diff --git a/.githooks/pre-commit b/.githooks/pre-commit new file mode 100755 index 000000000..1fa678fdd --- /dev/null +++ b/.githooks/pre-commit @@ -0,0 +1,20 @@ +#!/usr/bin/env sh +set -eu + +branch=$(git branch --show-current) + +if [ "$branch" != "main" ]; then + exit 0 +fi + +changed=$(git diff --cached --name-only) + +if printf '%s\n' "$changed" | grep -Eq '^(\.github/workflows/c-parser-main-guard\.yml|\.githooks/|docs/c_parser/|c_parser/|tests/(c_parser|parser/c|data/c)/|semantics/c2ir\.py)'; then + cat >&2 <<'MSG' +Blocked: C parser files are staged on main. + +Work on c-parser/main or a c-parser/* branch instead. The final main merge +requires the C parser readiness checklist to be complete and explicit approval. +MSG + exit 1 +fi diff --git a/.githooks/pre-merge-commit b/.githooks/pre-merge-commit new file mode 100755 index 000000000..ed1b70185 --- /dev/null +++ b/.githooks/pre-merge-commit @@ -0,0 +1,24 @@ +#!/usr/bin/env sh +set -eu + +branch=$(git branch --show-current) + +if [ "$branch" != "main" ]; then + exit 0 +fi + +if ! git rev-parse -q --verify MERGE_HEAD >/dev/null; then + exit 0 +fi + +merge_head=$(git rev-parse MERGE_HEAD) + +if git branch --all --contains "$merge_head" | grep -Eq '(^|[[:space:]])(remotes/origin/)?c-parser/'; then + cat >&2 <<'MSG' +Blocked: attempting to merge a c-parser/* branch into main. + +Merge C parser work into c-parser/main only. The final main merge requires the +C parser readiness checklist to be complete and explicit approval. +MSG + exit 1 +fi diff --git a/.githooks/pre-push b/.githooks/pre-push new file mode 100755 index 000000000..2dc29bf0e --- /dev/null +++ b/.githooks/pre-push @@ -0,0 +1,42 @@ +#!/usr/bin/env sh +set -eu + +current_branch=$(git branch --show-current) + +while read -r local_ref local_sha remote_ref remote_sha +do + case "$remote_ref" in + refs/heads/main) + ;; + *) + continue + ;; + esac + + if printf '%s\n' "$current_branch" | grep -Eq '^c-parser/'; then + cat >&2 <<'MSG' +Blocked: refusing to push a c-parser/* branch to remote main. + +Push C parser work to c-parser/main or another c-parser/* branch only. +MSG + exit 1 + fi + + if [ "$remote_sha" = "0000000000000000000000000000000000000000" ]; then + range="$local_sha" + else + range="$remote_sha..$local_sha" + fi + + changed=$(git diff --name-only "$range") + + if printf '%s\n' "$changed" | grep -Eq '^(\.github/workflows/c-parser-main-guard\.yml|\.githooks/|docs/c_parser/|c_parser/|tests/(c_parser|parser/c|data/c)/|semantics/c2ir\.py)'; then + cat >&2 <<'MSG' +Blocked: refusing to push C parser files to remote main. + +Push C parser work to c-parser/main. The final main merge requires the C parser +readiness checklist to be complete and explicit approval. +MSG + exit 1 + fi +done diff --git a/.github/workflows/c-parser-main-guard.yml b/.github/workflows/c-parser-main-guard.yml new file mode 100644 index 000000000..c06c002ea --- /dev/null +++ b/.github/workflows/c-parser-main-guard.yml @@ -0,0 +1,59 @@ +name: C Parser Main Guard + +on: + pull_request: + types: [opened, synchronize, reopened, labeled, unlabeled] + +jobs: + c-parser-main-guard: + runs-on: ubuntu-latest + steps: + - name: Checkout repository + uses: actions/checkout@v4 + with: + fetch-depth: 0 + + - name: Reject premature C parser work targeting main + env: + BASE_REF: ${{ github.event.pull_request.base.ref }} + BASE_SHA: ${{ github.event.pull_request.base.sha }} + HEAD_REF: ${{ github.event.pull_request.head.ref }} + HEAD_SHA: ${{ github.event.pull_request.head.sha }} + PR_LABELS: ${{ join(github.event.pull_request.labels.*.name, ',') }} + run: | + set -euo pipefail + + if [ "$BASE_REF" != "main" ]; then + echo "PR does not target main; C parser main guard does not apply." + exit 0 + fi + + ALLOW_LABEL="c-parser-ready-for-main" + + if echo ",${PR_LABELS}," | grep -Fq ",${ALLOW_LABEL},"; then + echo "${ALLOW_LABEL} label present; allowing C parser merge candidate." + exit 0 + fi + + CHANGED_FILES=$(git diff --name-only "$BASE_SHA" "$HEAD_SHA") + + echo "Base branch: $BASE_REF" + echo "Head branch: $HEAD_REF" + echo "Changed files:" + echo "$CHANGED_FILES" + + C_PARSER_PATH_PATTERN='^(\.github/workflows/c-parser-main-guard\.yml|\.githooks/|docs/c_parser/|c_parser/|tests/(c_parser|parser/c|data/c)/|semantics/c2ir\.py)' + + if echo "$HEAD_REF" | grep -Eq '^c-parser/'; then + echo "C parser branches must not target main before the C parser is ready." + echo "Target c-parser/main instead, or add ${ALLOW_LABEL} only for the final approved merge." + exit 1 + fi + + if echo "$CHANGED_FILES" | grep -Eq "$C_PARSER_PATH_PATTERN"; then + echo "C parser files changed in a PR targeting main." + echo "Target c-parser/main instead, or add ${ALLOW_LABEL} only for the final approved merge." + exit 1 + fi + + echo "No C parser branch or C parser paths detected in a PR targeting main." diff --git a/c_parser/__init__.py b/c_parser/__init__.py new file mode 100644 index 000000000..04e582071 --- /dev/null +++ b/c_parser/__init__.py @@ -0,0 +1,108 @@ +# -*- coding: utf-8 -*- +"""Public C parser package.""" + +from .models import ( + CArray, + CAtomic, + CBool, + CChar, + CComposedType, + CConst, + CDouble, + CDoubleComplex, + CDiagnostic, + CEnum, + CEnumerator, + CFile, + CFloat, + CFloatComplex, + CFunction, + CFunctionType, + CInclude, + CInitializer, + CInt, + CLong, + CLongDouble, + CLongDoubleComplex, + CLongLong, + CMacro, + CMacroDependency, + CParameter, + CParseError, + CPointer, + CProject, + CQualifier, + CRawDirective, + CRestrict, + CShort, + CSignedChar, + CSourceLocation, + CStruct, + CType, + CTypedef, + CUnknownType, + CUnion, + CUnsignedChar, + CUnsignedInt, + CUnsignedLong, + CUnsignedLongLong, + CUnsignedShort, + CVariable, + CVoid, + CVolatile, +) +from .parser import CParser, parse_c_file, parse_c_project + +__all__ = ( + "CArray", + "CAtomic", + "CBool", + "CChar", + "CComposedType", + "CConst", + "CDouble", + "CDoubleComplex", + "CDiagnostic", + "CEnum", + "CEnumerator", + "CFile", + "CFloat", + "CFloatComplex", + "CFunction", + "CFunctionType", + "CInclude", + "CInitializer", + "CInt", + "CLong", + "CLongDouble", + "CLongDoubleComplex", + "CLongLong", + "CMacro", + "CMacroDependency", + "CParameter", + "CParseError", + "CPointer", + "CParser", + "CProject", + "CQualifier", + "CRawDirective", + "CRestrict", + "CShort", + "CSignedChar", + "CSourceLocation", + "CStruct", + "CType", + "CTypedef", + "CUnion", + "CUnknownType", + "CUnsignedChar", + "CUnsignedInt", + "CUnsignedLong", + "CUnsignedLongLong", + "CUnsignedShort", + "CVariable", + "CVoid", + "CVolatile", + "parse_c_file", + "parse_c_project", +) diff --git a/c_parser/__main__.py b/c_parser/__main__.py new file mode 100644 index 000000000..162973276 --- /dev/null +++ b/c_parser/__main__.py @@ -0,0 +1,7 @@ +# -*- coding: utf-8 -*- +"""Run the C parser CLI.""" + +from .cli import main + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/c_parser/cli.py b/c_parser/cli.py new file mode 100644 index 000000000..4797bbdf7 --- /dev/null +++ b/c_parser/cli.py @@ -0,0 +1,87 @@ +# -*- coding: utf-8 -*- +from __future__ import annotations + +import argparse +import json +from pathlib import Path + +from .models import CFile, c_model_to_dict +from .parser import CParser + + +_C_SOURCE_SUFFIXES = {".c", ".h"} + + +def _collect_c_extensions(path: Path) -> list[Path]: + return sorted( + p + for p in path.rglob("*") + if p.is_file() and p.suffix.lower() in _C_SOURCE_SUFFIXES + ) + + +def expand_c_paths(paths: list[str]) -> list[Path]: + expanded: list[Path] = [] + for raw in paths: + p = Path(raw) + if p.is_dir(): + expanded.extend(_collect_c_extensions(p)) + else: + expanded.append(p) + return sorted(set(expanded)) + + +def parse_c_report(paths: list[str]) -> dict[str, dict]: + out: dict[str, dict] = {} + parser = CParser() + for p in expand_c_paths(paths): + parsed = parser.visit_file(p, filename=str(p)) + out[str(p)] = c_model_to_dict(parsed) + return out + + +def format_c_report(report: dict[str, dict]) -> str: + lines: list[str] = [] + for fname, parsed in report.items(): + lines.append(f"File: {fname}") + lines.append(f" Language: {parsed.get('language', 'c')}") + lines.append(f" Functions: {len(parsed.get('functions') or [])}") + lines.append(f" Structs: {len(parsed.get('structs') or [])}") + lines.append(f" Unions: {len(parsed.get('unions') or [])}") + lines.append(f" Enums: {len(parsed.get('enums') or [])}") + lines.append(f" Typedefs: {len(parsed.get('typedefs') or [])}") + lines.append(f" Variables: {len(parsed.get('variables') or [])}") + lines.append(f" Macros: {len(parsed.get('macros') or [])}") + lines.append(f" Includes: {len(parsed.get('includes') or [])}") + lines.append(f" Diagnostics: {len(parsed.get('diagnostics') or [])}") + lines.append(f" Parser status: {parsed.get('parser_status', 'partial')}") + lines.append("") + return "\n".join(lines).rstrip() + + +def main(argv: list[str] | None = None) -> int: + parser = argparse.ArgumentParser(description="C parser CLI for the implemented C subset.") + parser.add_argument("paths", nargs="+", help="C source/header file(s) or directory path(s)") + parser.add_argument("--json", action="store_true", help="Print JSON to stdout") + parser.add_argument("--out", type=str, help="Write parser JSON to a file") + args = parser.parse_args(argv) + + payload = parse_c_report(args.paths) + if args.out: + Path(args.out).write_text(json.dumps(payload, indent=2), encoding="utf-8") + return 0 + + if args.json: + print(json.dumps(payload, indent=2)) + else: + print(format_c_report(payload)) + return 0 + + +__all__ = ( + "CFile", + "expand_c_paths", + "format_c_report", + "main", + "parse_c_report", +) diff --git a/c_parser/lexer.py b/c_parser/lexer.py new file mode 100644 index 000000000..89882a771 --- /dev/null +++ b/c_parser/lexer.py @@ -0,0 +1,592 @@ +# -*- coding: utf-8 -*- +from __future__ import annotations + +from dataclasses import dataclass, field + + +@dataclass(frozen=True) +class CLogicalRecord: + """A comment-stripped logical C source record with original line mapping.""" + + text: str + filename: str | None = None + original_start_line: int = 1 + original_end_line: int = 1 + original_source_lines: tuple[str, ...] = field(default_factory=tuple) + + @property + def source_line(self) -> str | None: + return self.original_source_lines[0] if self.original_source_lines else None + + +@dataclass(frozen=True) +class NormalizedCSource: + filename: str | None + records: list[CLogicalRecord] + + +@dataclass(frozen=True) +class CToken: + text: str + kind: str + filename: str | None = None + line: int = 1 + column: int = 1 + source_line: str | None = None + + +@dataclass(frozen=True) +class CTopLevelSegment: + """A top-level C declaration or function-definition header.""" + + text: str + terminator: str + filename: str | None = None + original_start_line: int = 1 + original_end_line: int = 1 + original_start_column: int = 1 + original_end_column: int = 1 + original_source_line: str | None = None + original_end_source_line: str | None = None + original_source_lines: tuple[str, ...] = field(default_factory=tuple) + + +_TWO_CHAR_OPERATORS = { + "++", + "--", + "->", + "==", + "!=", + "<=", + ">=", + "&&", + "||", + "+=", + "-=", + "*=", + "/=", + "%=", + "&=", + "|=", + "^=", + "<<", + ">>", +} + +_BRACKET_PAIRS = {"(": ")", "[": "]", "{": "}"} +_BRACKET_CLOSERS = {")": "(", "]": "[", "}": "{"} + + +def _source_line(lines: list[str], line_number: int) -> str | None: + if 1 <= line_number <= len(lines): + return lines[line_number - 1] + return None + + +def _source_lines(lines: list[str], start_line: int, end_line: int) -> tuple[str, ...]: + return tuple(lines[start_line - 1 : end_line]) + + +def _advance_position(char: str, line: int, column: int) -> tuple[int, int]: + if char == "\n": + return line + 1, 1 + return line, column + 1 + + +def _blank_preprocessor_directives(source: str) -> str: + """Replace preprocessor directive logical lines with spaces.""" + out_lines: list[str] = [] + in_directive = False + for line in source.splitlines(keepends=True): + stripped = line.lstrip() + starts_directive = stripped.startswith("#") + if in_directive or starts_directive: + newline = "\n" if line.endswith("\n") else "" + body = line[:-1] if newline else line + out_lines.append(" " * len(body) + newline) + in_directive = body.rstrip().endswith("\\") + continue + out_lines.append(line) + in_directive = False + return "".join(out_lines) + + +def _scan_code_states(text: str): + state = "normal" + quote = "" + escaped = False + stack: list[str] = [] + + for index, char in enumerate(text): + if state in {"string", "char"}: + yield index, char, tuple(stack), state + if escaped: + escaped = False + continue + if char == "\\": + escaped = True + continue + if char == quote: + state = "normal" + quote = "" + continue + + yield index, char, tuple(stack), state + + if char in {'"', "'"}: + state = "string" if char == '"' else "char" + quote = char + escaped = False + elif char in _BRACKET_PAIRS: + stack.append(char) + elif char in _BRACKET_CLOSERS and stack and stack[-1] == _BRACKET_CLOSERS[char]: + stack.pop() + + +def top_level_split_with_offsets(text: str, delimiter: str = ",") -> list[tuple[str, int]]: + """Split outside nested syntax and preserve each trimmed fragment offset.""" + if len(delimiter) != 1: + raise ValueError("top_level_split_with_offsets delimiter must be a single character") + + parts: list[tuple[str, int]] = [] + start = 0 + for index, char, stack, state in _scan_code_states(text): + if state == "normal" and not stack and char == delimiter: + raw_part = text[start:index] + part = raw_part.strip() + if part: + parts.append((part, start + len(raw_part) - len(raw_part.lstrip()))) + start = index + 1 + + raw_tail = text[start:] + tail = raw_tail.strip() + if tail: + parts.append((tail, start + len(raw_tail) - len(raw_tail.lstrip()))) + return parts + + +def top_level_split(text: str, delimiter: str = ",") -> list[str]: + """Split on a delimiter that appears outside brackets and literals.""" + return [part for part, _offset in top_level_split_with_offsets(text, delimiter)] + + +def top_level_partition(text: str, delimiter: str = "=") -> tuple[str, str | None]: + """Partition once on a top-level delimiter outside brackets and literals.""" + if len(delimiter) != 1: + raise ValueError("top_level_partition delimiter must be a single character") + + for index, char, stack, state in _scan_code_states(text): + if state == "normal" and not stack and char == delimiter: + return text[:index].strip(), text[index + 1 :].strip() + return text.strip(), None + + +def _is_aggregate_definition_header(header: str) -> bool: + """Identify a tag definition before deciding that a brace starts a body.""" + compact = " ".join(header.split()) + if "(" in compact or "=" in compact: + return False + words = compact.split() + return any(word in {"struct", "union", "enum"} for word in words) + + +def split_top_level_c_source( + source: str, + filename: str | None = None, + *, + skip_preprocessor: bool = True, +) -> list[CTopLevelSegment]: + """Split C source into top-level declarations and definition headers.""" + stripped = strip_c_comments(source) + if skip_preprocessor: + stripped = _blank_preprocessor_directives(stripped) + + source_lines = source.splitlines() + segments: list[CTopLevelSegment] = [] + start_index: int | None = None + start_line = 1 + start_column = 1 + line = 1 + column = 1 + i = 0 + paren_depth = 0 + bracket_depth = 0 + brace_depth = 0 + state = "normal" + quote = "" + escaped = False + block_header: str | None = None + block_start_line = 1 + block_start_column = 1 + block_source_line: str | None = None + aggregate_block = False + + while i < len(stripped): + char = stripped[i] + + if state in {"string", "char"}: + if brace_depth == 0 and start_index is None and not char.isspace(): + start_index = i + start_line = line + start_column = column + if escaped: + escaped = False + elif char == "\\": + escaped = True + elif char == quote: + state = "normal" + quote = "" + line, column = _advance_position(char, line, column) + i += 1 + continue + + if char in {'"', "'"}: + if brace_depth == 0 and start_index is None and not char.isspace(): + start_index = i + start_line = line + start_column = column + state = "string" if char == '"' else "char" + quote = char + escaped = False + line, column = _advance_position(char, line, column) + i += 1 + continue + + if brace_depth == 0 and start_index is None and not char.isspace(): + start_index = i + start_line = line + start_column = column + + if char == "(": + paren_depth += 1 + elif char == ")" and paren_depth: + paren_depth -= 1 + elif char == "[": + bracket_depth += 1 + elif char == "]" and bracket_depth: + bracket_depth -= 1 + elif char == "{" and paren_depth == 0 and bracket_depth == 0 and brace_depth == 0: + if start_index is not None: + header = stripped[start_index:i].strip() + if header: + block_header = header + block_start_line = start_line + block_start_column = start_column + block_source_line = _source_line(source_lines, start_line) + aggregate_block = _is_aggregate_definition_header(header) + brace_depth = 1 + if not aggregate_block: + start_index = None + elif char == "{" and brace_depth: + brace_depth += 1 + elif char == "}" and brace_depth: + brace_depth -= 1 + if brace_depth == 0 and block_header and not aggregate_block: + segments.append( + CTopLevelSegment( + text=block_header, + terminator="block", + filename=filename, + original_start_line=block_start_line, + original_end_line=line, + original_start_column=block_start_column, + original_end_column=column, + original_source_line=block_source_line, + original_end_source_line=_source_line(source_lines, line), + original_source_lines=_source_lines(source_lines, block_start_line, line), + ) + ) + block_header = None + block_source_line = None + elif ( + char == ";" + and paren_depth == 0 + and bracket_depth == 0 + and brace_depth == 0 + and start_index is not None + ): + text = stripped[start_index:i].strip() + if text: + segments.append( + CTopLevelSegment( + text=text, + terminator=";", + filename=filename, + original_start_line=start_line, + original_end_line=line, + original_start_column=start_column, + original_end_column=column, + original_source_line=_source_line(source_lines, start_line), + original_end_source_line=_source_line(source_lines, line), + original_source_lines=_source_lines(source_lines, start_line, line), + ) + ) + start_index = None + block_header = None + block_source_line = None + aggregate_block = False + + line, column = _advance_position(char, line, column) + i += 1 + + if start_index is not None and brace_depth == 0: + text = stripped[start_index:].strip() + if text: + segments.append( + CTopLevelSegment( + text=text, + terminator="eof", + filename=filename, + original_start_line=start_line, + original_end_line=line, + original_start_column=start_column, + original_end_column=column, + original_source_line=_source_line(source_lines, start_line), + original_end_source_line=_source_line(source_lines, line), + original_source_lines=_source_lines(source_lines, start_line, line), + ) + ) + + return segments + + +def strip_c_comments(source: str) -> str: + """Remove C comments while preserving line and column accounting.""" + out: list[str] = [] + i = 0 + state = "normal" + quote = "" + + while i < len(source): + char = source[i] + nxt = source[i + 1] if i + 1 < len(source) else "" + + if state == "line_comment": + if char == "\n": + out.append(char) + state = "normal" + else: + out.append(" ") + i += 1 + continue + + if state == "block_comment": + if char == "*" and nxt == "/": + out.extend((" ", " ")) + i += 2 + state = "normal" + continue + out.append("\n" if char == "\n" else " ") + i += 1 + continue + + if state in {"string", "char"}: + out.append(char) + if char == "\\" and nxt: + out.append(nxt) + i += 2 + continue + if char == quote: + state = "normal" + quote = "" + i += 1 + continue + + if char == "/" and nxt == "/": + out.extend((" ", " ")) + i += 2 + state = "line_comment" + continue + if char == "/" and nxt == "*": + out.extend((" ", " ")) + i += 2 + state = "block_comment" + continue + if char in {'"', "'"}: + state = "string" if char == '"' else "char" + quote = char + out.append(char) + i += 1 + continue + + out.append(char) + i += 1 + + return "".join(out) + + +def normalize_c_source(source: str, filename: str | None = None) -> NormalizedCSource: + """Fold C logical records after safe comment removal.""" + stripped = strip_c_comments(source) + stripped_lines = stripped.splitlines() + original_lines = source.splitlines() + + records: list[CLogicalRecord] = [] + pending_text: str | None = None + pending_start_line = 1 + pending_source_lines: list[str] = [] + + for index, stripped_line in enumerate(stripped_lines, start=1): + original_line = original_lines[index - 1] if index - 1 < len(original_lines) else "" + line = stripped_line.rstrip() + continued = line.endswith("\\") + part = line[:-1].rstrip() if continued else line + + if pending_text is None: + pending_text = part + pending_start_line = index + pending_source_lines = [original_line] + else: + pending_text = f"{pending_text} {part.lstrip()}" + pending_source_lines.append(original_line) + + if continued: + continue + + if pending_text.strip(): + records.append( + CLogicalRecord( + text=pending_text.strip(), + filename=filename, + original_start_line=pending_start_line, + original_end_line=index, + original_source_lines=tuple(pending_source_lines), + ) + ) + pending_text = None + pending_source_lines = [] + + if pending_text is not None and pending_text.strip(): + records.append( + CLogicalRecord( + text=pending_text.strip(), + filename=filename, + original_start_line=pending_start_line, + original_end_line=len(stripped_lines), + original_source_lines=tuple(pending_source_lines), + ) + ) + + return NormalizedCSource(filename=filename, records=records) + + +def lex_c_source(source: str, filename: str | None = None) -> list[CToken]: + """Tokenize a small C lexical subset for parser staging tests.""" + stripped = strip_c_comments(source) + source_lines = source.splitlines() + tokens: list[CToken] = [] + i = 0 + line = 1 + column = 1 + + while i < len(stripped): + char = stripped[i] + nxt = stripped[i + 1] if i + 1 < len(stripped) else "" + + if char == "\n": + line += 1 + column = 1 + i += 1 + continue + if char.isspace(): + column += 1 + i += 1 + continue + + start_line = line + start_column = column + source_line = _source_line(source_lines, start_line) + + if char in {'"', "'"}: + quote = char + text = [char] + i += 1 + column += 1 + while i < len(stripped): + current = stripped[i] + text.append(current) + i += 1 + column += 1 + if current == "\\" and i < len(stripped): + text.append(stripped[i]) + i += 1 + column += 1 + continue + if current == quote: + break + tokens.append( + CToken( + text="".join(text), + kind="string" if quote == '"' else "char", + filename=filename, + line=start_line, + column=start_column, + source_line=source_line, + ) + ) + continue + + if char.isalpha() or char == "_": + start = i + while i < len(stripped) and (stripped[i].isalnum() or stripped[i] == "_"): + i += 1 + column += 1 + tokens.append( + CToken( + text=stripped[start:i], + kind="identifier", + filename=filename, + line=start_line, + column=start_column, + source_line=source_line, + ) + ) + continue + + if char.isdigit(): + start = i + while i < len(stripped) and (stripped[i].isalnum() or stripped[i] in "._"): + i += 1 + column += 1 + tokens.append( + CToken( + text=stripped[start:i], + kind="number", + filename=filename, + line=start_line, + column=start_column, + source_line=source_line, + ) + ) + continue + + text = char + nxt if char + nxt in _TWO_CHAR_OPERATORS else char + i += len(text) + column += len(text) + tokens.append( + CToken( + text=text, + kind="punctuation", + filename=filename, + line=start_line, + column=start_column, + source_line=source_line, + ) + ) + + return tokens + + +__all__ = ( + "CLogicalRecord", + "CToken", + "CTopLevelSegment", + "NormalizedCSource", + "lex_c_source", + "normalize_c_source", + "split_top_level_c_source", + "strip_c_comments", + "top_level_partition", + "top_level_split", + "top_level_split_with_offsets", +) diff --git a/c_parser/models.py b/c_parser/models.py new file mode 100644 index 000000000..4a553c81d --- /dev/null +++ b/c_parser/models.py @@ -0,0 +1,534 @@ +# -*- coding: utf-8 -*- +from __future__ import annotations + +import inspect +import os +import sys +from dataclasses import dataclass, field, fields, is_dataclass +from typing import Any + + +_ANSI = { + "bold": "\033[1m", + "red": "\033[31m", + "blue": "\033[34m", + "cyan": "\033[36m", + "reset": "\033[0m", +} +_TRUE_VALUES = {"1", "true", "yes", "on"} + + +def _env_flag(name: str) -> bool: + return os.getenv(name, "").strip().lower() in _TRUE_VALUES + + +def _apply_color(text: str, *styles: str, enabled: bool) -> str: + if not enabled: + return text + prefix = "".join(_ANSI[style] for style in styles) + return f"{prefix}{text}{_ANSI['reset']}" + + +def _enable_windows_ansi() -> None: # pragma: no cover - Windows-only console setup. + if os.name != "nt": + return + + if sys.modules.get("colorama") is not None: + sys.modules["colorama"].just_fix_windows_console() + return + + import importlib.util + + if importlib.util.find_spec("colorama") is not None: + import importlib + + colorama = importlib.import_module("colorama") + colorama.just_fix_windows_console() + + +def c_model_to_dict(obj: Any, _seen: set[int] | None = None) -> Any: + """Convert C parser dataclasses into stable JSON-compatible values.""" + if _seen is None: + _seen = set() + if isinstance(obj, CQualifier): + return obj.spelling + if isinstance(obj, CType): + if isinstance(obj, (CStruct, CUnion, CEnum, CTypedef)) and id(obj) in _seen: + return {"reference": obj.reference_name} + if isinstance(obj, (CStruct, CUnion, CEnum, CTypedef)): + _seen.add(id(obj)) + payload = {"model": type(obj).__name__} + payload.update({f.name: c_model_to_dict(getattr(obj, f.name), _seen) for f in fields(obj)}) + return payload + if is_dataclass(obj): + return {f.name: c_model_to_dict(getattr(obj, f.name), _seen) for f in fields(obj)} + if isinstance(obj, list): + return [c_model_to_dict(v, _seen) for v in obj] + if isinstance(obj, dict): + return {k: c_model_to_dict(v, _seen) for k, v in obj.items()} + if isinstance(obj, set): + return sorted(c_model_to_dict(v, _seen) for v in obj) + return obj + + +class CParseError(ValueError): + """C parser error with compiler-style diagnostic rendering support.""" + + default_code = "CPARSE001" + + def __init__( + self, + message: str, + filename: str | None = None, + line_number: int | None = None, + column: int | None = None, + source_line: str | None = None, + *, + code: str | None = None, + ): + self.filename = filename + self.line_number = line_number + self.column = column + self.source_line = source_line + self.base_message = message + self.code = code or self.default_code + frame = inspect.stack()[1] + self.parser_file = frame.filename + self.parser_line_number = frame.lineno + self.parser_function = frame.function + super().__init__(self.format_diagnostic(color=False)) + + def format_diagnostic(self, *, color: bool = False, debug: bool | None = None) -> str: + if color: + _enable_windows_ansi() + if debug is None: + debug = _env_flag("C_PARSER_DEBUG") + + location = self.filename or "" + if self.line_number is not None: + column = self.column if self.column is not None else 1 + location = f"{location}:{self.line_number}:{column}" + + severity = _apply_color("error", "red", "bold", enabled=color) + code = _apply_color(f"[{self.code}]", "cyan", enabled=color) + lines = [f"{_apply_color(location, 'bold', enabled=color)}: {severity}{code}: {self.base_message}"] + + if self.source_line is not None: + line_no = str(self.line_number) if self.line_number is not None else "?" + gutter_width = max(len(line_no), 1) + source = self.source_line.rstrip("\n") + marker_column = max((self.column or 1) - 1, 0) + marker = " " * marker_column + "^" if source.strip() else "" + lines.extend( + [ + f"{' ' * gutter_width} {_apply_color('|', 'blue', enabled=color)}", + f"{_apply_color(line_no.rjust(gutter_width), 'blue', enabled=color)} {_apply_color('|', 'blue', enabled=color)} {source}", + f"{' ' * gutter_width} {_apply_color('|', 'blue', enabled=color)} {_apply_color(marker, 'red', 'bold', enabled=color)}", + ] + ) + + if debug: + lines.append( + _apply_color( + f"note: parser raised at {self.parser_file}:{self.parser_line_number} in {self.parser_function}()", + "cyan", + enabled=color, + ) + ) + + return "\n".join(lines) + + +@dataclass +class CSourceLocation: + filename: str | None = None + line: int | None = None + column: int | None = None + source_line: str | None = None + + @property + def display(self) -> str: + location = self.filename or "" + if self.line is not None: + column = self.column if self.column is not None else 1 + location = f"{location}:{self.line}:{column}" + return location + + +@dataclass +class CDiagnostic: + code: str + message: str + severity: str = "warning" + location: CSourceLocation | None = None + unit_kind: str | None = None + unit_name: str | None = None + + +@dataclass(frozen=True) +class CQualifier: + spelling: str + + +@dataclass(frozen=True) +class CConst(CQualifier): + spelling: str = "const" + + +@dataclass(frozen=True) +class CVolatile(CQualifier): + spelling: str = "volatile" + + +@dataclass(frozen=True) +class CRestrict(CQualifier): + spelling: str = "restrict" + + +@dataclass(frozen=True) +class CAtomic(CQualifier): + spelling: str = "_Atomic" + + +@dataclass(kw_only=True) +class CType: + qualifiers: list[CQualifier] = field(default_factory=list) + source_text: str = "" + + +@dataclass +class CUnknownType(CType): + spelling: str = "unknown" + + +@dataclass +class CVoid(CType): + pass + + +@dataclass +class CBool(CType): + pass + + +@dataclass +class CChar(CType): + pass + + +@dataclass +class CSignedChar(CType): + pass + + +@dataclass +class CUnsignedChar(CType): + pass + + +@dataclass +class CShort(CType): + pass + + +@dataclass +class CUnsignedShort(CType): + pass + + +@dataclass +class CInt(CType): + pass + + +@dataclass +class CUnsignedInt(CType): + pass + + +@dataclass +class CLong(CType): + pass + + +@dataclass +class CUnsignedLong(CType): + pass + + +@dataclass +class CLongLong(CType): + pass + + +@dataclass +class CUnsignedLongLong(CType): + pass + + +@dataclass +class CFloat(CType): + pass + + +@dataclass +class CDouble(CType): + pass + + +@dataclass +class CLongDouble(CType): + pass + + +@dataclass +class CFloatComplex(CType): + pass + + +@dataclass +class CDoubleComplex(CType): + pass + + +@dataclass +class CLongDoubleComplex(CType): + pass + + +@dataclass +class CPointer(CType): + pass + + +@dataclass +class CArray(CType): + bound: str | None = None + is_static_minimum: bool = False + is_variable_length: bool = False + is_flexible: bool = False + + +@dataclass +class CFunctionType(CType): + result_type: CType = field(default_factory=CVoid) + parameter_types: list[CType] = field(default_factory=list) + is_variadic: bool = False + prototype_style: str | None = None + + +@dataclass +class CComposedType(CType): + components: list[CType] = field(default_factory=list) + + @property + def pointer_depth(self) -> int: + return sum(isinstance(component, CPointer) for component in self.components) + + @property + def array_rank(self) -> int: + return sum(isinstance(component, CArray) for component in self.components) + + +def _contains_function_pointer(type_: CType) -> bool: + if not isinstance(type_, CComposedType): + return False + for index, component in enumerate(type_.components): + if isinstance(component, CPointer) and any( + isinstance(later, CFunctionType) for later in type_.components[index + 1 :] + ): + return True + return False + + +@dataclass +class CParameter: + name: str | None = None + type: CType = field(default_factory=CVoid) + declared_type: CType | None = None + source_location: CSourceLocation | None = None + callback_policy: Any = None + + @property + def callback_candidate(self) -> bool: + return _contains_function_pointer(self.type) + + +@dataclass +class CFunction: + name: str + result_type: CType = field(default_factory=CVoid) + parameters: list[CParameter] = field(default_factory=list) + storage: list[str] = field(default_factory=list) + specifiers: list[str] = field(default_factory=list) + is_variadic: bool = False + is_definition: bool = False + prototype_style: str | None = None + source_location: CSourceLocation | None = None + start: CSourceLocation | None = None + end: CSourceLocation | None = None + declaration_locations: list[CSourceLocation] = field(default_factory=list) + + @property + def type(self) -> CFunctionType: + return CFunctionType( + result_type=self.result_type, + parameter_types=[parameter.type for parameter in self.parameters], + is_variadic=self.is_variadic, + prototype_style=self.prototype_style, + ) + + +@dataclass +class CStruct(CType): + name: str | None = None + members: list["CVariable"] = field(default_factory=list) + anonymous_id: str | None = None + is_incomplete: bool = False + source_location: CSourceLocation | None = None + + @property + def reference_name(self) -> str: + return f"struct {self.name}" if self.name else self.anonymous_id or "anonymous struct" + + +@dataclass +class CUnion(CType): + name: str | None = None + members: list["CVariable"] = field(default_factory=list) + anonymous_id: str | None = None + is_incomplete: bool = False + source_location: CSourceLocation | None = None + + @property + def reference_name(self) -> str: + return f"union {self.name}" if self.name else self.anonymous_id or "anonymous union" + + +@dataclass +class CEnumerator: + name: str + value: str | None = None + source_location: CSourceLocation | None = None + + +@dataclass +class CEnum(CType): + name: str | None = None + constants: list[CEnumerator] = field(default_factory=list) + anonymous_id: str | None = None + source_location: CSourceLocation | None = None + + @property + def reference_name(self) -> str: + return f"enum {self.name}" if self.name else self.anonymous_id or "anonymous enum" + + +@dataclass +class CTypedef(CType): + name: str + type: CType | None = None + source_location: CSourceLocation | None = None + declaration_locations: list[CSourceLocation] = field(default_factory=list) + + @property + def reference_name(self) -> str: + return self.name + + +@dataclass +class CInitializer: + source_text: str + + +@dataclass +class CVariable: + name: str | None + type: CType = field(default_factory=CVoid) + storage: list[str] = field(default_factory=list) + initializer: CInitializer | None = None + bit_width: str | None = None + source_location: CSourceLocation | None = None + callback_policy: Any = None + declaration_locations: list[CSourceLocation] = field(default_factory=list) + + @property + def callback_candidate(self) -> bool: + return _contains_function_pointer(self.type) + + +@dataclass +class CMacro: + name: str + value: str | None = None + function_like: bool = False + directive: str = "define" + source_location: CSourceLocation | None = None + + +@dataclass +class CRawDirective: + directive: str + argument: str | None = None + source_location: CSourceLocation | None = None + + +@dataclass +class CMacroDependency: + name: str + context: str = "declaration" + source_location: CSourceLocation | None = None + source_text: str = "" + + +@dataclass +class CInclude: + target: str + kind: str = "local" + resolved_path: str | None = None + source_location: CSourceLocation | None = None + + +@dataclass +class CFile: + filename: str | None = None + language: str = "c" + parser_status: str = "partial" + preprocessing: str = "raw" + functions: list[CFunction] = field(default_factory=list) + structs: list[CStruct] = field(default_factory=list) + unions: list[CUnion] = field(default_factory=list) + enums: list[CEnum] = field(default_factory=list) + typedefs: list[CTypedef] = field(default_factory=list) + variables: list[CVariable] = field(default_factory=list) + macros: list[CMacro] = field(default_factory=list) + includes: list[CInclude] = field(default_factory=list) + raw_directives: list[CRawDirective] = field(default_factory=list) + macro_dependencies: list[CMacroDependency] = field(default_factory=list) + diagnostics: list[CDiagnostic] = field(default_factory=list) + + def to_dict(self) -> dict[str, Any]: + return c_model_to_dict(self) + + +@dataclass +class CProject: + files: dict[str, CFile] = field(default_factory=dict) + functions: dict[str, CFunction] = field(default_factory=dict) + structs: dict[str, CStruct] = field(default_factory=dict) + unions: dict[str, CUnion] = field(default_factory=dict) + enums: dict[str, CEnum] = field(default_factory=dict) + typedefs: dict[str, CTypedef] = field(default_factory=dict) + variables: dict[str, CVariable] = field(default_factory=dict) + macros: dict[str, CMacro] = field(default_factory=dict) + includes: dict[str, CInclude] = field(default_factory=dict) + functions_by_file: dict[str, list[str]] = field(default_factory=dict) + enum_constants: dict[str, CEnumerator] = field(default_factory=dict) + include_graph: dict[str, set[str]] = field(default_factory=dict) + system_includes: dict[str, set[str]] = field(default_factory=dict) + unresolved_includes: dict[str, set[str]] = field(default_factory=dict) + header_source_pairs: dict[str, set[str]] = field(default_factory=dict) + diagnostics: list[CDiagnostic] = field(default_factory=list) + + def to_dict(self) -> dict[str, Any]: + return c_model_to_dict(self) diff --git a/c_parser/parser.py b/c_parser/parser.py new file mode 100644 index 000000000..3501abe9f --- /dev/null +++ b/c_parser/parser.py @@ -0,0 +1,2171 @@ +# -*- coding: utf-8 -*- +from __future__ import annotations + +from dataclasses import dataclass +import re +from collections.abc import Mapping, Sequence +from pathlib import Path, PurePosixPath + +from .lexer import ( + CTopLevelSegment, + split_top_level_c_source, + strip_c_comments, + top_level_partition, + top_level_split, + top_level_split_with_offsets, +) +from .models import ( + CArray, + CAtomic, + CBool, + CChar, + CComposedType, + CConst, + CDouble, + CDoubleComplex, + CDiagnostic, + CEnum, + CEnumerator, + CFile, + CFloat, + CFloatComplex, + CFunction, + CFunctionType, + CParameter, + CParseError, + CPointer, + CProject, + CRestrict, + CSourceLocation, + CShort, + CSignedChar, + CStruct, + CType, + CTypedef, + CUnion, + CUnknownType, + CUnsignedChar, + CUnsignedInt, + CUnsignedLong, + CUnsignedLongLong, + CUnsignedShort, + CVariable, + CVoid, + CVolatile, + CInt, + CInitializer, + CLong, + CLongDouble, + CLongDoubleComplex, + CLongLong, + CMacroDependency, +) +from .preprocessor import collect_preprocessor_metadata +from .type_resolver import resolve_project_types + + +_C_SOURCE_SUFFIXES = {".c", ".h"} +_IDENTIFIER_RE = re.compile(r"[A-Za-z_]\w*") +_STORAGE_CLASSES = {"typedef", "extern", "static", "register", "_Thread_local"} +_TYPE_QUALIFIERS = {"const", "restrict", "volatile", "_Atomic"} +_FUNCTION_SPECIFIERS = {"inline", "_Noreturn"} +_TAG_KINDS = {"struct", "union", "enum"} +_UNSUPPORTED_DECLARATION_MARKERS = ( + "__attribute__", + "__declspec", + "[[", + "_Alignas", + "alignas", + "_Atomic(", +) +_PRIMITIVE_WORDS = { + "void", + "char", + "short", + "int", + "long", + "float", + "double", + "signed", + "unsigned", + "_Bool", + "_Complex", +} +_QUALIFIER_CLASSES = { + "const": CConst, + "volatile": CVolatile, + "restrict": CRestrict, + "_Atomic": CAtomic, +} +_PRIMITIVE_TYPES = { + "void": CVoid, + "_Bool": CBool, + "char": CChar, + "signed char": CSignedChar, + "unsigned char": CUnsignedChar, + "short": CShort, + "short int": CShort, + "signed short": CShort, + "signed short int": CShort, + "unsigned short": CUnsignedShort, + "unsigned short int": CUnsignedShort, + "int": CInt, + "signed": CInt, + "signed int": CInt, + "unsigned": CUnsignedInt, + "unsigned int": CUnsignedInt, + "long": CLong, + "long int": CLong, + "signed long": CLong, + "signed long int": CLong, + "unsigned long": CUnsignedLong, + "unsigned long int": CUnsignedLong, + "long long": CLongLong, + "long long int": CLongLong, + "signed long long": CLongLong, + "signed long long int": CLongLong, + "unsigned long long": CUnsignedLongLong, + "unsigned long long int": CUnsignedLongLong, + "float": CFloat, + "double": CDouble, + "long double": CLongDouble, + "float _Complex": CFloatComplex, + "_Complex": CDoubleComplex, + "double _Complex": CDoubleComplex, + "long double _Complex": CLongDoubleComplex, +} +_PRIMITIVE_TYPE_SIGNATURES = { + tuple(sorted(spelling.split())): type_class + for spelling, type_class in _PRIMITIVE_TYPES.items() +} + + +@dataclass +class _PointerOp: + qualifiers: list[str] + + +@dataclass +class _ArrayOp: + size: str | None = None + static: bool = False + qualifiers: list[str] | None = None + variable_length: bool = False + + +@dataclass +class _FunctionOp: + parameters: list[CParameter] + variadic: bool = False + prototype_style: str | None = None + + +@dataclass +class _ParsedDeclarator: + name: str | None + operations: list[_PointerOp | _ArrayOp | _FunctionOp] + source_text: str = "" + + +class _UnsupportedDeclaratorSyntax(ValueError): + pass + + +class _InvalidSpecifierSequence(ValueError): + pass + + +def _looks_like_existing_source_path(value: object) -> bool: + if isinstance(value, Path): + return value.is_file() + if not isinstance(value, str) or not value or "\n" in value: + return False + try: + return Path(value).is_file() + except OSError: + return False + + +def _collect_c_paths(path: Path) -> list[Path]: + return sorted( + p + for p in path.rglob("*") + if p.is_file() and p.suffix.lower() in _C_SOURCE_SUFFIXES + ) + + +def _posix_key(path: str | Path | PurePosixPath) -> str: + return PurePosixPath(str(path)).as_posix() + + +def _include_key_from_current(current_key: str, target: str) -> str: + current_parent = PurePosixPath(current_key).parent + if str(current_parent) == ".": + return _posix_key(target) + return _posix_key(current_parent / target) + + +def _is_header_key(key: str) -> bool: + return PurePosixPath(key).suffix.lower() == ".h" + + +def _is_source_key(key: str) -> bool: + return PurePosixPath(key).suffix.lower() == ".c" + + +class CParser: + """C parser entrypoint for the currently implemented C subset. + + The implemented subset covers raw preprocessing metadata, recursive + declarators, aggregate declarations, typedefs, and function signatures. + """ + + def _source_location_at(self, segment: CTopLevelSegment, offset: int) -> CSourceLocation: + prefix = segment.text[:offset] + line_offset = prefix.count("\n") + line = segment.original_start_line + line_offset + if line_offset: + column = len(prefix.rsplit("\n", 1)[-1]) + 1 + else: + column = segment.original_start_column + len(prefix) + source_line = segment.original_source_line + if line_offset and line_offset < len(segment.original_source_lines): + source_line = segment.original_source_lines[line_offset] + return CSourceLocation( + filename=segment.filename, + line=line, + column=column, + source_line=source_line, + ) + + def _source_location(self, segment: CTopLevelSegment) -> CSourceLocation: + return self._source_location_at(segment, 0) + + def _macro_dependencies( + self, + source: str, + filename: str | None, + function_like_macro_names: set[str], + object_like_macro_names: set[str] | None = None, + ) -> list[CMacroDependency]: + dependencies: list[CMacroDependency] = [] + if not function_like_macro_names and not object_like_macro_names: + return dependencies + + for segment in split_top_level_c_source(source, filename=filename): + dependency = self._segment_macro_dependency( + segment, + function_like_macro_names, + object_like_macro_names, + ) + if dependency is not None: + dependencies.append(dependency) + return dependencies + + def _segment_macro_dependency( + self, + segment: CTopLevelSegment, + function_like_macro_names: set[str], + object_like_macro_names: set[str] | None = None, + ) -> CMacroDependency | None: + text = segment.text.strip() + if not text: + return None + declaration_text, initializer = top_level_partition(text, "=") + scan_text = declaration_text if initializer is not None else text + for macro_name in sorted(function_like_macro_names): + if re.search(rf"\b{re.escape(macro_name)}\s*\(", scan_text): + return CMacroDependency( + name=macro_name, + context="declaration", + source_text=text, + source_location=self._source_location(segment), + ) + for macro_name in sorted(object_like_macro_names or set()): + prefix_words = _STORAGE_CLASSES | _TYPE_QUALIFIERS | _FUNCTION_SPECIFIERS + prefix_pattern = "|".join(re.escape(word) for word in sorted(prefix_words)) + if re.match( + rf"^(?:(?:{prefix_pattern})\s+)*{re.escape(macro_name)}\b", + scan_text, + ): + return CMacroDependency( + name=macro_name, + context="declaration", + source_text=text, + source_location=self._source_location(segment), + ) + return None + + def _macro_dependent_declaration_diagnostic( + self, + segment: CTopLevelSegment, + dependency: CMacroDependency, + *, + function_like: bool, + ) -> CDiagnostic: + macro_kind = "function-like" if function_like else "object-like" + return CDiagnostic( + code="C_MACRO_DEPENDENT_DECLARATION", + message=( + f"Declaration depends on {macro_kind} macro {dependency.name!r}; " + "provide preprocessed input to parse it." + ), + severity="warning", + location=dependency.source_location or self._source_location(segment), + unit_kind="macro_dependent_declaration", + unit_name=dependency.name, + ) + + def _has_unsupported_declaration_marker(self, text: str) -> bool: + return any(marker in text for marker in _UNSUPPORTED_DECLARATION_MARKERS) + + def _redeclaration_diagnostic( + self, + code: str, + message: str, + location: CSourceLocation | None, + unit_kind: str, + unit_name: str | None, + ) -> CDiagnostic: + return CDiagnostic( + code=code, + message=message, + severity="error", + location=location, + unit_kind=unit_kind, + unit_name=unit_name, + ) + + def _append_declaration_location( + self, + locations: list[CSourceLocation], + location: CSourceLocation | None, + ) -> None: + if location is not None and location not in locations: + locations.append(location) + + def _type_key(self, type_: CType, seen: set[int] | None = None) -> tuple: + if seen is None: + seen = set() + object_id = id(type_) + if object_id in seen: + return ("cycle", type(type_).__name__, getattr(type_, "reference_name", None)) + seen.add(object_id) + + qualifiers = tuple(qualifier.spelling for qualifier in getattr(type_, "qualifiers", [])) + if isinstance(type_, CComposedType): + return ( + "CComposedType", + tuple(self._type_key(component, seen) for component in type_.components), + qualifiers, + ) + if isinstance(type_, CFunctionType): + return ( + "CFunctionType", + self._type_key(type_.result_type, seen), + tuple(self._type_key(parameter_type, seen) for parameter_type in type_.parameter_types), + type_.is_variadic, + qualifiers, + ) + if isinstance(type_, CPointer): + return ("CPointer", qualifiers) + if isinstance(type_, CArray): + return ( + "CArray", + type_.bound, + type_.is_static_minimum, + type_.is_variable_length, + type_.is_flexible, + qualifiers, + ) + if isinstance(type_, CTypedef): + if type_.type is not None: + return ("CTypedef", self._type_key(type_.type, seen), qualifiers) + return ("CTypedef", type_.name, qualifiers) + if isinstance(type_, CStruct): + return ("CStruct", type_.name, type_.anonymous_id, qualifiers) + if isinstance(type_, CUnion): + return ("CUnion", type_.name, type_.anonymous_id, qualifiers) + if isinstance(type_, CEnum): + return ("CEnum", type_.name, type_.anonymous_id, qualifiers) + return (type(type_).__name__, qualifiers) + + def _types_compatible(self, left: CType, right: CType) -> bool: + return self._type_key(left) == self._type_key(right) + + def _unspecified_function_declaration(self, function: CFunction) -> bool: + return function.prototype_style == "unspecified" and not function.parameters + + def _functions_compatible(self, left: CFunction, right: CFunction) -> bool: + if not self._types_compatible(left.result_type, right.result_type): + return False + if self._unspecified_function_declaration(left) or self._unspecified_function_declaration(right): + return True + if left.is_variadic != right.is_variadic or len(left.parameters) != len(right.parameters): + return False + return all( + self._types_compatible(left_param.type, right_param.type) + for left_param, right_param in zip(left.parameters, right.parameters) + ) + + def _merge_function_declaration( + self, + existing: CFunction, + incoming: CFunction, + ) -> CFunction: + if incoming.is_definition and not existing.is_definition: + merged = incoming + for location in existing.declaration_locations: + self._append_declaration_location(merged.declaration_locations, location) + self._append_declaration_location(merged.declaration_locations, existing.source_location) + return merged + + for location in incoming.declaration_locations: + self._append_declaration_location(existing.declaration_locations, location) + self._append_declaration_location(existing.declaration_locations, incoming.source_location) + return existing + + def _deduplicate_functions( + self, + functions: list[CFunction], + diagnostics: list[CDiagnostic], + ) -> list[CFunction]: + by_name: dict[str, CFunction] = {} + order: list[str] = [] + + for function in functions: + existing = by_name.get(function.name) + if existing is None: + by_name[function.name] = function + order.append(function.name) + continue + + if not self._functions_compatible(existing, function): + diagnostics.append( + self._redeclaration_diagnostic( + "C_CONFLICTING_FUNCTION_DECLARATION", + f"Conflicting declarations for function {function.name!r}.", + function.source_location, + "function", + function.name, + ) + ) + continue + + if existing.is_definition and function.is_definition: + diagnostics.append( + self._redeclaration_diagnostic( + "C_DUPLICATE_FUNCTION_DEFINITION", + f"Duplicate definition for function {function.name!r}.", + function.source_location, + "function", + function.name, + ) + ) + continue + + by_name[function.name] = self._merge_function_declaration(existing, function) + + return [by_name[name] for name in order] + + def _is_variable_definition(self, variable: CVariable) -> bool: + return variable.initializer is not None + + def _merge_variable_declaration( + self, + existing: CVariable, + incoming: CVariable, + ) -> CVariable: + if self._is_variable_definition(incoming) and not self._is_variable_definition(existing): + merged = incoming + for location in existing.declaration_locations: + self._append_declaration_location(merged.declaration_locations, location) + self._append_declaration_location(merged.declaration_locations, existing.source_location) + return merged + + for location in incoming.declaration_locations: + self._append_declaration_location(existing.declaration_locations, location) + self._append_declaration_location(existing.declaration_locations, incoming.source_location) + return existing + + def _deduplicate_variables( + self, + variables: list[CVariable], + diagnostics: list[CDiagnostic], + ) -> list[CVariable]: + by_name: dict[str, CVariable] = {} + order: list[str] = [] + + for variable in variables: + if variable.name is None: + continue + existing = by_name.get(variable.name) + if existing is None: + by_name[variable.name] = variable + order.append(variable.name) + continue + + if not self._types_compatible(existing.type, variable.type): + diagnostics.append( + self._redeclaration_diagnostic( + "C_CONFLICTING_VARIABLE_DECLARATION", + f"Conflicting declarations for variable {variable.name!r}.", + variable.source_location, + "variable", + variable.name, + ) + ) + continue + + if self._is_variable_definition(existing) and self._is_variable_definition(variable): + diagnostics.append( + self._redeclaration_diagnostic( + "C_DUPLICATE_VARIABLE_DEFINITION", + f"Duplicate definition for variable {variable.name!r}.", + variable.source_location, + "variable", + variable.name, + ) + ) + continue + + by_name[variable.name] = self._merge_variable_declaration(existing, variable) + + return [by_name[name] for name in order] + + def _deduplicate_typedefs( + self, + typedefs: list[CTypedef], + diagnostics: list[CDiagnostic], + ) -> list[CTypedef]: + by_name: dict[str, CTypedef] = {} + order: list[str] = [] + + for typedef in typedefs: + existing = by_name.get(typedef.name) + if existing is None: + by_name[typedef.name] = typedef + order.append(typedef.name) + continue + + if existing.type is None or typedef.type is None or not self._types_compatible(existing.type, typedef.type): + diagnostics.append( + self._redeclaration_diagnostic( + "C_CONFLICTING_TYPEDEF", + f"Conflicting typedef declarations for {typedef.name!r}.", + typedef.source_location, + "typedef", + typedef.name, + ) + ) + continue + + for location in typedef.declaration_locations: + self._append_declaration_location(existing.declaration_locations, location) + self._append_declaration_location(existing.declaration_locations, typedef.source_location) + + return [by_name[name] for name in order] + + def _deduplicate_structs( + self, + structs: list[CStruct], + diagnostics: list[CDiagnostic], + ) -> list[CStruct]: + by_name: dict[str, CStruct] = {} + ordered: list[CStruct] = [] + + for struct in structs: + if struct.name is None: + ordered.append(struct) + continue + existing = by_name.get(struct.name) + if existing is None: + by_name[struct.name] = struct + ordered.append(struct) + continue + if existing.is_incomplete and not struct.is_incomplete: + index = ordered.index(existing) + ordered[index] = struct + by_name[struct.name] = struct + continue + if not existing.is_incomplete and not struct.is_incomplete: + diagnostics.append( + self._redeclaration_diagnostic( + "C_DUPLICATE_TAG_DEFINITION", + f"Duplicate definition for struct tag {struct.name!r}.", + struct.source_location, + "struct", + struct.name, + ) + ) + return ordered + + def _deduplicate_unions( + self, + unions: list[CUnion], + diagnostics: list[CDiagnostic], + ) -> list[CUnion]: + by_name: dict[str, CUnion] = {} + ordered: list[CUnion] = [] + + for union in unions: + if union.name is None: + ordered.append(union) + continue + existing = by_name.get(union.name) + if existing is None: + by_name[union.name] = union + ordered.append(union) + continue + if existing.is_incomplete and not union.is_incomplete: + index = ordered.index(existing) + ordered[index] = union + by_name[union.name] = union + continue + if not existing.is_incomplete and not union.is_incomplete: + diagnostics.append( + self._redeclaration_diagnostic( + "C_DUPLICATE_TAG_DEFINITION", + f"Duplicate definition for union tag {union.name!r}.", + union.source_location, + "union", + union.name, + ) + ) + return ordered + + def _deduplicate_enums( + self, + enums: list[CEnum], + diagnostics: list[CDiagnostic], + ) -> list[CEnum]: + by_name: dict[str, CEnum] = {} + ordered: list[CEnum] = [] + + for enum in enums: + if enum.name is None: + ordered.append(enum) + continue + existing = by_name.get(enum.name) + if existing is None: + by_name[enum.name] = enum + ordered.append(enum) + continue + diagnostics.append( + self._redeclaration_diagnostic( + "C_DUPLICATE_TAG_DEFINITION", + f"Duplicate definition for enum tag {enum.name!r}.", + enum.source_location, + "enum", + enum.name, + ) + ) + return ordered + + def _normalize_redeclarations(self, parsed: CFile) -> None: + parsed.structs = self._deduplicate_structs(parsed.structs, parsed.diagnostics) + parsed.unions = self._deduplicate_unions(parsed.unions, parsed.diagnostics) + parsed.enums = self._deduplicate_enums(parsed.enums, parsed.diagnostics) + parsed.typedefs = self._deduplicate_typedefs(parsed.typedefs, parsed.diagnostics) + parsed.variables = self._deduplicate_variables(parsed.variables, parsed.diagnostics) + parsed.functions = self._deduplicate_functions(parsed.functions, parsed.diagnostics) + + def _end_location(self, segment: CTopLevelSegment) -> CSourceLocation: + return CSourceLocation( + filename=segment.filename, + line=segment.original_end_line, + column=segment.original_end_column, + source_line=segment.original_end_source_line, + ) + + def _last_identifier(self, text: str) -> re.Match[str] | None: + bracket_depth = 0 + allowed_spans: list[tuple[int, int]] = [] + span_start = 0 + for index, char in enumerate(text): + if char == "[": + if bracket_depth == 0 and span_start < index: + allowed_spans.append((span_start, index)) + bracket_depth += 1 + elif char == "]" and bracket_depth: + bracket_depth -= 1 + if bracket_depth == 0: + span_start = index + 1 + if bracket_depth == 0 and span_start < len(text): + allowed_spans.append((span_start, len(text))) + + matches: list[re.Match[str]] = [] + for start, end in allowed_spans: + matches.extend(_IDENTIFIER_RE.finditer(text, start, end)) + return matches[-1] if matches else None + + def _specifier_words(self, spec_text: str) -> list[str]: + return _IDENTIFIER_RE.findall(spec_text) + + def _qualifiers(self, spellings: list[str]) -> list: + return [_QUALIFIER_CLASSES[spelling]() for spelling in spellings] + + def _invalid_specifier_error( + self, + segment: CTopLevelSegment, + message: str, + *, + offset: int = 0, + ) -> CParseError: + location = self._source_location_at(segment, offset) + return CParseError( + message, + filename=location.filename, + line_number=location.line, + column=location.column, + source_line=location.source_line, + code="CPARSE003", + ) + + def _parse_specifiers(self, spec_text: str) -> tuple[CType, list[str], list[str]]: + words = self._specifier_words(spec_text) + storage: list[str] = [] + qualifiers: list[str] = [] + function_specifiers: list[str] = [] + type_words: list[str] = [] + + for word in words: + if word in _STORAGE_CLASSES: + storage.append(word) + elif word in _TYPE_QUALIFIERS: + qualifiers.append(word) + elif word in _FUNCTION_SPECIFIERS: + function_specifiers.append(word) + else: + type_words.append(word) + + if type_words and type_words[0] in _TAG_KINDS: + tag_name = type_words[1] if len(type_words) > 1 else None + tag_type = {"struct": CStruct, "union": CUnion, "enum": CEnum}[type_words[0]] + tag_kwargs = { + "name": tag_name, + "qualifiers": self._qualifiers(qualifiers), + "source_text": " ".join([*qualifiers, *type_words]), + } + if tag_type in {CStruct, CUnion}: + tag_kwargs["is_incomplete"] = True + type_: CType = tag_type(**tag_kwargs) + elif type_words: + spelling = " ".join(type_words) + primitive = _PRIMITIVE_TYPE_SIGNATURES.get(tuple(sorted(type_words))) + if primitive is not None: + type_ = primitive( + qualifiers=self._qualifiers(qualifiers), + source_text=" ".join([*qualifiers, *type_words]), + ) + elif len(type_words) == 1 and type_words[0] not in _PRIMITIVE_WORDS: + type_ = CTypedef( + name=type_words[0], + qualifiers=self._qualifiers(qualifiers), + source_text=" ".join([*qualifiers, *type_words]), + ) + else: + raise _InvalidSpecifierSequence( + f"Invalid type specifier sequence {spelling!r}." + ) + else: + type_ = CUnknownType( + qualifiers=self._qualifiers(qualifiers), + source_text=spec_text.strip(), + ) + + return type_, storage, function_specifiers + + def _skip_whitespace(self, text: str, index: int) -> int: + while index < len(text) and text[index].isspace(): + index += 1 + return index + + def _read_identifier(self, text: str, index: int) -> tuple[str, int] | None: + if index >= len(text): + return None + first = text[index] + if not (first == "_" or first.isalpha()): + return None + end = index + 1 + while end < len(text) and (text[end] == "_" or text[end].isalnum()): + end += 1 + return text[index:end], end + + def _find_matching_delimiter( + self, + text: str, + open_index: int, + open_char: str, + close_char: str, + ) -> int | None: + depth = 0 + state = "normal" + quote = "" + escaped = False + for index in range(open_index, len(text)): + char = text[index] + if state in {"string", "char"}: + if escaped: + escaped = False + elif char == "\\": + escaped = True + elif char == quote: + state = "normal" + quote = "" + continue + if char in {'"', "'"}: + state = "string" if char == '"' else "char" + quote = char + escaped = False + continue + if char == open_char: + depth += 1 + elif char == close_char: + depth -= 1 + if depth == 0: + return index + return None + + def _split_declaration_specifiers(self, text: str) -> tuple[str, str]: + index = 0 + spec_end = 0 + consumed_type = False + consumed_typedef_name = False + + while True: + index = self._skip_whitespace(text, index) + identifier = self._read_identifier(text, index) + if identifier is None: + break + word, end = identifier + + if word in _STORAGE_CLASSES or word in _TYPE_QUALIFIERS or word in _FUNCTION_SPECIFIERS: + index = end + spec_end = end + continue + + if word in _PRIMITIVE_WORDS: + consumed_type = True + index = end + spec_end = end + continue + + if word in _TAG_KINDS: + consumed_type = True + index = self._skip_whitespace(text, end) + tag_identifier = self._read_identifier(text, index) + if tag_identifier is not None: + _tag_name, index = tag_identifier + spec_end = index + continue + + if not consumed_type and not consumed_typedef_name: + consumed_type = True + consumed_typedef_name = True + index = end + spec_end = end + continue + + break + + return text[:spec_end].strip(), text[spec_end:].strip() + + def _parse_pointer_ops( + self, + text: str, + index: int, + ) -> tuple[list[_PointerOp], int]: + pointers: list[_PointerOp] = [] + index = self._skip_whitespace(text, index) + while index < len(text) and text[index] == "*": + index += 1 + qualifiers: list[str] = [] + while True: + index = self._skip_whitespace(text, index) + identifier = self._read_identifier(text, index) + if identifier is None: + break + word, end = identifier + if word not in _TYPE_QUALIFIERS: + break + qualifiers.append(word) + index = end + pointers.append(_PointerOp(qualifiers=qualifiers)) + index = self._skip_whitespace(text, index) + return pointers, index + + def _parse_array_op(self, content: str) -> _ArrayOp: + words = content.strip().split() + qualifiers: list[str] = [] + is_static = False + remaining: list[str] = [] + for word in words: + if word == "static": + is_static = True + elif word in _TYPE_QUALIFIERS: + qualifiers.append(word) + else: + remaining.append(word) + normalized = " ".join(remaining) + variable_length = normalized == "*" + return _ArrayOp( + size=None if variable_length else normalized or None, + static=is_static, + qualifiers=qualifiers, + variable_length=variable_length, + ) + + def _parse_declarator_suffixes( + self, + text: str, + index: int, + ) -> tuple[list[_ArrayOp | _FunctionOp], int]: + operations: list[_ArrayOp | _FunctionOp] = [] + while True: + index = self._skip_whitespace(text, index) + if index >= len(text): + return operations, index + + if text[index] == "[": + close_index = self._find_matching_delimiter(text, index, "[", "]") + if close_index is None: + return operations, index + operations.append(self._parse_array_op(text[index + 1 : close_index])) + index = close_index + 1 + continue + + if text[index] == "(": + close_index = self._find_matching_delimiter(text, index, "(", ")") + if close_index is None: + return operations, index + parameters_text = text[index + 1 : close_index] + parameters, variadic = self._parse_parameters(parameters_text) + operations.append( + _FunctionOp( + parameters=parameters, + variadic=variadic, + prototype_style=self._prototype_style(parameters_text), + ) + ) + index = close_index + 1 + continue + + return operations, index + + def _parse_direct_declarator_at( + self, + text: str, + index: int, + ) -> tuple[str | None, list[_PointerOp | _ArrayOp | _FunctionOp], int]: + index = self._skip_whitespace(text, index) + if index < len(text) and text[index] == "(": + close_index = self._find_matching_delimiter(text, index, "(", ")") + if close_index is None: + return None, [], index + inner = self._parse_declarator(text[index + 1 : close_index]) + suffixes, index = self._parse_declarator_suffixes(text, close_index + 1) + return inner.name, [*reversed(suffixes), *inner.operations], index + + identifier = self._read_identifier(text, index) + if identifier is None: + suffixes, index = self._parse_declarator_suffixes(text, index) + return None, list(reversed(suffixes)), index + + name, index = identifier + suffixes, index = self._parse_declarator_suffixes(text, index) + return name, list(reversed(suffixes)), index + + def _parse_declarator_at( + self, + text: str, + index: int, + ) -> tuple[str | None, list[_PointerOp | _ArrayOp | _FunctionOp], int]: + pointers, index = self._parse_pointer_ops(text, index) + name, direct_operations, index = self._parse_direct_declarator_at(text, index) + return name, [*pointers, *direct_operations], index + + def _parse_declarator(self, text: str) -> _ParsedDeclarator: + stripped = text.strip() + if not stripped: + return _ParsedDeclarator(name=None, operations=[], source_text="") + name, operations, index = self._parse_declarator_at(stripped, 0) + remainder = stripped[self._skip_whitespace(stripped, index) :].strip() + if remainder: + raise _UnsupportedDeclaratorSyntax( + f"Unsupported declarator syntax after parsed type layers: {remainder!r}." + ) + return _ParsedDeclarator(name=name, operations=operations, source_text=stripped) + + def _prepend_component(self, component: CType, current: CType) -> CComposedType: + if isinstance(current, CComposedType): + return CComposedType( + components=[component, *current.components], + source_text=current.source_text, + ) + return CComposedType(components=[component, current], source_text=current.source_text) + + def _apply_pointer_operation(self, current: CType, operation: _PointerOp) -> CType: + return self._prepend_component( + CPointer(qualifiers=self._qualifiers(operation.qualifiers)), + current, + ) + + def _apply_array_operation(self, current: CType, operation: _ArrayOp) -> CType: + array = CArray( + bound=operation.size, + is_static_minimum=operation.static, + qualifiers=self._qualifiers(operation.qualifiers or []), + is_variable_length=operation.variable_length, + ) + return self._prepend_component(array, current) + + def _apply_function_operation(self, current: CType, operation: _FunctionOp) -> CType: + return CFunctionType( + result_type=current, + parameter_types=[parameter.type for parameter in operation.parameters], + is_variadic=operation.variadic, + prototype_style=operation.prototype_style, + source_text=current.source_text, + ) + + def _apply_declarator_operations( + self, + base_type: CType, + operations: list[_PointerOp | _ArrayOp | _FunctionOp], + ) -> CType: + current = base_type + for operation in operations: + if isinstance(operation, _PointerOp): + current = self._apply_pointer_operation(current, operation) + elif isinstance(operation, _ArrayOp): + current = self._apply_array_operation(current, operation) + else: + current = self._apply_function_operation(current, operation) + return current + + def _build_declared_type( + self, + spec_text: str, + declarator_fragment: str = "", + ) -> tuple[str | None, CType, list[str], list[str], _FunctionOp | None]: + base_type, storage, function_specifiers = self._parse_specifiers(spec_text) + parsed = self._parse_declarator(declarator_fragment) + type_ = self._apply_declarator_operations(base_type, parsed.operations) + source_parts = [spec_text.strip(), declarator_fragment.strip()] + type_.source_text = " ".join(part for part in source_parts if part).strip() + direct_function = ( + parsed.operations[-1] + if parsed.operations and isinstance(parsed.operations[-1], _FunctionOp) + else None + ) + return parsed.name, type_, storage, function_specifiers, direct_function + + def _build_type( + self, + spec_text: str, + declarator_fragment: str = "", + ) -> tuple[CType, list[str]]: + _name, type_, _storage, function_specifiers, _direct_function = self._build_declared_type( + spec_text, + declarator_fragment, + ) + return type_, function_specifiers + + def _adjust_parameter_type(self, declared_type: CType) -> CType: + if isinstance(declared_type, CFunctionType): + return CComposedType( + components=[CPointer(), declared_type], + source_text=declared_type.source_text, + ) + if ( + isinstance(declared_type, CComposedType) + and declared_type.components + and isinstance(declared_type.components[0], CArray) + ): + outer_array = declared_type.components[0] + return CComposedType( + components=[ + CPointer(qualifiers=list(outer_array.qualifiers)), + *declared_type.components[1:], + ], + source_text=declared_type.source_text, + ) + return declared_type + + def _parse_parameter(self, text: str) -> CParameter | None: + stripped = text.strip() + if not stripped or stripped == "void": + return None + spec_text, declarator = self._split_declaration_specifiers(stripped) + if not spec_text: + return None + name, type_, _storage, _function_specifiers, _direct_function = self._build_declared_type( + spec_text, + declarator, + ) + return CParameter( + name=name, + type=self._adjust_parameter_type(type_), + declared_type=type_, + ) + + def _find_parameter_list(self, text: str) -> tuple[int, int] | None: + close_index = len(text) - 1 + while close_index >= 0 and text[close_index].isspace(): + close_index -= 1 + if close_index < 0 or text[close_index] != ")": + return None + + depth = 0 + state = "normal" + quote = "" + escaped = False + for index in range(close_index, -1, -1): + char = text[index] + if state in {"string", "char"}: + if escaped: + escaped = False + elif char == "\\": + escaped = True + elif char == quote: + state = "normal" + quote = "" + continue + if char in {'"', "'"}: + state = "string" if char == '"' else "char" + quote = char + escaped = False + continue + if char == ")": + depth += 1 + elif char == "(": + depth -= 1 + if depth == 0: + return index, close_index + return None + + def _parse_parameters(self, parameters_text: str) -> tuple[list[CParameter], bool]: + stripped = parameters_text.strip() + if not stripped or stripped == "void": + return [], False + + parameters: list[CParameter] = [] + variadic = False + for item in top_level_split(stripped, ","): + if item == "...": + variadic = True + continue + parameter = self._parse_parameter(item) + if parameter is not None: + parameters.append(parameter) + return parameters, variadic + + def _is_knr_definition(self, segment: CTopLevelSegment, parameters_text: str) -> bool: + if segment.terminator != "block": + return False + stripped = parameters_text.strip() + if not stripped or stripped == "void" or "..." in stripped: + return False + for item in top_level_split(stripped, ","): + if not re.fullmatch(r"[A-Za-z_]\w*", item.strip()): + return False + return True + + def _raise_for_unsupported_old_style_definitions( + self, + source: str, + filename: str | None, + ) -> None: + source_lines = source.splitlines() + stripped_lines = strip_c_comments(source).splitlines() + + for index, line in enumerate(stripped_lines): + text = line.strip() + if text.startswith("#"): + continue + parameter_bounds = self._find_parameter_list(text) + if parameter_bounds is None: + continue + open_index, close_index = parameter_bounds + before_parameters = text[:open_index].strip() + name_match = self._last_identifier(before_parameters) + if name_match is None: + continue + if name_match.group(0) in {"if", "for", "while", "switch"}: + continue + return_spec = before_parameters[: name_match.start()].strip() + if not return_spec or "(" in return_spec or ")" in return_spec: + continue + + parameters_text = text[open_index + 1 : close_index].strip() + if not parameters_text or parameters_text == "void": + continue + + parameters = [part.strip() for part in parameters_text.split(",")] + if not parameters or not all(re.fullmatch(r"[A-Za-z_]\w*", part) for part in parameters): + continue + + saw_old_style_declaration = False + for follow in stripped_lines[index + 1 :]: + stripped = follow.strip() + if not stripped: + continue + if stripped.startswith("{"): + source_line = source_lines[index] if index < len(source_lines) else line + raise CParseError( + "K&R style function definitions are not supported", + filename=filename, + line_number=index + 1, + column=max(line.find(name_match.group(0)) + 1, 1), + source_line=source_line, + code="CPARSE002", + ) + if stripped.endswith(";"): + saw_old_style_declaration = True + continue + break + + if saw_old_style_declaration: + source_line = source_lines[index] if index < len(source_lines) else line + raise CParseError( + "K&R style function definitions are not supported", + filename=filename, + line_number=index + 1, + column=max(line.find(name_match.group(0)) + 1, 1), + source_line=source_line, + code="CPARSE002", + ) + + def _prototype_style(self, parameters_text: str) -> str: + return "unspecified" if not parameters_text.strip() else "prototype" + + def _parse_function(self, segment: CTopLevelSegment) -> CFunction | None: + text = segment.text.strip() + if text.startswith(("typedef ", "_Static_assert")) or self._has_unsupported_declaration_marker(text): + return None + + spec_text, declarator = self._split_declaration_specifiers(text) + if not spec_text or not declarator: + return None + try: + name, function_type, storage, function_specifiers, direct_function = self._build_declared_type( + spec_text, + declarator, + ) + except _InvalidSpecifierSequence as error: + raise self._invalid_specifier_error(segment, str(error)) from None + if name is None or not isinstance(function_type, CFunctionType) or direct_function is None: + return None + parameter_bounds = self._find_parameter_list(text) + if parameter_bounds is not None: + open_index, close_index = parameter_bounds + parameters_text = text[open_index + 1 : close_index] + if "(" not in text[:open_index] and self._is_knr_definition(segment, parameters_text): + raise CParseError( + "K&R style function definitions are not supported", + filename=segment.filename, + line_number=segment.original_start_line, + column=segment.original_start_column, + source_line=segment.original_source_line, + code="CPARSE002", + ) + return self._function_from_type( + name, + function_type, + direct_function.parameters, + storage, + function_specifiers, + segment, + ) + + def _function_from_type( + self, + name: str, + function_type: CFunctionType, + parameters: list[CParameter], + storage: list[str], + function_specifiers: list[str], + segment: CTopLevelSegment, + ) -> CFunction: + return CFunction( + name=name, + result_type=function_type.result_type, + parameters=list(parameters), + storage=list(storage), + specifiers=function_specifiers, + is_variadic=function_type.is_variadic, + is_definition=segment.terminator == "block", + prototype_style=function_type.prototype_style, + source_location=self._source_location(segment), + start=self._source_location(segment), + end=self._end_location(segment) if segment.terminator == "block" else None, + ) + + def _anonymous_tag_id(self, kind: str, segment: CTopLevelSegment) -> str: + filename = segment.filename or "" + return f"{kind}@{filename}:{segment.original_start_line}:{segment.original_start_column}" + + def _tag_definition_header(self, text: str) -> tuple[str, list[str], str | None] | None: + words = self._specifier_words(text) + for index, word in enumerate(words): + if word not in _TAG_KINDS: + continue + prefix = words[:index] + suffix = words[index + 1 :] + if any(item not in _STORAGE_CLASSES | _TYPE_QUALIFIERS for item in prefix): + return None + if len(suffix) > 1: + return None + return word, prefix, suffix[0] if suffix else None + return None + + def _forward_tag(self, segment: CTopLevelSegment) -> CStruct | CUnion | None: + words = self._specifier_words(segment.text.strip()) + if len(words) != 2 or words[0] not in {"struct", "union"}: + return None + if words[0] == "struct": + return CStruct( + name=words[1], + is_incomplete=True, + source_location=self._source_location(segment), + ) + return CUnion( + name=words[1], + is_incomplete=True, + source_location=self._source_location(segment), + ) + + def _use_aggregate_definition( + self, + type_: CType, + aggregate: CStruct | CUnion | CEnum, + ) -> CType: + if isinstance(type_, CComposedType): + terminal = type_.components[-1] + if isinstance(terminal, (CStruct, CUnion, CEnum)) and not terminal.qualifiers: + type_.components[-1] = aggregate + return type_ + if isinstance(type_, (CStruct, CUnion, CEnum)) and not type_.qualifiers: + return aggregate + return type_ + + def _declarations_from_declarators( + self, + spec_text: str, + declarator_list: str, + segment: CTopLevelSegment, + *, + resolved: CStruct | CUnion | CEnum | None = None, + ) -> tuple[list[CFunction], list[CTypedef], list[CVariable], list[CDiagnostic]]: + functions: list[CFunction] = [] + typedefs: list[CTypedef] = [] + variables: list[CVariable] = [] + diagnostics: list[CDiagnostic] = [] + + for declarator in top_level_split(declarator_list, ","): + declaration, initializer = top_level_partition(declarator, "=") + try: + name, type_, storage, function_specifiers, direct_function = self._build_declared_type( + spec_text, + declaration, + ) + except _InvalidSpecifierSequence as error: + raise self._invalid_specifier_error(segment, str(error)) from None + except _UnsupportedDeclaratorSyntax as error: + diagnostics.append(self._declarator_diagnostic(segment, str(error))) + continue + if not name: + continue + if resolved is not None: + type_ = self._use_aggregate_definition(type_, resolved) + location = self._source_location(segment) + if "typedef" in storage: + typedefs.append( + CTypedef( + name=name, + type=type_, + source_location=location, + source_text=name, + ) + ) + elif isinstance(type_, CFunctionType) and direct_function is not None: + functions.append( + self._function_from_type( + name, + type_, + direct_function.parameters, + storage, + function_specifiers, + segment, + ) + ) + else: + variables.append( + CVariable( + name=name, + type=type_, + storage=storage, + initializer=CInitializer(initializer) if initializer is not None else None, + source_location=location, + ) + ) + + return functions, typedefs, variables, diagnostics + + def _declarator_diagnostic(self, segment: CTopLevelSegment, message: str) -> CDiagnostic: + return CDiagnostic( + code="C_UNSUPPORTED_DECLARATOR", + message=message, + severity="warning", + location=self._source_location(segment), + unit_kind="declarator", + unit_name=None, + ) + + def _field_diagnostic( + self, + segment: CTopLevelSegment, + owner_kind: str, + message: str, + *, + offset: int = 0, + ) -> CDiagnostic: + return CDiagnostic( + code="C_UNSUPPORTED_FIELD_DECLARATION", + message=message, + severity="warning", + location=self._source_location_at(segment, offset), + unit_kind=f"{owner_kind}_field", + unit_name=None, + ) + + def _incomplete_array_component(self, type_: CType) -> CArray | None: + components = type_.components if isinstance(type_, CComposedType) else [type_] + if not components or not isinstance(components[0], CArray): + return None + array = components[0] + if array.bound is None and not array.is_variable_length: + return array + return None + + def _validate_flexible_members( + self, + members: list[CVariable], + owner_kind: str, + ) -> list[CDiagnostic]: + diagnostics: list[CDiagnostic] = [] + named_members = sum(member.name is not None for member in members) + for index, member in enumerate(members): + array = self._incomplete_array_component(member.type) + if array is None: + continue + if owner_kind == "struct" and index == len(members) - 1 and named_members > 1: + array.is_flexible = True + continue + if owner_kind == "union": + message = "A union member cannot be a flexible array member." + elif index != len(members) - 1: + message = "A flexible array member must be the final member of a struct." + else: + message = "A flexible array member requires a preceding named struct member." + diagnostics.append( + CDiagnostic( + code="C_INVALID_FLEXIBLE_ARRAY_MEMBER", + message=message, + severity="error", + location=member.source_location, + unit_kind=f"{owner_kind}_field", + unit_name=member.name, + ) + ) + return diagnostics + + def _parse_fields( + self, + body: str, + segment: CTopLevelSegment, + owner_kind: str, + *, + body_offset: int, + ) -> tuple[list[CVariable], list[CDiagnostic]]: + members: list[CVariable] = [] + diagnostics: list[CDiagnostic] = [] + for text, field_offset in top_level_split_with_offsets(body, ";"): + member_offset = body_offset + field_offset + member_location = self._source_location_at(segment, member_offset) + if self._has_unsupported_declaration_marker(text): + diagnostics.append( + self._field_diagnostic( + segment, + owner_kind, + "Declaration attributes and alignment specifiers are not supported in fields yet.", + offset=member_offset, + ) + ) + continue + if "{" in text or "}" in text: + diagnostics.append( + self._field_diagnostic( + segment, + owner_kind, + "Nested aggregate field definitions are not supported yet.", + offset=member_offset, + ) + ) + continue + spec_text, declarator_list = self._split_declaration_specifiers(text) + if not spec_text or not declarator_list: + diagnostics.append( + self._field_diagnostic( + segment, + owner_kind, + "Unsupported field declaration.", + offset=member_offset, + ) + ) + continue + for declarator in top_level_split(declarator_list, ","): + declaration, _initializer = top_level_partition(declarator, "=") + declaration, bit_width = top_level_partition(declaration, ":") + try: + name, type_, _storage, _function_specifiers, _direct_function = self._build_declared_type( + spec_text, + declaration, + ) + except _InvalidSpecifierSequence as error: + raise self._invalid_specifier_error(segment, str(error), offset=member_offset) from None + except _UnsupportedDeclaratorSyntax as error: + diagnostics.append( + self._field_diagnostic(segment, owner_kind, str(error), offset=member_offset) + ) + continue + if name is None and bit_width is None: + diagnostics.append( + self._field_diagnostic( + segment, + owner_kind, + "Unnamed field type is not supported.", + offset=member_offset, + ) + ) + continue + members.append( + CVariable( + name=name, + type=type_, + source_location=member_location, + bit_width=bit_width, + ) + ) + diagnostics.extend(self._validate_flexible_members(members, owner_kind)) + return members, diagnostics + + def _parse_enumerators(self, body: str, segment: CTopLevelSegment) -> list[CEnumerator]: + constants: list[CEnumerator] = [] + for item in top_level_split(body, ","): + name_text, value = top_level_partition(item, "=") + identifier = self._read_identifier(name_text.strip(), 0) + if identifier is None: + continue + name, end = identifier + if name_text[end:].strip(): + continue + constants.append( + CEnumerator( + name=name, + value=value, + source_location=self._source_location(segment), + ) + ) + return constants + + def _parse_tag_definition( + self, + segment: CTopLevelSegment, + ) -> tuple[ + CStruct | CUnion | CEnum, + list[CFunction], + list[CTypedef], + list[CVariable], + list[CDiagnostic], + ] | None: + text = segment.text.strip() + if self._has_unsupported_declaration_marker(text): + return None + open_index = text.find("{") + if open_index < 0: + return None + close_index = self._find_matching_delimiter(text, open_index, "{", "}") + if close_index is None: + return None + + header = self._tag_definition_header(text[:open_index].strip()) + if header is None: + return None + kind, prefix, tag_name = header + body = text[open_index + 1 : close_index] + declarators = text[close_index + 1 :].strip() + location = self._source_location(segment) + anonymous_id = None if tag_name else self._anonymous_tag_id(kind, segment) + diagnostics: list[CDiagnostic] = [] + + if kind == "enum": + aggregate: CStruct | CUnion | CEnum = CEnum( + name=tag_name, + constants=self._parse_enumerators(body, segment), + anonymous_id=anonymous_id, + source_location=location, + ) + else: + members, diagnostics = self._parse_fields( + body, + segment, + kind, + body_offset=open_index + 1, + ) + if kind == "struct": + aggregate = CStruct( + name=tag_name, + members=members, + anonymous_id=anonymous_id, + source_location=location, + ) + else: + aggregate = CUnion( + name=tag_name, + members=members, + anonymous_id=anonymous_id, + source_location=location, + ) + + functions: list[CFunction] = [] + typedefs: list[CTypedef] = [] + variables: list[CVariable] = [] + if declarators: + spec_text = " ".join([*prefix, kind, *([tag_name] if tag_name else [])]) + functions, typedefs, variables, declarator_diagnostics = self._declarations_from_declarators( + spec_text, + declarators, + segment, + resolved=aggregate, + ) + diagnostics.extend(declarator_diagnostics) + elif "typedef" in prefix: + diagnostics.append( + CDiagnostic( + code="C_UNSUPPORTED_DECLARATION", + message="Typedef aggregate definition has no alias declarator.", + severity="warning", + location=location, + unit_kind=f"{kind}_typedef", + unit_name=tag_name, + ) + ) + + return aggregate, functions, typedefs, variables, diagnostics + + def _parse_declaration( + self, + segment: CTopLevelSegment, + ) -> tuple[list[CFunction], list[CTypedef], list[CVariable], list[CDiagnostic]]: + text = segment.text.strip() + if ( + not text + or "{" in text + or "}" in text + or text.startswith("_Static_assert") + or self._has_unsupported_declaration_marker(text) + ): + return [], [], [], [] + + spec_text, declarator_list = self._split_declaration_specifiers(text) + if not spec_text or not declarator_list: + return [], [], [], [] + + return self._declarations_from_declarators(spec_text, declarator_list, segment) + + def _is_braced_initializer_declaration(self, segment: CTopLevelSegment) -> bool: + text = segment.text.strip() + if not text: + return False + if "{" in text and "}" in text and "=" in text: + return True + if segment.terminator != "block": + return False + + declaration, initializer = top_level_partition(text, "=") + return bool(declaration) and initializer is not None + + def _unsupported_declaration_diagnostic(self, segment: CTopLevelSegment) -> CDiagnostic | None: + text = segment.text.strip() + if not text: + return None + + kind = "unsupported_declaration" + message = "Unsupported C declaration form." + + if self._is_braced_initializer_declaration(segment): + kind = "braced_initializer_declaration" + message = "Braced or designated initializer declarations are not supported yet." + elif text.startswith("struct "): + kind = "struct_definition" + message = "Struct definitions are not supported yet." + elif text.startswith("union "): + kind = "union_definition" + message = "Union definitions are not supported yet." + elif text.startswith("enum "): + kind = "enum_definition" + message = "Enum definitions are not supported yet." + elif text.startswith("_Static_assert"): + kind = "static_assert" + message = "Static assertions are recorded but not evaluated." + elif "__attribute__" in text or "__declspec" in text or "[[" in text: + kind = "attribute_declaration" + message = "Compiler-specific declaration attributes are not supported yet." + elif "_Alignas" in text or "alignas" in text: + kind = "alignment_declaration" + message = "Declaration alignment specifiers are not supported yet." + elif "_Atomic(" in text: + kind = "atomic_type_declaration" + message = "_Atomic(type) declarations are not supported yet." + elif "{" in text or "}" in text: + kind = "brace_declaration" + message = "Unsupported declaration containing braces." + + return CDiagnostic( + code="C_UNSUPPORTED_DECLARATION", + message=message, + severity="warning", + location=self._source_location(segment), + unit_kind=kind, + unit_name=None, + ) + + def _parse_translation_unit( + self, + source: str, + filename: str | None, + *, + function_like_macros: set[str] | None = None, + object_like_macros: set[str] | None = None, + ) -> tuple[ + list[CFunction], + list[CStruct], + list[CUnion], + list[CEnum], + list[CTypedef], + list[CVariable], + list[CDiagnostic], + ]: + self._raise_for_unsupported_old_style_definitions(source, filename) + + functions: list[CFunction] = [] + structs: list[CStruct] = [] + unions: list[CUnion] = [] + enums: list[CEnum] = [] + typedefs: list[CTypedef] = [] + variables: list[CVariable] = [] + diagnostics: list[CDiagnostic] = [] + + function_like_names = function_like_macros or set() + object_like_names = object_like_macros or set() + for segment in split_top_level_c_source(source, filename=filename): + macro_dependency = self._segment_macro_dependency( + segment, + function_like_names, + object_like_names, + ) + if macro_dependency is not None: + diagnostics.append( + self._macro_dependent_declaration_diagnostic( + segment, + macro_dependency, + function_like=macro_dependency.name in function_like_names, + ) + ) + continue + tag_definition = self._parse_tag_definition(segment) + if tag_definition is not None: + aggregate, parsed_functions, parsed_typedefs, parsed_variables, parsed_diagnostics = tag_definition + if isinstance(aggregate, CStruct): + structs.append(aggregate) + elif isinstance(aggregate, CUnion): + unions.append(aggregate) + else: + enums.append(aggregate) + functions.extend(parsed_functions) + typedefs.extend(parsed_typedefs) + variables.extend(parsed_variables) + diagnostics.extend(parsed_diagnostics) + continue + if self._is_braced_initializer_declaration(segment): + unsupported = self._unsupported_declaration_diagnostic(segment) + if unsupported is not None: + diagnostics.append(unsupported) + continue + if segment.terminator != ";": + try: + function = self._parse_function(segment) + except _UnsupportedDeclaratorSyntax as error: + diagnostics.append(self._declarator_diagnostic(segment, str(error))) + continue + if function is not None: + functions.append(function) + continue + unsupported = self._unsupported_declaration_diagnostic(segment) + if unsupported is not None: + diagnostics.append(unsupported) + continue + forward_tag = self._forward_tag(segment) + if isinstance(forward_tag, CStruct): + structs.append(forward_tag) + continue + if isinstance(forward_tag, CUnion): + unions.append(forward_tag) + continue + parsed_functions, parsed_typedefs, parsed_variables, declarator_diagnostics = self._parse_declaration( + segment + ) + functions.extend(parsed_functions) + typedefs.extend(parsed_typedefs) + variables.extend(parsed_variables) + diagnostics.extend(declarator_diagnostics) + if ( + not parsed_functions + and not parsed_typedefs + and not parsed_variables + and not declarator_diagnostics + ): + unsupported = self._unsupported_declaration_diagnostic(segment) + if unsupported is not None: + diagnostics.append(unsupported) + + return functions, structs, unions, enums, typedefs, variables, diagnostics + + def _build_project(self, parsed_files: dict[str, CFile]) -> CProject: + project = CProject(files=parsed_files) + all_functions: list[CFunction] = [] + for filename, file in parsed_files.items(): + project.functions_by_file[filename] = [function.name for function in file.functions] + all_functions.extend(file.functions) + for struct in file.structs: + if struct.name is not None: + self._index_struct(project, struct, project.diagnostics) + for union in file.unions: + if union.name is not None: + self._index_union(project, union, project.diagnostics) + for enum in file.enums: + if enum.name is not None: + self._index_enum(project, enum, project.diagnostics) + for constant in enum.constants: + project.enum_constants[constant.name] = constant + for typedef in file.typedefs: + project.typedefs[typedef.name] = typedef + for variable in file.variables: + if variable.name is not None: + project.variables[variable.name] = variable + for macro in file.macros: + project.macros[macro.name] = macro + for include in file.includes: + project.includes[f"{filename}:{include.target}"] = include + project.diagnostics.extend(file.diagnostics) + self._index_file_includes(project, filename, file) + self._index_header_source_pairs(project) + resolve_project_types(project) + project.functions = { + function.name: function + for function in self._deduplicate_functions(all_functions, project.diagnostics) + } + return project + + def _index_struct( + self, + project: CProject, + struct: CStruct, + diagnostics: list[CDiagnostic], + ) -> None: + if struct.name is None: + return + existing = project.structs.get(struct.name) + if existing is None or (existing.is_incomplete and not struct.is_incomplete): + project.structs[struct.name] = struct + elif not existing.is_incomplete and not struct.is_incomplete: + diagnostics.append( + self._redeclaration_diagnostic( + "C_DUPLICATE_TAG_DEFINITION", + f"Duplicate definition for struct tag {struct.name!r}.", + struct.source_location, + "struct", + struct.name, + ) + ) + + def _index_union( + self, + project: CProject, + union: CUnion, + diagnostics: list[CDiagnostic], + ) -> None: + if union.name is None: + return + existing = project.unions.get(union.name) + if existing is None or (existing.is_incomplete and not union.is_incomplete): + project.unions[union.name] = union + elif not existing.is_incomplete and not union.is_incomplete: + diagnostics.append( + self._redeclaration_diagnostic( + "C_DUPLICATE_TAG_DEFINITION", + f"Duplicate definition for union tag {union.name!r}.", + union.source_location, + "union", + union.name, + ) + ) + + def _index_enum( + self, + project: CProject, + enum: CEnum, + diagnostics: list[CDiagnostic], + ) -> None: + if enum.name is None: + return + existing = project.enums.get(enum.name) + if existing is None: + project.enums[enum.name] = enum + else: + diagnostics.append( + self._redeclaration_diagnostic( + "C_DUPLICATE_TAG_DEFINITION", + f"Duplicate definition for enum tag {enum.name!r}.", + enum.source_location, + "enum", + enum.name, + ) + ) + + def _include_graph_target( + self, + parsed_files: dict[str, CFile], + filename: str, + target: str, + resolved_path: str | None, + ) -> str: + local_key = _include_key_from_current(filename, target) + if local_key in parsed_files: + return local_key + + basename_matches = [key for key in parsed_files if PurePosixPath(key).name == target] + if len(basename_matches) == 1: + return basename_matches[0] + + if resolved_path: + resolved_name = Path(resolved_path).name + resolved_matches = [key for key in parsed_files if PurePosixPath(key).name == resolved_name] + if len(resolved_matches) == 1: + return resolved_matches[0] + return str(Path(resolved_path)) + + return local_key + + def _index_file_includes( + self, + project: CProject, + filename: str, + file: CFile, + ) -> None: + local_targets: set[str] = set() + system_targets: set[str] = set() + unresolved_targets: set[str] = set() + + for include in file.includes: + if include.kind == "system": + system_targets.add(include.target) + continue + + target = self._include_graph_target( + project.files, + filename, + include.target, + include.resolved_path, + ) + local_targets.add(target) + if include.resolved_path is None and target not in project.files: + unresolved_targets.add(include.target) + + project.include_graph[filename] = local_targets + project.system_includes[filename] = system_targets + project.unresolved_includes[filename] = unresolved_targets + + def _index_header_source_pairs(self, project: CProject) -> None: + headers = [key for key in project.files if _is_header_key(key)] + sources = [key for key in project.files if _is_source_key(key)] + + for header in headers: + project.header_source_pairs.setdefault(header, set()) + + for header in headers: + header_path = PurePosixPath(header) + header_stem = header_path.with_suffix("") + for source in sources: + source_path = PurePosixPath(source) + if source_path.with_suffix("") == header_stem: + project.header_source_pairs[header].add(source) + + for source in sources: + for included in project.include_graph.get(source, set()): + if included in project.files and _is_header_key(included): + project.header_source_pairs.setdefault(included, set()).add(source) + + def visit_file( + self, + source_or_path: str | Path, + filename: str | None = None, + *, + macro_defines: set[str] | dict[str, int | bool | str] | None = None, + include_dirs: Sequence[str | Path] | None = None, + preprocessing: str = "raw", + encoding: str = "utf-8", + ) -> CFile: + del macro_defines + source_path: Path | None = None + if _looks_like_existing_source_path(source_or_path): + path = Path(source_or_path) + source_path = path + if filename is None: + filename = str(path) + source = path.read_text(encoding=encoding) + else: + source = str(source_or_path) + + parsed = CFile(filename=filename, parser_status="partial", preprocessing=preprocessing) + if preprocessing == "raw": + effective_include_dirs = list(include_dirs or ()) + if source_path is not None: + effective_include_dirs.insert(0, source_path.parent) + metadata = collect_preprocessor_metadata( + source, + filename=filename, + include_dirs=effective_include_dirs, + ) + parsed.includes = metadata.includes + parsed.macros = metadata.macros + parsed.raw_directives = metadata.raw_directives + function_like_macro_names = {macro.name for macro in metadata.macros if macro.function_like} + object_like_macro_names = { + macro.name + for macro in metadata.macros + if macro.directive == "define" and not macro.function_like + } + parsed.macro_dependencies = self._macro_dependencies( + source, + filename, + function_like_macro_names, + object_like_macro_names, + ) + parsed.diagnostics = metadata.diagnostics + functions, structs, unions, enums, typedefs, variables, parser_diagnostics = self._parse_translation_unit( + source, + filename, + function_like_macros=function_like_macro_names, + object_like_macros=object_like_macro_names, + ) + parsed.functions = functions + parsed.structs = structs + parsed.unions = unions + parsed.enums = enums + parsed.typedefs = typedefs + parsed.variables = variables + parsed.diagnostics.extend(parser_diagnostics) + self._normalize_redeclarations(parsed) + return parsed + + def visit_project( + self, + files: Mapping[str, str] | Sequence[str | Path] | str | Path, + *, + include_dirs: Sequence[str | Path] | None = None, + macro_defines: set[str] | dict[str, int | bool | str] | None = None, + preprocessing: str = "raw", + encoding: str = "utf-8", + ) -> CProject: + if isinstance(files, Mapping): + parsed_files = { + name: self.visit_file( + source, + filename=name, + include_dirs=include_dirs, + macro_defines=macro_defines, + preprocessing=preprocessing, + encoding=encoding, + ) + for name, source in files.items() + } + return self._build_project(parsed_files) + + paths: list[Path] = [] + root: Path | None = None + if isinstance(files, (str, Path)): + path = Path(files) + if path.is_dir(): + root = path + paths = _collect_c_paths(path) + else: + paths = [path] + else: + paths = [Path(p) for p in files] + + parsed_files: dict[str, CFile] = {} + for path in sorted(paths): + key = path.name if root is not None else str(path) + if root is not None: + key = str(path.relative_to(root)) + parsed_files[key] = self.visit_file( + path, + filename=key, + include_dirs=include_dirs, + macro_defines=macro_defines, + preprocessing=preprocessing, + encoding=encoding, + ) + return self._build_project(parsed_files) + + +_DEFAULT_PARSER = CParser() + + +def parse_c_file( + source_or_path: str | Path, + filename: str | None = None, + *, + macro_defines: set[str] | dict[str, int | bool | str] | None = None, + include_dirs: Sequence[str | Path] | None = None, + preprocessing: str = "raw", + encoding: str = "utf-8", +) -> CFile: + return _DEFAULT_PARSER.visit_file( + source_or_path, + filename=filename, + macro_defines=macro_defines, + include_dirs=include_dirs, + preprocessing=preprocessing, + encoding=encoding, + ) + + +def parse_c_project( + files: Mapping[str, str] | Sequence[str | Path] | str | Path, + *, + include_dirs: Sequence[str | Path] | None = None, + macro_defines: set[str] | dict[str, int | bool | str] | None = None, + preprocessing: str = "raw", + encoding: str = "utf-8", +) -> CProject: + return _DEFAULT_PARSER.visit_project( + files, + include_dirs=include_dirs, + macro_defines=macro_defines, + preprocessing=preprocessing, + encoding=encoding, + ) diff --git a/c_parser/preprocessor.py b/c_parser/preprocessor.py new file mode 100644 index 000000000..ab1c9ce2d --- /dev/null +++ b/c_parser/preprocessor.py @@ -0,0 +1,162 @@ +# -*- coding: utf-8 -*- +from __future__ import annotations + +import re +from collections.abc import Sequence +from dataclasses import dataclass, field +from pathlib import Path + +from .lexer import CLogicalRecord, NormalizedCSource, normalize_c_source +from .models import CDiagnostic, CInclude, CMacro, CRawDirective, CSourceLocation + + +_INCLUDE_RE = re.compile(r'^\s*#\s*include\s*(?:"([^"]+)"|<([^>]+)>)') +_DEFINE_RE = re.compile(r"^\s*#\s*define\s+([A-Za-z_]\w*)(\([^)]*\))?(?:\s+(.*))?$") +_UNDEF_RE = re.compile(r"^\s*#\s*undef\s+([A-Za-z_]\w*)\s*$") +_DIRECTIVE_RE = re.compile(r"^\s*#\s*([A-Za-z_]\w*)\b(.*)$") +_RAW_PROVENANCE_DIRECTIVES = {"if", "ifdef", "ifndef", "elif", "else", "endif", "pragma"} + + +@dataclass +class CPreprocessorMetadata: + includes: list[CInclude] = field(default_factory=list) + macros: list[CMacro] = field(default_factory=list) + raw_directives: list[CRawDirective] = field(default_factory=list) + diagnostics: list[CDiagnostic] = field(default_factory=list) + + +def _record_location(record: CLogicalRecord) -> CSourceLocation: + source_line = record.source_line + column = 1 + if source_line is not None: + marker = source_line.find("#") + if marker >= 0: + column = marker + 1 + return CSourceLocation( + filename=record.filename, + line=record.original_start_line, + column=column, + source_line=source_line, + ) + + +def _resolve_local_include( + target: str, + filename: str | None, + include_dirs: Sequence[str | Path] | None, +) -> str | None: + candidates: list[Path] = [] + if filename: + candidates.append(Path(filename).parent / target) + candidates.extend(Path(include_dir) / target for include_dir in include_dirs or ()) + + for candidate in candidates: + try: + if candidate.is_file(): + return str(candidate) + except OSError: + continue + return None + + +def collect_preprocessor_metadata( + source: str, + filename: str | None = None, + *, + include_dirs: Sequence[str | Path] | None = None, +) -> CPreprocessorMetadata: + normalized = normalize_c_source(source, filename=filename) + metadata = CPreprocessorMetadata() + + for record in normalized.records: + directive_match = _DIRECTIVE_RE.match(record.text) + if directive_match: + directive, argument = directive_match.groups() + if directive in _RAW_PROVENANCE_DIRECTIVES: + metadata.raw_directives.append( + CRawDirective( + directive=directive, + argument=argument.strip() or None, + source_location=_record_location(record), + ) + ) + continue + + include_match = _INCLUDE_RE.match(record.text) + if include_match: + local_target, system_target = include_match.groups() + target = local_target or system_target + kind = "local" if local_target is not None else "system" + resolved_path = ( + _resolve_local_include(target, filename, include_dirs) + if kind == "local" + else None + ) + location = _record_location(record) + metadata.includes.append( + CInclude( + target=target, + kind=kind, + resolved_path=resolved_path, + source_location=location, + ) + ) + if kind == "local" and resolved_path is None: + metadata.diagnostics.append( + CDiagnostic( + code="C_UNRESOLVED_INCLUDE", + message=f'Could not resolve local include "{target}".', + severity="warning", + location=location, + unit_kind="include", + unit_name=target, + ) + ) + continue + + define_match = _DEFINE_RE.match(record.text) + if define_match: + name, parameters, value = define_match.groups() + location = _record_location(record) + function_like = parameters is not None + metadata.macros.append( + CMacro( + name=name, + value=value.strip() if value else None, + function_like=function_like, + source_location=location, + ) + ) + if function_like: + metadata.diagnostics.append( + CDiagnostic( + code="C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + message=f"Function-like macro {name!r} is recorded but not expanded.", + severity="warning", + location=location, + unit_kind="macro", + unit_name=name, + ) + ) + continue + + undef_match = _UNDEF_RE.match(record.text) + if undef_match: + name = undef_match.group(1) + metadata.macros.append( + CMacro( + name=name, + directive="undef", + source_location=_record_location(record), + ) + ) + + return metadata + + +__all__ = ( + "CPreprocessorMetadata", + "NormalizedCSource", + "collect_preprocessor_metadata", + "normalize_c_source", +) diff --git a/c_parser/project.py b/c_parser/project.py new file mode 100644 index 000000000..3a2be400e --- /dev/null +++ b/c_parser/project.py @@ -0,0 +1,6 @@ +# -*- coding: utf-8 -*- +"""C project parsing placeholder.""" + +from .parser import parse_c_project + +__all__ = ("parse_c_project",) diff --git a/c_parser/type_resolver.py b/c_parser/type_resolver.py new file mode 100644 index 000000000..8637d3312 --- /dev/null +++ b/c_parser/type_resolver.py @@ -0,0 +1,157 @@ +# -*- coding: utf-8 -*- +"""Basic C project type resolution for parser models.""" + +from __future__ import annotations + +from .models import ( + CComposedType, + CDiagnostic, + CEnum, + CFunction, + CFunctionType, + CParameter, + CProject, + CStruct, + CType, + CTypedef, + CUnion, + CVariable, +) + + +def resolve_project_types(project: CProject) -> CProject: + """Resolve basic typedef and tag references inside a parsed C project.""" + emitted_cycles: set[tuple[str, ...]] = set() + for typedef in project.typedefs.values(): + _resolve_typedef_definition(project, typedef, [], emitted_cycles) + + for file in project.files.values(): + for function in file.functions: + _resolve_function(project, function, emitted_cycles) + for typedef in file.typedefs: + _resolve_typedef_definition(project, typedef, [], emitted_cycles) + for variable in file.variables: + _resolve_variable(project, variable, emitted_cycles) + for aggregate in [*file.structs, *file.unions]: + for member in aggregate.members: + _resolve_variable(project, member, emitted_cycles) + + return project + + +def _resolve_function( + project: CProject, + function: CFunction, + emitted_cycles: set[tuple[str, ...]], +) -> None: + function.result_type = _resolve_type(project, function.result_type, [], emitted_cycles) + for parameter in function.parameters: + _resolve_parameter(project, parameter, emitted_cycles) + + +def _resolve_parameter( + project: CProject, + parameter: CParameter, + emitted_cycles: set[tuple[str, ...]], +) -> None: + parameter.type = _resolve_type(project, parameter.type, [], emitted_cycles) + if parameter.declared_type is not None: + parameter.declared_type = _resolve_type(project, parameter.declared_type, [], emitted_cycles) + + +def _resolve_variable( + project: CProject, + variable: CVariable, + emitted_cycles: set[tuple[str, ...]], +) -> None: + variable.type = _resolve_type(project, variable.type, [], emitted_cycles) + + +def _resolve_typedef_definition( + project: CProject, + typedef: CTypedef, + stack: list[str], + emitted_cycles: set[tuple[str, ...]], +) -> None: + if typedef.type is None: + return + if typedef.name in stack: + _record_typedef_cycle(project, [*stack, typedef.name], typedef, emitted_cycles) + return + typedef.type = _resolve_type(project, typedef.type, [*stack, typedef.name], emitted_cycles) + + +def _resolve_type( + project: CProject, + type_: CType, + stack: list[str], + emitted_cycles: set[tuple[str, ...]], +) -> CType: + if isinstance(type_, CComposedType): + type_.components = [ + _resolve_type(project, component, stack, emitted_cycles) + for component in type_.components + ] + return type_ + if isinstance(type_, CFunctionType): + type_.result_type = _resolve_type(project, type_.result_type, stack, emitted_cycles) + type_.parameter_types = [ + _resolve_type(project, parameter_type, stack, emitted_cycles) + for parameter_type in type_.parameter_types + ] + return type_ + if isinstance(type_, CTypedef): + return _resolve_typedef_reference(project, type_, stack, emitted_cycles) + if isinstance(type_, CStruct) and type_.name and not type_.qualifiers: + return project.structs.get(type_.name, type_) + if isinstance(type_, CUnion) and type_.name and not type_.qualifiers: + return project.unions.get(type_.name, type_) + if isinstance(type_, CEnum) and type_.name and not type_.qualifiers: + return project.enums.get(type_.name, type_) + return type_ + + +def _resolve_typedef_reference( + project: CProject, + reference: CTypedef, + stack: list[str], + emitted_cycles: set[tuple[str, ...]], +) -> CType: + target = project.typedefs.get(reference.name) + if target is None: + return reference + if target.name in stack: + _record_typedef_cycle(project, [*stack, target.name], target, emitted_cycles) + return reference + _resolve_typedef_definition(project, target, stack, emitted_cycles) + return target + + +def _record_typedef_cycle( + project: CProject, + cycle: list[str], + typedef: CTypedef, + emitted_cycles: set[tuple[str, ...]], +) -> None: + first = cycle[-1] + try: + start = cycle.index(first) + except ValueError: # pragma: no cover - defensive only. + start = 0 + normalized = tuple(cycle[start:]) + if normalized in emitted_cycles: + return + emitted_cycles.add(normalized) + project.diagnostics.append( + CDiagnostic( + code="C_TYPEDEF_CYCLE", + message=f"Typedef cycle detected: {' -> '.join(normalized)}.", + severity="error", + location=typedef.source_location, + unit_kind="typedef", + unit_name=typedef.name, + ) + ) + + +__all__ = ("resolve_project_types",) diff --git a/c_parser/utils.py b/c_parser/utils.py new file mode 100644 index 000000000..dc843db0b --- /dev/null +++ b/c_parser/utils.py @@ -0,0 +1,4 @@ +# -*- coding: utf-8 -*- +"""C parser utility placeholder.""" + +__all__: tuple[str, ...] = () diff --git a/docs/c_parser/c_parser_architecture.md b/docs/c_parser/c_parser_architecture.md new file mode 100644 index 000000000..31d1dd789 --- /dev/null +++ b/docs/c_parser/c_parser_architecture.md @@ -0,0 +1,744 @@ +# C Parser Architecture Plan + +Status: partial parser plus raw directive metadata implemented. The `c_parser` +package, typed parser models, public entrypoints, explicit +`x2py --language c --parse` CLI path, raw include/macro/undef/conditional +metadata collection, top-level redeclaration handling, project include/index +reporting, top-level source splitting, and a first simple +declaration/function subset with function-definition start/end locations and +aggregate declarations exist. Declarators are parsed through a recursive +grammar-style path for pointer, array, function, and parenthesized combinations. + +This document records the target architecture for the C parser frontend in +x2py. The initial skeleton has grown into a partial parser, and the remaining +sections describe the architecture it should grow into. The design is based on +inspection of the +current Fortran parser, semantic IR conversion layer, `.pyi` parser/printer, +CLI, tests, and fixture workflow. + +## Current Implementation Snapshot + +Implemented now: + +- `c_parser/` package exists and is included in package discovery. +- `c_parser.models` defines JSON-stable parser dataclasses and `CParseError`. +- `c_parser.parser` exposes `CParser`, `parse_c_file`, and `parse_c_project`. +- `c_parser.parser` keeps parser helpers on `CParser`, matching the Fortran + parser's stateful class structure; module-level functions are limited to + public entrypoints and small path helpers. +- `c_parser.lexer` strips comments safely, folds backslash-newline logical + records, exposes lightweight token records, and provides top-level splitting + helpers that track braces, parentheses, brackets, literals, and + function-definition end locations. +- `c_parser.preprocessor` records raw `#include` directives, simple object-like + macros, `#undef` directives, conditional/pragma directive provenance, and + unsupported function-like macro diagnostics without expanding macros. +- `c_parser.parser` parses variables, typedefs, incomplete `struct`/`union` + tags, basic struct/union/enum definitions, function prototypes, and + function-definition signatures while skipping bodies. Declarator handling + follows the C declarator grammar for pointer prefixes, parenthesized direct + declarators, and array/function suffixes, including functions returning + function pointers and arrays of callback pointers. Incomplete tags are + recorded as `CStruct` or `CUnion` objects with `is_incomplete=True`. + Declaration types are represented by concrete `CType` subclasses: + primitives, `CPointer`, `CArray`, `CFunctionType`, and + `CComposedType`. Aggregate members are `CVariable` objects using that same + type path and preserve arrays, callback candidates, bit-width text, and + member-level source locations. Supported flexible final struct members set + `CArray.is_flexible=True`; invalid flexible-member placement and union use + produce `C_INVALID_FLEXIBLE_ARRAY_MEMBER` diagnostics. + Inline tag definitions followed by aliases or objects produce concrete + `CTypedef` or `CVariable` records linked to the aggregate object. Function + models expose `result_type` and named `parameters`; their derived + `CFunctionType` is the nameless callable signature. Array and function + parameter declarations preserve their written `declared_type` and expose + pointer-adjusted effective `type` values. Declarations prefixed by + unexpanded object-like macros are deferred as macro dependencies rather than + misreported as invalid type sequences. Selected unsupported declaration + forms, including attributes, alignment specifiers, + `_Atomic(type)`, nested aggregate member definitions, and static assertions, + are reported as diagnostics with + explicit `unit_kind` values. A declarator must be fully consumed before a + concrete object is returned; unknown suffixes become diagnostics. Primitive + specifier order is normalized, and invalid combinations such as + `unsigned float` raise `CParseError` with code `CPARSE003` while a single + unresolved typedef-like name remains deferred. Definitions preserve direct + `start` and `end` locations from the signature start through the closing + brace; and K&R-style function definitions raise focused diagnostics. +- Top-level redeclaration handling merges compatible repeated declarations, + completes incomplete struct/union tags when a later definition is parsed, + prefers compatible function or variable definitions over earlier + declarations, preserves related declaration locations, and reports duplicate + definitions or incompatible redeclarations as diagnostics. Local declarations + inside function bodies remain out of scope because bodies are skipped. +- `c_parser.cli` provides C-specific partial report formatting. +- `x2py.cli` dispatches `--language c --parse` to the C parser path. +- `--language c --semantics`, `--language c --pyi`, and C wrap-readiness are + rejected until semantic conversion exists. +- Focused partial CLI/API, declaration/function, diagnostic color, project + include/index, raw lexer/directive, project golden, error golden, and JSON + schema tests are active. Remaining parser-suite skips are limited to the + pinned corpus roadmap and compiler-preprocessed `.i`/`#line` behavior. +- `tests/data/c/` contains general fixtures modeled after the Fortran general + fixture themes, additional C-specific API shapes, fatal diagnostic inputs, + and real-world cJSON/jsmn/tinyexpr/linmath/NanoSVG/stb inputs whose partial + project parse reports are covered by regression goldens. + +Deferred: + +- full typedef/tag resolution policy beyond basic project-level link-up and + callback policy metadata, for example conflict diagnostics, active + conditional branches, and semantic wrappability decisions +- nested aggregate member definitions, braced initializers, compiler + attributes, alignment specifiers, and `_Atomic(type)` declarations, for + example `struct outer { struct { int x; } inner; };` and + `int values[3] = {1, 2, 3};` +- preprocessed-input support, line mapping, and macro-expanded declaration + parsing, for example `API(int) run(void);` after macro expansion +- include graph and project type resolution +- C semantic readiness, semantic IR conversion, and `.pyi` output + +Documentation rule: any future C parser implementation change must update all +affected docs under `docs/c_parser/` in the same change. This applies to model, +parser, CLI, test, fixture, semantic, and `.pyi` changes; documentation updates +should not wait for a separate request. + +## Inspected Repository Areas + +- `README.md` +- `fortran_parser.md` +- `parser_implementation_reference.md` +- `Semantic_Multilanguage_Wrapper_Runtime_Architecture.md` +- `docs/pyi_format.md` +- `fortran_parser/lexer.py` +- `fortran_parser/parser.py` +- `fortran_parser/models.py` +- `fortran_parser/type_resolver.py` +- `fortran_parser/utils.py` +- `fortran_parser/cli.py` +- `x2py/cli.py` +- `x2py/__init__.py` +- `semantics/models.py` +- `semantics/fortran2ir.py` +- `semantics/pyi_printer.py` +- `semantics/pyi_parser.py` +- `tests/parser/test_cli.py` +- `tests/parser/test_fortran_fixture_suite.py` +- `tests/parser/test_fortran_error_fixture_suite.py` +- `tests/parser/test_parser_developer_tutorial.py` +- `tests/parser/test_parser_public_entrypoints.py` +- `tests/semantics/test_semantic_wrap_readiness.py` +- `tests/parser/test_error_handling.py` +- `tests/semantics/test_fortran2ir.py` +- `tests/semantics/test_semantic_conversion_smoke.py` +- `tests/pyi/test_pyi_to_ir.py` +- `tests/pyi/test_pyi_fixture_suite.py` +- `tests/parser/fortran/generate_fortran_parser_goldens.py` +- `tests/parser/fortran/errors/generate_fortran_parser_error_goldens.py` +- `tests/parser/c/generate_c_parser_goldens.py` +- `tests/parser/c/errors/generate_c_parser_error_goldens.py` +- `tests/semantics/generate_semantic_fixtures.py` +- `tests/pyi/generate_pyi_fixtures.py` +- `tests/_shared/fixture_outputs.py` + +## Architectural Observations From The Existing Parser + +The Fortran parser is not a compiler frontend. It is a wrapper-oriented +semantic extraction frontend with a bounded language subset. Its important +architectural properties are: + +- A lexer/preprocessor stage normalizes source while preserving original line + numbers and source lines for diagnostics. +- The parser uses recursive source-unit slicing instead of a whole-file scan. +- Each source unit is parsed inside an explicit `_ParserScope`; there is no + ambient global current module/procedure stack. +- Unit visitors are small and grammar-shaped: file, module, submodule, program, + procedure, interface, derived type, and block data each receive only their + own source substring. +- The shared declaration parser is reused for procedure arguments/results, + module variables, program variables, block data variables, and derived type + fields. +- Grammar-region splitting separates header, specification, execution, and + contains regions. Wrapper extraction mostly ignores executable bodies. +- Parser model objects are typed dataclasses with stable JSON-friendly fields. +- Project parsing builds indexes and dependency order from imports/uses. +- Readiness is semantic-layer work, not parser work. The C parser should + preserve enough source facts for later semantic readiness, but it should not + expose parser-side `wrappable` reports. +- CLI output has a stable human tree, JSON output, output file behavior, + no-color support, and debug traceback opt-in. +- Semantic IR conversion is a separate visitor layer. Parser output is a helper + input, not the source of truth. +- `.pyi` generation and parsing operate over semantic IR, not parser internals. +- Fixture testing combines focused unit tests, parser JSON goldens, error + goldens, semantic fixtures, `.pyi` fixtures, and corpus parse-only coverage. + +The C parser should follow these patterns where they map cleanly to C syntax. +It should not be a giant regex parser, a compiler wrapper, or a libclang-only +dependency architecture. + +## Grammar-Style Parser Requirement + +The C frontend must be implemented as a grammar-style recursive parser, not as +an unstructured source scanner. The core parser should be shaped around C +grammar regions and reusable visitors: + +- translation-unit visitor +- preprocessor directive collector +- declaration visitor +- declarator parser +- initializer skipper/extractor where wrapper-relevant +- function prototype visitor +- function definition visitor that extracts signatures and skips bodies +- struct, union, enum, and typedef visitors +- scoped symbol/type indexes + +Regular expressions are acceptable only as narrow helpers inside a grammar +step, such as recognizing an include directive after the preprocessor collector +has isolated the line. They must not become the top-level parsing strategy. + +External compiler preprocessing can be used later as an optional input source +for `.i` files or macro-expanded views, but the x2py C frontend still needs its +own typed parser models, source-location handling, diagnostics, and project +indexes. Invoking a compiler must not replace the grammar-style parser. + +## Package Layout + +The implementation lives in a separate package so it does not destabilize the +Fortran parser: + +```text +c_parser/ + __init__.py + __main__.py + cli.py + lexer.py + models.py + parser.py + preprocessor.py + project.py + type_resolver.py + utils.py +``` + +Current and planned responsibilities: + +- `c_parser/models.py` + - Implemented: typed parser models, `CParseError`, compiler-style + diagnostic rendering, concrete `CType` composition, and JSON-stable + dataclass serialization, including declared/effective parameter type facts. + - Planned: resolved symbol links, richer macro/preprocessing provenance, + and project indexes. +- `c_parser/lexer.py` + - Implemented: safe comment removal that preserves line mapping, logical + record folding for backslash-newline, string/character literal awareness, + lightweight tokens with source locations, top-level splitting with block + end locations, and delimiter splitting aware of nesting and literals. + - Planned: richer token helpers as extension and initializer-expression + parsing require them. +- `c_parser/preprocessor.py` + - Implemented: lightweight raw directive metadata for includes, + object-like macros, `#undef` directives, function-like macro diagnostics, + and local include resolution when a matching file is available. + - Planned: compiler-assisted preprocessing metadata and `#line`/linemarker + source mapping for preprocessed input. +- `c_parser/parser.py` + - Implemented: `CParser`, `parse_c_file`, `parse_c_project`, + translation-unit visiting, declaration/function visitors, grammar-shaped + recursive declarator parsing, concrete `CType` construction, and aggregate + member extraction. Helper methods live on `CParser` rather than as broad + module-level functions. Function models record prototype-style versus + unspecified empty parameter lists, function definitions preserve start/end + locations, K&R-style definitions are rejected with `CParseError`, and + invalid primitive-specifier combinations are rejected with `CPARSE003`. + Array and function parameters preserve `declared_type` while effective + `type` uses C parameter adjustment. Raw declarations beginning with an + object-like macro name are retained as macro-dependent diagnostics. + - Planned: symbol resolution and additional declaration-specifier and + extension coverage. +- `c_parser/project.py` + - Placeholder now. + - Planned: file discovery for `.c`, `.h`, and possibly `.i`. + - Include graph construction. + - Header/source association. + - Cross-file type and typedef resolution. +- `c_parser/type_resolver.py` + - Placeholder now. + - Planned: resolve the concrete primitive/tag/typedef types constructed by + the parser across declarations and files. + - Resolve typedef chains and aggregate references. + - Safely fold simple compile-time constant expressions. +- `c_parser/cli.py` + - Implemented: report formatting and serialization helpers called by + `x2py.cli` behind explicit C flags. + - Planned: richer human output as more C facts are populated. +- `c_parser/utils.py` + - Placeholder now. + - Planned: shared helpers that are not parser-state dependent. + +## Public API Shape + +The public C API mirrors the Fortran style but remains C-specific: + +```python +parse_c_file(source_or_path, filename=None, macro_defines=None, include_dirs=None, preprocessing="raw", encoding="utf-8") -> CFile +parse_c_project(files, include_dirs=None, macro_defines=None, preprocessing="raw", encoding="utf-8") -> CProject +``` + +`macro_defines` is reserved for future compiler-assisted preprocessing +configuration. It must not cause raw mode to evaluate C preprocessor +conditionals or expand macros inside x2py. + +Implemented companion class: + +```python +class CParser: + def visit_file(...): ... + def visit_project(...): ... +``` + +These entrypoints are exposed from `c_parser`, not re-exported from +`x2py.__init__`. Keeping the API under `c_parser` avoids making the top-level +x2py API promise stable C behavior before the frontend matures. + +## Core Model Families + +All declared types inherit from `CType`, which stores `qualifiers` and +`source_text`. Type qualifiers are concrete values: `CConst`, `CVolatile`, +`CRestrict`, and `CAtomic`. + +The implemented primitive `CType` subclasses are: + +- `CVoid`, `CBool`, `CChar`, `CSignedChar`, and `CUnsignedChar` +- `CShort`, `CUnsignedShort`, `CInt`, and `CUnsignedInt` +- `CLong`, `CUnsignedLong`, `CLongLong`, and `CUnsignedLongLong` +- `CFloat`, `CDouble`, and `CLongDouble` +- `CFloatComplex`, `CDoubleComplex`, and `CLongDoubleComplex` + +Derived and named `CType` subclasses are: + +- `CPointer`, whose qualifiers apply to that pointer component +- `CArray`, with `bound`, `is_static_minimum`, `is_variable_length`, and + `is_flexible`; supported final flexible struct members are classified now, + and invalid placement or union use produces a parser diagnostic +- `CFunctionType`, the nameless callable signature with `result_type`, + `parameter_types`, `is_variadic`, and `prototype_style` +- `CComposedType`, whose `components` are read from the declared name outward +- `CStruct`, `CUnion`, and `CEnum`, which are tag types as well as aggregate + declaration objects +- `CTypedef`, which represents either a declared alias with its underlying + `type`, or an unresolved typedef-name use until symbol resolution is added +- `CUnknownType`, retained for type states that cannot yet be modeled; invalid + primitive-specifier combinations no longer become `CUnknownType` + +For example, composition order distinguishes the following declarations: + +```python +int *values[4]; # CComposedType([CArray(bound="4"), CPointer(), CInt()]) +int (*matrix)[4]; # CComposedType([CPointer(), CArray(bound="4"), CInt()]) +int *(*table)[4]; # CComposedType([CPointer(), CArray(bound="4"), CPointer(), CInt()]) +``` + +Declaration objects are separate from the type components: + +- `CVariable` has `name`, `type`, `storage`, optional `initializer`, optional + `bit_width`, source/callback metadata, and related declaration locations. + Struct and union `members` are also `CVariable` objects with per-member + locations; there is no separate field class. +- `CFunction` has `name`, `result_type`, named `parameters`, storage and + function specifiers, `is_variadic`, prototype style, and source/definition + locations plus related declaration locations. Its `type` property builds the + corresponding nameless `CFunctionType`. +- `CParameter` has a source name, written `declared_type`, and effective + `type`; outer array parameters and direct function parameters adjust to + pointer `type` values while their source form is retained. +- `CInitializer` preserves initializer source text without claiming evaluation. +- `CStruct` and `CUnion` expose `members` and `is_incomplete`; `CEnum` exposes + `constants`; `CEnumerator` preserves enumerator name and value text. +- `CTypedef` has its alias name, declared `type`, and related declaration + locations. +- `CMacro` + - `name` + - `value` + - `function_like` + - `directive` + - `source_location` +- `CRawDirective` + - `directive` + - `argument` + - `source_location` +- `CMacroDependency` + - `name` + - `context` + - `source_location` +- `CInclude` + - `target` + - `kind` + - `resolved_path` + - `source_location` +- `CFile` + - `filename` + - `language` + - `parser_status` + - `preprocessing` + - `functions` + - `structs` + - `unions` + - `enums` + - `typedefs` + - `variables` + - `macros` + - `includes` + - `raw_directives` + - `macro_dependencies` + - `diagnostics` +- `CProject` + - `files` + - `functions` + - `structs` + - `unions` + - `enums` + - `typedefs` + - `variables` + - `macros` + - `includes` + - `functions_by_file` + - `enum_constants` + - `include_graph` + - `system_includes` + - `unresolved_includes` + - `header_source_pairs` + - `diagnostics` + +Serialization uses `"model"` to identify concrete `CType` nodes; `"type"` is +reserved for semantic type relationships such as `CVariable.type` and +`CTypedef.type`. Concrete qualifier objects serialize using their canonical +spellings, such as `"const"`. Reused aggregate/typedef objects serialize as +references to avoid cycles. + +Future parser phases can deepen symbol links, duplicate/conflict diagnostics, +conditional region ownership, and project diagnostics when the corresponding +behavior lands. Additions should be documented and tested with stable +serialization expectations. + +## Grammar-Style Parsing Strategy + +C does not have Fortran-style modules, but it still has parseable scoped +regions: + +- translation unit +- preprocessor directive lines +- external declarations +- function prototypes +- function definitions +- declaration specifier sequences +- declarators +- parameter declaration lists +- struct/union/enum definitions +- compound statement bodies + +The C parser parses external declarations by slicing top-level grammar +regions, not by scanning the full file repeatedly. The high-level flow should +be: + +1. Normalize source through a C lexer/preprocessor layer. +2. Produce tokens or logical source records with original source locations. +3. Visit the translation unit. +4. Split direct external declarations while balancing parentheses, brackets, + braces, string literals, and comments. +5. Classify each external declaration: + - include/preprocessor directive + - typedef + - function prototype + - function definition + - forward struct declaration or struct/union/enum definition + - file-scope variable/static const + - unsupported/macro-dependent declaration +6. Dispatch to a small visitor for that declaration kind. +7. Use a shared declaration-specifier and declarator parser to build type + references for functions, parameters, members, variables, and typedefs. +8. Ignore executable function bodies except where needed to find the matching + brace and preserve function start/end locations. + +## Declarator-Centered Design + +C type syntax is declarator-centered. Declarator parsing stays a first-class +subsystem, not a pile of ad hoc string splitting. The current parser applies +one recursive declarator path to variables, typedefs, function signatures, +parameters, and aggregate members; future work should extend that grammar-shaped +path rather than adding parallel splitting rules. + +Layered pieces: + +- declaration specifier parser + - storage classes: `extern`, `static`, `typedef`, `register`, `_Thread_local` + - qualifiers: `const`, `restrict`, `volatile`, `_Atomic` + - primitive base: `void`, `char`, `short`, `int`, `long`, `float`, `double`, + `_Bool`, `_Complex` + - signedness: `signed`, `unsigned` + - tags: `struct`, `union`, `enum` + - typedef-name references +- declarator parser + - identifier extraction + - pointer chains + - arrays + - function parameters + - parenthesized declarators + - function pointers + - anonymous abstract declarators where needed +- entity applier + - convert one declaration specifier plus one declarator into a typed model + - reuse this for function returns, parameters, members, variables, and typedefs + +This is the C equivalent of the Fortran parser's shared declaration backend. + +## Preprocessing Strategy + +The C frontend must be preprocessor-aware without trying to be a full C +preprocessor in v1. + +The practical rule is: x2py should not own preprocessor correctness. Partial +macro expansion is especially dangerous in C because macros can participate in +function names, type names, declarators, attributes, calling conventions, +visibility annotations, and entire declarations. Raw mode must therefore avoid +guessing what macro-expanded declarations mean. Macro-heavy APIs are still in +scope, but the supported path for those APIs is compiler-assisted preprocessing +with line mapping. The parser should support both raw-source mode and a later +preprocessed-input mode, and should store the facts it learns from either mode +in C parser models before any semantic IR conversion is attempted. + +Raw-source mode target: + +- Strip comments safely while preserving line numbers. +- Fold backslash-newline continuations. +- Record `#include` directives as structured include dependencies. +- Record `#define` object-like macros for simple constants. +- Record `#undef` directives as macro provenance. +- Record function-like macros as unsupported or deferred metadata. +- Record conditional directive presence as metadata only when needed for + provenance. +- Parse ordinary declarations only when they are visible without macro + expansion. +- Mark function-like wrappers and object-like declaration-prefix regions as + unsupported/deferred rather than treating them as parsed declarations. +- Do not select active branches from `#if`/`#ifdef` in raw mode. + +Compiler-assisted preprocessing target: + +- Accept a preprocessed stream from `.i` files or a configured compiler command + such as `cc -E` or `clang -E`. +- Preserve `#line` marker information so diagnostics can map preprocessed + declarations back to original files. +- Treat `#line`/linemarker directives as the source of truth for + `source_location` fields after preprocessing. +- Store both the original input path and the preprocessed origin metadata on + parsed models. +- Mark declarations discovered only after preprocessing with + `origin="preprocessed"` or equivalent model metadata. +- Record the macro definitions/include directories/preprocessor command that + produced the parse, because different `-D` and `-I` settings can expose + different public APIs. +- Treat function-like macros as metadata in raw mode, but allow their expanded + declarations to be parsed when they appear in compiler-preprocessed input. +- Require preprocessed input whenever public declarations depend on macros for + names, types, declarators, attributes, storage classes, calling conventions, + visibility annotations, or active conditional branches. + +Initial non-goal: + +- Do not implement arbitrary macro expansion. +- Do not attempt token-paste/stringify semantics. +- Do not implement recursive compiler-compatible macro semantics inside x2py. +- Do not require libclang as the only way to understand headers. + +## Project Parsing Strategy + +C project parsing should account for include graphs instead of Fortran `use` +graphs. + +Current behavior: + +- `parse_c_project` accepts mappings, explicit paths, and directories. +- Directory mode currently discovers `.c` and `.h` files only. +- Returned `CProject` objects contain `CFile` parser models with raw include, + macro, metadata diagnostics, and supported declarations populated per file. +- Basic project-level indexes are populated for parsed functions, typedefs, + variables, macros, includes, functions by file, and enum constants. +- Quoted local includes are recorded in an `include_graph`; system includes + are recorded separately. Unresolved quoted includes remain diagnostics + rather than hard failures, and include cycles are represented as graph edges + without recursive traversal. +- Likely header/source pairs are reported by matching stems and direct source + includes. +- Basic cross-file typedef and struct/union/enum tag references are linked to + project index objects after all files are parsed. Original type spelling is + preserved in the model `source_text`. +- Duplicate/conflict analysis is not populated yet. + +Planned behavior after project-resolution phases: + +- Collect `.c`, `.h`, and eventually `.i` files from explicit paths or + directories. +- Parse headers and sources into `CFile` models. +- Deepen include graph behavior where normalized paths are ambiguous. +- Deepen duplicate/conflict diagnostics. +- Track duplicate symbols by C namespace: + - ordinary identifiers + - typedef names + - struct/union/enum tags + - labels are not wrapper-relevant and should not enter the public index +- Keep project resolution tolerant enough to parse partial projects, while + parser diagnostics and metadata preserve missing dependencies for later + semantic readiness. + +## Readiness Boundary + +The parser should not compute wrappability. That responsibility belongs to the +semantic layer, after parser models are converted into semantic IR or after an +edited `.pyi` file supplies the missing policy. + +What the parser should still preserve is the source information needed for that +later stage: + +- unresolved include references +- unresolved typedef/tag references +- macro-dependent declarations +- variadic functions +- pointer ownership and mutability ambiguity +- incomplete public types +- callback and function-pointer structure +- unsupported extension markers + +These should become parser diagnostics or parser metadata, not a parser-side +`wrappable` report or a parser JSON readiness payload. + +## Parser-First Model Policy + +For the current planning horizon, the C parser should store C-specific facts in +`c_parser/models.py`. It currently stores function-pointer signatures, +callback-candidate markers, type qualifiers, raw include dependencies, and +unresolved typedef/tag uses. Later phases should add preprocessing origin, +macro dependencies, ownership policy, and resolved symbol links. + +Semantic IR conversion is deliberately later work. When that phase starts, the +IR model may need extensions for C pointer ownership, unsigned integer types, +callbacks, opaque handles, function pointer policies, and preprocessing-origin +metadata. The parser should not wait for those IR decisions before preserving +the source facts it can extract. + +## Semantic IR Mapping + +The semantic layer is the source of truth. The C parser should only help create +or update semantic modules. + +Planned mapping: + +- C file or header group -> `SemanticModule` +- C function -> `SemanticFunction` +- C parameter -> `SemanticArgument` +- C primitive -> `SemanticType` +- C pointer -> constraints and ownership metadata +- C array -> `Shape(...)`, `ORDER_C`, and pointer/extent metadata +- `const` -> read-only ownership/constraint metadata +- `restrict` -> aliasing metadata +- structs/unions -> `SemanticClass` or named opaque semantic type +- enums -> constants or a future semantic enum representation +- typedefs -> semantic aliases or metadata, depending on IR support at the + time of implementation +- macros/constants -> `SemanticArgument` module variables with `Constant` + where safe + +Pointer ownership and lifetime should be conservative. Ambiguous pointers +should be represented with diagnostics and metadata rather than guessed as safe +Python APIs. + +## `.pyi` Integration + +Generated `.pyi` stubs for C should come after parser models and semantic IR +conversion are stable. Readiness, if added for C, should follow the semantic +layer pattern already used by the project. + +Likely stub patterns: + +- plain scalar functions: + - `def f(x: Int32) -> Float64: ...` +- pointer arguments: + - use semantic constraints such as `Pointer`, `Writable`, `Const`, `Shape` + only after the IR supports them cleanly +- arrays: + - `Float64[Shape("n"), ORDER_C]` +- opaque handles: + - classes or named semantic types with ownership constraints +- structs: + - `class struct_name: ...` when field layout is useful and stable +- callbacks: + - generated stubs should include callback declarations only after user policy + fields are designed and supported +- constants: + - `Final[...]` + +The existing `.pyi` parser already supports `Final`, `private`, `native_call`, +imports, classes, functions, shapes, and native projection entries. C-specific +work should extend the semantic model intentionally before changing `.pyi` +syntax. + +For function pointers and callbacks, parser extraction and later wrappability +are separate decisions. The parser should extract the function pointer type into +C models whenever possible. If a callback-bearing API later becomes wrappable, +that should be because the user supplied enough `.pyi` policy for the semantic +layer to make the decision. The policy needs to identify: + +- the callback signature, including argument and return semantic types +- whether native calls Python, Python passes a callback to native, or both +- whether the callback is used only during the call or stored by native code +- which context/userdata parameter, often `void *`, is paired with it +- whether `NULL` is allowed for the callback and/or context +- the calling convention when it is not the platform default +- whether invocation is synchronous, asynchronous, same-thread, or arbitrary + native-thread +- who owns callback and context memory +- how and when a stored callback is released +- what should happen if the Python callback raises + +Until those fields exist and are supplied, any future readiness layer should +report an explicit callback policy blocker rather than pretending the function +is safely wrappable. + +## Isolation Policy + +All C parser work must be isolated from project `main` until the C frontend is +mature and stable. + +Long-lived integration branch: + +```text +c-parser/main +``` + +Roadmap branch: + +```text +c-parser/phase-0-roadmap +``` + +Future feature branches should be created from `c-parser/main` and merged only +back into `c-parser/main`, for example: + +```text +c-parser/phase-1-cli-and-docs +c-parser/phase-2-testing +c-parser/phase-3-models +c-parser/phase-4-lexer +c-parser/phase-5-declarations +c-parser/phase-6-functions +c-parser/phase-7-structs-enums +c-parser/phase-8-project-resolution +c-parser/phase-9-semantic-readiness +c-parser/phase-10-semantics +c-parser/phase-11-pyi +c-parser/phase-12-corpus-stabilization +``` + +No C parser branch should merge directly into project `main` until the +frontend has stable parser behavior, docs, CLI, tests, semantic readiness +integration, semantic conversion, and `.pyi` expectations. diff --git a/docs/c_parser/c_parser_cli_workflow.md b/docs/c_parser/c_parser_cli_workflow.md new file mode 100644 index 000000000..82492c585 --- /dev/null +++ b/docs/c_parser/c_parser_cli_workflow.md @@ -0,0 +1,482 @@ +# C Parser CLI Workflow Plan + +Status: C parser partial subset plus raw directive metadata implemented. The +CLI command shape exists and parse reports can include raw includes, simple +macros, `#undef` and conditional directive provenance, top-level +redeclaration diagnostics, project include/index metadata, diagnostics, +variables, typedefs, +aggregate declarations, function prototypes, prototype-style metadata, and +function-definition signatures with start/end locations. Declarator output can +represent parenthesized pointer/array precedence through concrete +`CComposedType` components and nameless `CFunctionType` signatures; function +parameters expose both declared and C-adjusted effective type facts. + +This document records the implemented C parse command shape, output schema, +and diagnostic contract, plus deferred CLI behavior. + +## Current Status + +Implemented commands: + +```bash +python -m x2py path/to/api.h --language c --parse +python -m x2py path/to/api.h --language c --parse --json +python -m x2py path/to/api.h --language c --parse --out report.json +``` + +The C parser accepts explicit `.c` and `.h` files, plus directories in explicit +C mode. Directory scanning in C mode only collects `.c` and `.h` files. +Auto-detection is deferred, so omitting `--language` keeps the current Fortran +behavior. + +The C parser output differs from Fortran parser output by using C-specific +top-level sections: `functions`, `structs`, `unions`, `enums`, `typedefs`, +`variables`, `macros`, `includes`, and `diagnostics`. The current partial parser +can populate `functions`, `typedefs`, `variables`, `structs`, `unions`, and +`enums` in the supported subset. Typedefs, variables, parameters, and aggregate +members can include concrete composed types for pointer/array/function forms, +including function pointers, functions returning function pointers, and +legal final flexible struct members marked with `is_flexible=True`. Array and +function parameters preserve written `declared_type` forms while effective +`type` values use pointer adjustment. Raw +`includes`, `macros`, `raw_directives`, `macro_dependencies`, and metadata +`diagnostics` can also be populated. `parse_c_project(...)` additionally +populates project-level include/index fields such as `include_graph`, +`system_includes`, `unresolved_includes`, `functions_by_file`, +`enum_constants`, and `header_source_pairs`. Those fields require project +context; a single-file parse only records the local file facts. +The object class distinguishes declarations (`CFunction`, +`CVariable`, `CTypedef`, `CStruct`, `CUnion`, or `CEnum`), and incomplete tag +declarations set `is_incomplete=True`. +Known unsupported declaration forms such as declaration attributes, alignment +specifiers, `_Atomic(type)`, nested aggregate member definitions, and static assertions are +reported in diagnostics with explicit `unit_kind` values; unconsumed declarator +suffixes are diagnosed instead of silently omitted. Invalid flexible array +member placement and flexible union members produce +`C_INVALID_FLEXIBLE_ARRAY_MEMBER` error diagnostics at the field location. The parser reports +`parser_status: "partial"`. C parse diagnostics, currently including +unsupported K&R-style function definitions and invalid primitive-specifier +combinations such as `unsigned float`, honor `--no-color` and `NO_COLOR=1`. +Active CLI regression tests also verify that `--debug-traceback` and +`C_PARSER_DEBUG=1` re-raise fatal C parse errors for debugging. +Function definitions do not store executable body text; they preserve a +direct `start` location and `end` location from the signature start through the +closing brace. Compatible repeated top-level declarations are merged; +prototype-plus-definition records prefer the definition and preserve prototype +locations in `declaration_locations`. File-scope tentative declarations such +as `int i; int i;` are also merged. Duplicate definitions and incompatible +top-level redeclarations are reported as diagnostics. Local declarations inside +function bodies are not parsed. + +Unsupported C stages: + +```bash +python -m x2py path/to/api.h --language c --semantics +python -m x2py path/to/api.h --language c --pyi +python -m x2py path/to/api.h --language c --wrap-readiness +``` + +These commands return clear argparse errors until C semantic IR conversion and +`.pyi` generation are implemented. Fortran-only parse display flags such as +`--show-vars` and `--print-limit` are rejected in C mode. + +## Current CLI Baseline + +The current `x2py` CLI is Fortran-oriented: + +```bash +python -m x2py --parse +python -m x2py --parse --json +python -m x2py --wrap-readiness +python -m x2py --semantics +python -m x2py --semantics --wrap-readiness +python -m x2py --pyi +``` + +Important current behaviors to preserve: + +- Stage flags are explicit: `--parse`, `--semantics`, `--pyi`. +- `--out` writes stage output and suppresses stdout. +- `--json` prints JSON for the selected stage output. +- `--wrap-readiness` is semantic readiness. It can be requested alone for + Fortran or `.pyi` inputs, or combined with other stages. +- Parser JSON remains parse-only. Combined `--parse --wrap-readiness --json` + keeps parse and readiness payloads in separate top-level sections. +- Parse diagnostics are compiler-style and go to stderr. +- Python tracebacks are hidden by default. +- `--debug-traceback` or parser debug env vars re-raise parse errors. +- Diagnostics use ANSI color by default unless `--no-color` or `NO_COLOR=1` + disables it. +- Human parse output is a stable tree. +- JSON parse output is a stable per-file object keyed by input path. + +The C CLI must integrate without breaking any of these Fortran behaviors. + +## Command Shape Recommendation + +Strong initial preference: + +```bash +x2py --language c --parse +``` + +Rationale: + +- It is explicit. +- It scales to future language frontends. +- It avoids surprising users by auto-detecting mixed-language directories too + early. +- It lets Fortran remain the default during the long C parser stabilization + period. + +Optional short alias, not implemented: + +```bash +x2py --parse-c +``` + +The short alias is convenient, but should be secondary. If added, it should be +implemented as a strict alias for `--language c --parse`. + +Auto-detection should be later: + +```bash +x2py --parse +``` + +Auto-detection should wait until C parser behavior is mature enough to handle +mixed source trees predictably. Until then, `--parse` without `--language` +should keep existing Fortran behavior. + +## Flags And Deferred Options + +Initial flags: + +```text +--language {fortran,c} +--parse +--json +--out [PATH] +--no-color +--debug-traceback +``` + +Current C behavior also accepts `--no-color`. `CParseError` supports +compiler-style diagnostic formatting and the `C_PARSER_DEBUG` environment +variable. The current grammar subset is tolerant for recoverable unsupported +declaration forms, but invalid primitive-specifier combinations raise +`CPARSE003`; unresolved single typedef-name uses are deferred until type +resolution can determine whether a declaration exists. + +C-specific flags to add only when needed: + +```text +--include-dir PATH +--show-macros +--show-includes +--print-limit N +``` + +Potential later flags: + +```text +--auto-language +--project +--header-mode +--source-mode +--preprocessed +--preprocess-command PATH_OR_COMMAND +--define NAME[=VALUE] +--undef NAME +``` + +`--define` and `--undef` should belong to compiler-assisted preprocessing, not +to raw parser-side macro evaluation. Raw C mode records directives and parses +ordinary visible declarations only; it does not select `#if` branches or expand +macros. A declaration prefixed by an unexpanded object-like macro is deferred +as macro-dependent rather than treated as an invalid type sequence. + +## Current Partial Behavior + +Phase 1 implemented CLI structure before a real declaration parser existed. +The command shape remains stable as the parser starts populating model fields: + +```bash +x2py include/example.h --language c --parse +``` + +Human output: + +```text +File: include/example.h + Language: c + Functions: 1 + Structs: 0 + Unions: 0 + Enums: 0 + Typedefs: 0 + Variables: 0 + Macros: 0 + Includes: 0 + Diagnostics: 0 + Parser status: partial +``` + +JSON output for a file without raw directives: + +```json +{ + "include/example.h": { + "filename": "include/example.h", + "language": "c", + "parser_status": "partial", + "preprocessing": "raw", + "functions": [ + { + "name": "run", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": false, + "prototype_style": "prototype", + "source_location": {"filename": "include/example.h", "line": 1, "...": "..."}, + "start": {"filename": "include/example.h", "line": 1, "...": "..."}, + "end": null, + "declaration_locations": [] + } + ], + "structs": [], + "unions": [], + "enums": [], + "typedefs": [], + "variables": [], + "macros": [], + "includes": [], + "raw_directives": [], + "macro_dependencies": [], + "diagnostics": [] + } +} +``` + +The parser should not claim C files are wrappable. If C readiness is added +later, it should follow the semantics-owned readiness boundary used elsewhere +in x2py, not become parser JSON. + +For raw directives, the same JSON shape is used, but `includes`, `macros`, +`raw_directives`, `macro_dependencies`, and `diagnostics` may contain populated +model dictionaries. Function-like macros are recorded as macro metadata and +also produce a non-fatal `C_UNSUPPORTED_FUNCTION_LIKE_MACRO` diagnostic. +Function-like declaration wrappers and object-like declaration prefixes are +marked through `macro_dependencies` without being parsed as expanded +declarations. Local quoted includes are resolved +relative to the current file or configured include dirs when possible; +unresolved local includes produce `C_UNRESOLVED_INCLUDE` diagnostics instead +of hard failures. + +Raw mode must not claim support for macro-generated declarations. If macros +affect function names, types, parameters, attributes, storage classes, calling +conventions, visibility annotations, or active conditional branches, the user +should provide compiler-preprocessed input later through a `.i` file or an +explicit preprocessor command. That preprocessed path must preserve +`#line`/linemarker mappings so parser diagnostics and JSON `source_location` +fields still point back to the original `.h` or `.c` file. + +## JSON Parse Schema + +The C parse JSON is per-file and does not reuse Fortran key names when the +concepts differ. Current top-level per-file keys: + +```text +language +filename +parser_status +preprocessing +functions +structs +unions +enums +typedefs +variables +macros +includes +raw_directives +macro_dependencies +diagnostics +``` + +Declaration/directive records include `source_location`; diagnostics use +`location`. Concrete type components preserve `source_text` rather than their +own source-location object: + +```text +source_location: { + filename: str | null, + line: int | null, + column: int | null, + source_line: str | null +} + +location: { + filename: str | null, + line: int | null, + column: int | null, + source_line: str | null +} +``` + +Concrete `CType` values serialize with a `"model"` discriminator, for example +`{"model": "CInt", "qualifiers": [], "source_text": "int"}`. The `"type"` +key is reserved for a semantic relationship such as a `CVariable` or +`CTypedef` pointing to its declared type. Qualifier objects serialize as +canonical spelling strings such as `"const"`. Aggregate/typedef object reuse +emits a reference rather than a recursive JSON cycle. + +## Human Tree Output + +The current human tree is the count-only report shown above. A later expanded +tree could mirror the Fortran parser style: + +Initial mature output shape: + +```text +File: src/api.c + Includes: 2 + - api.h + - stddef.h + Functions: 2 + - int add(int a, int b) + - void scale(double *x, size_t n) + Structs: 1 + - struct vector (members=2) + Typedefs: 1 + - vector_t -> struct vector + Macros: 1 + - MAX_DIM = 16 +``` + +Future semantic readiness output should be described in the semantic-layer +documentation, not in the parser CLI workflow. + +## Diagnostics Behavior + +Fatal C syntax errors use `CParseError` with the same user experience as +`FortranParseError`: + +```text +src/api.h:12:5: error[CPARSE001]: Unsupported declaration. + | +12 | __attribute__((vector_size(16))) float v; + | ^ +``` + +Default CLI behavior: + +- print the formatted diagnostic to stderr +- exit with status code `1` +- do not show Python traceback +- colorize when color is enabled + +Unsupported but recoverable declarations and raw preprocessor limitations are +stored as non-fatal `CDiagnostic` entries in the parse report instead. +Invalid primitive-specifier combinations that are independent of symbol +resolution are fatal: + +```text +src/api.h:12:1: error[CPARSE003]: Invalid type specifier sequence 'unsigned float'. +12 | unsigned float value; + | ^ +``` + +Debug behavior: + +- `--debug-traceback` re-raises the error +- `C_PARSER_DEBUG=1` re-raises C parser errors +- `FORTRAN_PARSER_DEBUG` should not control C behavior +- a generic `X2PY_DEBUG=1` may be considered later + +Color behavior: + +- `--no-color` disables ANSI diagnostics +- `NO_COLOR=1` disables ANSI diagnostics +- Windows color behavior can follow the existing `colorama` pattern + +## CLI Test Expectations + +The active CLI/parser tests cover the current partial subset: + +- Existing Fortran CLI tests still pass unchanged. +- `python -m x2py --help` lists `--language`. +- `python -m x2py --language c --parse` is accepted. +- `python -m x2py --parse-c` is not implemented. +- `--language c --parse --json` emits stable partial-parser JSON with raw + include/macro metadata and supported declarations when present. +- `--language c --parse --out report.json` writes JSON and suppresses stdout. +- `--language c --parse --no-color` is accepted. +- `--language c --parse --debug-traceback` is accepted. +- raw comment stripping, line-continuation folding, top-level splitting, + include collection, simple macro collection, function-like macro diagnostics, + object-like macro declaration-prefix deferral, + conditional non-selection, simple declarations, variables, typedefs, + parenthesized declarators, function pointer typedefs/parameters, recursive + declarator combinations, concrete declaration objects, aggregate + definitions/members/enumerators, incomplete struct/union tags, and function + signatures with definition start/end locations are covered by focused C tests. +- valid reordered primitive specifiers and fatal invalid primitive-specifier + combinations are covered by focused C tests. +- flexible array member classification/validation, per-member source + locations, and named/unnamed/zero-width bit-field source facts are covered + by focused C tests. +- array and function parameter declared/effective type adjustment is covered + by focused C tests. +- `--show-vars` and `--print-limit` are rejected in C mode until C-specific + display controls exist. +- `--semantics` with `--language c` is rejected until C semantic conversion is + implemented. +- `--pyi` with `--language c` is rejected until C `.pyi` emission is + implemented. + +## Integration Order + +Completed order: + +1. Added CLI language selection behind explicit flags. +2. Kept Fortran as default behavior. +3. Added a C parser package and initial report provider. +4. Added C-specific docs for command shape and staged output. +5. Added CLI/API tests around discovery, stable command behavior, JSON, output + files, public entrypoints, and diagnostic formatting. +6. Added raw lexer/directive metadata collection for comments, + continuations, includes, simple macros, and unsupported function-like + macros. +7. Added top-level splitting and a first partial grammar subset for simple + variables, typedefs, function prototypes, and function-definition headers. +8. Added function-definition start/end locations while continuing to skip + executable bodies. +9. Added forward `struct name;` extraction as incomplete `CStruct` source facts. +10. Replaced ad hoc declarator splitting with a recursive grammar-style + declarator parser for pointer prefixes, parenthesized direct declarators, + and array/function suffixes. +11. Classified each declarator from its recursive type and added basic + struct/union/enum declarations, members, tag typedefs, and trailing tag + variables as concrete parser models. +12. Replaced generic type references and declaration-kind tags with concrete + `CType` subclasses, `CComposedType` components, and concrete declaration + objects. +13. Added order-insensitive primitive specifier validation and `CPARSE003` + errors for invalid primitive combinations while retaining unresolved + typedef-name references for later resolution. +14. Added field-level source locations, flexible array member classification + and invalid-use diagnostics, plus explicit bit-field regression coverage. +15. Added C array/function parameter adjustment while preserving written + parameter type facts in `declared_type`. + +Next implementation work should continue with tag/typedef resolution, +preprocessed-input line mapping, compiler extension policy, and project +resolution while keeping the explicit `--language c` gate in place. diff --git a/docs/c_parser/c_parser_implementation_checklist.md b/docs/c_parser/c_parser_implementation_checklist.md new file mode 100644 index 000000000..3d6def3f3 --- /dev/null +++ b/docs/c_parser/c_parser_implementation_checklist.md @@ -0,0 +1,1472 @@ +# C Parser Implementation Checklist + +Status: implementation checklist with Phase 1 skeleton, Phase 2 parser/error +golden workflow, selected Phase 3 model/error work, Phase 4 raw +lexer/directive metadata, a first Phase 5/6 partial declaration/function +subset including top-level redeclaration handling, and selected Phase 8 project +include/index work complete. The +`c_parser` package and explicit C +parse path exist, and simple variables, typedefs, function prototypes, +function-definition signatures, function-definition start/end locations, and +incomplete `struct`/`union` declarations and basic aggregate definitions are +now parsed. Declarators use a recursive grammar-style parser for pointer, +array, function, and parenthesized combinations. Declaration types are concrete +`CType` subclasses combined by `CComposedType`; aggregate members are +`CVariable` objects using the same declared-type path. Selected unsupported +extensions are diagnosed, and invalid primitive-specifier combinations raise +`CParseError` without treating unresolved single typedef-name uses as invalid. +Aggregate members carry their own source locations, and flexible array +members are classified and checked for supported struct/union constraints. +Function parameters preserve written array/function forms in `declared_type` +while exposing C-adjusted pointer forms in `type`. Raw conditional directives +and macro-shaped declarations, including object-like declaration prefixes, are +stored as metadata. Project parsing now +records include graphs, system and unresolved includes, functions by file, +enum constants, header/source pairings, and basic cross-file typedef/tag +resolution with incomplete tag completion. Compatible top-level prototypes, +tentative file-scope variables, and repeated typedefs are merged; duplicate +definitions and incompatible redeclarations produce diagnostics. Local +declarations inside function bodies are intentionally ignored. + +This checklist is intentionally detailed so future work can proceed one branch, +one checklist item, and one tested capability at a time. The C parser initiative +must remain isolated from project `main` until the frontend is mature and +stable. + +## Progress Snapshot + +- Last updated: 2026-05-24 +- Checklist progress: 623/873 checked (71.4%). +- Current parser status: partial C parser with raw directive metadata, top-level + source splitting, simple declarations/variables/typedefs, prototype-style + metadata, K&R diagnostics, simple function signatures, and start/end + locations for function definitions. Incomplete struct/union declarations are + recorded as `CStruct`/`CUnion` values with `is_incomplete=True`; named tags + are indexed at project level. Parenthesized declarators, function pointer + typedefs/parameters, callback members, and functions returning function + pointers are represented with concrete `CType` objects and + `CComposedType.components`. Primitive specifiers have concrete type classes, + valid spelling permutations are normalized, invalid combinations raise + `CPARSE003`, and functions, variables, typedefs, and aggregates are + distinguished by their concrete declaration objects rather than a kind field. + Struct and union fields now preserve per-member locations; legal final + flexible struct members are marked through `CArray.is_flexible`, with error + diagnostics for invalid placement or union use. Array and function + parameter declarations preserve their source form in `declared_type` while + their effective `type` applies C parameter-to-pointer adjustment. Raw + conditional directives and macro-shaped declaration dependencies, including + object-like declaration prefixes, are recorded as metadata. `parse_c_project` + returns project include/index facts and + resolves basic cross-file typedef and tag references while preserving + unresolved references for later diagnostics. Top-level compatible + redeclarations are merged, matching prototypes plus definitions prefer the + definition while preserving declaration locations, and duplicate/conflicting + top-level declarations produce diagnostics. + +## Global Rules + +- [ ] Keep all C parser work on `c-parser/main` and child branches until the + frontend is stable. +- [ ] Do not merge C parser work directly into project `main`. +- [ ] Keep the Fortran parser behavior unchanged unless a future task + explicitly requires shared infrastructure changes. +- [x] Put C parser implementation in a separate `c_parser` package. +- [x] Keep C parser tests separated from existing Fortran tests. +- [x] Gate all integration through explicit C flags or C-specific APIs. +- [ ] Keep any C wrappability assessment in the semantic layer, not inside the + parser package. +- [x] Implement C parsing as a grammar-style recursive parser with scoped + visitors, source slicing, shared declaration/declarator parsing helpers, + and typed model objects. +- [x] Store initial C-specific facts in `c_parser/models.py`; defer semantic IR + extensions until the C parser models prove what information is needed. +- [ ] Keep the C parser main-merge guard active for C parser branches and + paths. +- [ ] Require the `c-parser-ready-for-main` label only for the final approved + merge into project `main`. +- [x] Do not implement a giant regex parser. +- [x] Do not implement a whole-file scanner as the core architecture. +- [x] Do not make libclang the only parser architecture. +- [ ] Do not make compiler preprocessing a replacement for x2py parser models, + source locations, diagnostics, or project indexes. +- [x] Preserve the semantic IR layer as the source of truth. +- [x] Treat documentation as a first-class deliverable in every phase. +- [ ] Whenever C parser behavior, models, CLI behavior, tests, fixture + workflows, semantic integration, or `.pyi` behavior change, update every + affected file under `docs/c_parser/` in the same change. Do not wait for + a separate documentation request. +- [x] Update this checklist when implementation reality changes. + +## Phase 0: Repository Inspection, Branch Setup, And Roadmap + +Branch target: + +- `c-parser/main` +- `c-parser/phase-0-roadmap` + +Scope: + +- Planning only. +- Documentation only. +- No parser package. +- No parser logic. +- No CLI code changes. +- No fixture generation. + +### Branch And Isolation Tasks + +- [x] Start from project `main`. +- [x] Create long-lived integration branch `c-parser/main`. +- [x] Create planning branch `c-parser/phase-0-roadmap` from + `c-parser/main`. +- [x] Merge `c-parser/phase-0-roadmap` back into `c-parser/main`. +- [x] Confirm `main` has no C parser planning commits unless intentionally + merged later after stabilization. +- [x] Record the branch strategy in C parser docs. +- [x] Use `codex: ...` prefix for planning commit message. + +### Repository Inspection Tasks + +- [x] Inspect `README.md`. +- [x] Inspect `fortran_parser.md`. +- [x] Inspect `parser_implementation_reference.md`. +- [x] Inspect `Semantic_Multilanguage_Wrapper_Runtime_Architecture.md`. +- [x] Inspect `docs/pyi_format.md`. +- [x] Inspect `fortran_parser/lexer.py`. +- [x] Inspect `fortran_parser/parser.py`. +- [x] Inspect `fortran_parser/models.py`. +- [x] Inspect `fortran_parser/type_resolver.py`. +- [x] Inspect `fortran_parser/utils.py`. +- [x] Inspect `fortran_parser/cli.py`. +- [x] Inspect `x2py/cli.py`. +- [x] Inspect `x2py/__init__.py`. +- [x] Inspect `semantics/models.py`. +- [x] Inspect `semantics/fortran2ir.py`. +- [x] Inspect `semantics/pyi_printer.py`. +- [x] Inspect `semantics/pyi_parser.py`. +- [x] Inspect parser CLI tests. +- [x] Inspect parser public entrypoint tests. +- [x] Inspect parser developer tutorial tests. +- [x] Inspect semantic wrap-readiness tests. +- [x] Inspect parser error handling tests. +- [x] Inspect parser fixture/golden suite. +- [x] Inspect parser golden regeneration script. +- [x] Inspect parser error golden regeneration script. +- [x] Inspect semantic conversion tests. +- [x] Inspect semantic fixture generator. +- [x] Inspect `.pyi` tests. +- [x] Inspect `.pyi` fixture generator. +- [x] Avoid spending analysis on ignored Fortran source fixtures except file + layout and fixture workflow. +- [x] Avoid spending analysis on generated JSON fixtures. + +### Planning Document Tasks + +- [x] Create `docs/c_parser/`. +- [x] Create `docs/c_parser/c_parser_reference.md`. +- [x] Create `docs/c_parser/c_parser_architecture.md`. +- [x] Create `docs/c_parser/c_parser_cli_workflow.md`. +- [x] Create `docs/c_parser/c_parser_implementation_checklist.md`. +- [x] Create `docs/c_parser/c_parser_main_merge_guard.md`. +- [x] Document the branch isolation strategy. +- [x] Document the main-merge guard policy. +- [x] Document Fortran parser architecture observations. +- [x] Document proposed C parser package layout. +- [x] Document public API shape. +- [x] Document CLI command shape. +- [x] Document early skeleton CLI behavior. +- [x] Document JSON schema direction. +- [x] Document semantic readiness direction. +- [x] Document semantic IR mapping direction. +- [x] Document `.pyi` integration direction. +- [x] Document v1 non-goals. + +### Phase 0 Definition Of Done + +- [x] Planning docs exist under `docs/c_parser/`. +- [x] Docs clearly say no parser implementation exists yet. +- [x] Docs make CLI and documentation Phase 1 deliverables. +- [x] Docs preserve the grammar-style parser requirement. +- [x] Docs preserve project-main isolation. +- [x] Main-merge guard policy is documented. +- [x] Planning branch is committed. +- [x] Planning branch is merged into `c-parser/main`. + +### Phase 0 Test Expectations + +- [x] No test changes are required in Phase 0. +- [x] Run a documentation-safe sanity command such as `git status`. +- [x] Do not regenerate fixtures. +- [x] Do not run parser golden update scripts. + +### Phase 0 Risks And Open Questions + +- [x] Decide whether the future package should be named `c_parser` or another + name before code lands. +- [x] Decide whether `x2py.__init__` should expose C APIs during skeleton phase + or wait until Phase 3 models are useful. +- [x] Decide whether C debug env var should be `C_PARSER_DEBUG` or generic + `X2PY_DEBUG`. + +## Phase 1: CLI And Documentation Skeleton First + +Branch target: + +- `c-parser/phase-1-cli-and-docs` + +Scope: + +- User-visible command shape. +- Documentation skeleton. +- Placeholder C parser reports. +- CLI tests. +- No real parser logic. + +### Documentation Tasks + +- [x] Update `docs/c_parser/c_parser_cli_workflow.md` with implemented command + examples. +- [x] Update `docs/c_parser/c_parser_reference.md` with skeleton CLI behavior. +- [x] Add a "Current Status" section showing which C features are placeholder + only. +- [x] Document how C parser output differs from Fortran parser output. +- [x] Document that auto-detection is deferred. +- [x] Document that `--language c` is required initially. +- [x] Document unsupported `--semantics --language c` behavior. +- [x] Document unsupported `--pyi --language c` behavior. +- [x] Document C parser diagnostics even if only skeleton diagnostics exist. +- [x] Add examples for parse tree, JSON, and output file behavior. + +### CLI Design Tasks + +- [x] Add `--language {fortran,c}` to `x2py.cli`. +- [x] Preserve current Fortran behavior when `--language` is omitted. +- [x] Make `--language fortran` equivalent to current behavior. +- [x] Add explicit C parse path behind `--language c --parse`. +- [x] Decide not to add `--parse-c` alias in this phase. +- [ ] If `--parse-c` is added, make it an alias for `--language c --parse`. +- [x] Reject `--language c` without a supported stage flag. +- [x] Reject `--language c --semantics` until Phase 10. +- [x] Reject `--language c --pyi` until Phase 11. +- [x] Reject Fortran-only flags in C mode if they do not apply. +- [x] Keep `--json` behavior stable for parse output. +- [x] Keep `--out` behavior stable for C parse JSON. +- [x] Keep `--no-color` accepted in C mode. +- [x] Keep `--debug-traceback` accepted in C mode. +- [x] Do not change `fortran_parser.cli` unless a compatibility reason is + documented. + +### Skeleton Report Tasks + +- [x] Create a minimal C report provider without real parsing. +- [x] Ensure skeleton C report can accept `.c` and `.h` paths. +- [x] Ensure skeleton C report can accept directories only in explicit C mode. +- [x] Return `language: "c"` in C JSON output. +- [x] Return `parser_status: "skeleton"` in C JSON output. +- [x] Return empty `functions` list. +- [x] Return empty `structs` list. +- [x] Return empty `unions` list. +- [x] Return empty `enums` list. +- [x] Return empty `typedefs` list. +- [x] Return empty `variables` list. +- [x] Return `macros` list, empty until raw macro directives are found. +- [x] Return `includes` list, empty until raw include directives are found. +- [x] Return `diagnostics` list, empty unless skeleton or raw metadata + diagnostics are found. +- [x] Human tree output should show zero-count C sections and skeleton status. + +### CLI Test Tasks + +- [x] Add C CLI tests in a C-specific test file, for example + `tests/parser/test_c_cli_skeleton.py` or `tests/c_parser/test_cli.py`. +- [x] Test existing Fortran CLI behavior still passes. +- [x] Test `--help` shows `--language`. +- [x] Test `--language c --parse` accepts a temporary `.h` file. +- [x] Test `--language c --parse --json` emits valid JSON. +- [x] Test `--language c --parse --out report.json` writes JSON and suppresses + stdout. +- [x] Test `--language c --semantics` returns argparse error or clear + unsupported-stage error. +- [x] Test `--language c --pyi` returns argparse error or clear + unsupported-stage error. +- [x] Test `--language c --parse --show-vars` is rejected or ignored with + documented behavior. +- [x] Test `--parse` without `--language` remains Fortran behavior. +- [ ] If `--parse-c` is added, test it maps to C parse mode. +- [x] Test `--no-color` is accepted in C mode. +- [x] Test `NO_COLOR=1` is honored once C diagnostics exist. +- [x] Test `--debug-traceback` is accepted in C mode. + +### Phase 1 Definition Of Done + +- [x] Users can discover C mode from CLI help. +- [x] Users can run a stable C parse skeleton command. +- [x] C JSON skeleton output has a documented schema. +- [x] Fortran CLI behavior is unchanged. +- [x] Documentation includes the exact command workflow. +- [x] Tests cover the skeleton command workflow. + +### Phase 1 Risks And Open Questions + +- [x] Decide whether to implement a temporary skeleton module inside + `x2py.cli` or create `c_parser/cli.py` early. +- [x] Decide whether skeleton output should include zero-count sections in + human output or omit empty sections like Fortran. +- [x] Decide whether `--json` should eventually support semantic C output or + stay parse-only. + +## Phase 2: Testing Infrastructure + +Branch target: + +- `c-parser/phase-2-testing` + +Scope: + +- Test directories, fixtures, golden scripts, and update workflow. +- Minimal placeholder fixtures are allowed. +- Skipped roadmap tests are allowed before parser implementation exists. +- No real parser logic unless needed to support skeleton output already added. + +### Test Layout Tasks + +- [x] Create a dedicated C parser test area. +- [x] Choose between `tests/c_parser/` and `tests/parser/c/` for focused C + parser tests. +- [x] Create `tests/data/c/general/`. +- [x] Create `tests/data/c/errors/parser/`. +- [x] Create `tests/data/c/corpus/`. +- [x] Create `tests/data/c/scientific/`. +- [x] Add `tests/data/c/json/` real-world partial-parser regression inputs. +- [x] Add `tests/data/c/tinyexpr/` real-world partial-parser regression inputs. +- [x] Add `tests/data/c/linmath/` header-only partial-parser regression input. +- [x] Add `tests/data/c/nanosvg/` dependent-header partial-parser regression + inputs. +- [x] Add top-level `tests/data/c/stb/` single-file library regression inputs + without vendoring nested repository metadata as fixtures. +- [x] Create `tests/parser/c/fixtures/general/`. +- [x] Create `tests/parser/c/fixtures/json/`. +- [x] Create `tests/parser/c/fixtures/tinyexpr/`. +- [x] Create `tests/parser/c/fixtures/linmath/`. +- [x] Create `tests/parser/c/fixtures/nanosvg/`. +- [x] Create `tests/parser/c/fixtures/stb/`. +- [x] Create `tests/parser/c/fixtures/errors/`. +- [x] Keep C fixture data separate from Fortran fixture data. +- [x] Add README files explaining each C fixture directory. +- [x] Add small `.h` and `.c` fixture files for C fixture coverage. + +### Skipped Roadmap Test Policy + +- [x] Add skipped C parser roadmap tests before implementation starts. +- [x] Keep every roadmap test skipped until its implementation branch lands. +- [x] Keep `c_parser` imports inside skipped test functions, not at module + import time, so collection works before the package exists. +- [x] Use the skipped tests as an executable checklist for future branches. +- [x] Unskip tests one capability at a time. +- [x] In each implementation branch, unskip only the tests covered by that + branch. +- [x] Do not unskip broad fixture, corpus, semantic, or `.pyi` tests before + the supporting workflow exists. +- [x] When a skipped test is unblocked, replace placeholder expectations with + the exact implemented model fields if the final schema differs. +- [x] Keep the skipped C suite separate from existing Fortran tests. +- [x] Keep Fortran tests green whenever C tests are unskipped. + +### Roadmap And Active Test Files + +- [x] Create `tests/parser/c/README.md` with the staged unskip policy. +- [x] Consolidate implemented public API roadmap coverage into + `tests/parser/c/test_c_public_api_skeleton.py`. +- [x] Consolidate implemented CLI roadmap coverage into + `tests/parser/c/test_c_cli_skeleton.py`. +- [x] Create `tests/parser/c/test_c_lexer_preprocessor.py`. +- [x] Create `tests/parser/c/test_c_declarations_and_declarators.py`. +- [x] Create `tests/parser/c/test_c_functions.py`. +- [x] Create `tests/parser/c/test_c_structs_unions_enums_typedefs.py`. +- [x] Consolidate implemented project/include roadmap coverage into + `tests/parser/c/test_c_project_resolution.py`. +- [x] Create `tests/semantics/test_c_semantic_readiness.py` or equivalent + semantic-layer coverage for C wrappability once that layer exists. +- [x] Create `tests/parser/c/test_c_fixture_suite.py`. +- [x] Create `tests/parser/c/test_c_error_fixture_suite.py`. +- [x] Create `tests/parser/c/test_c_json_sanity.py`. +- [x] Create `tests/parser/c/test_c_corpus.py`. + +### Golden Workflow Tasks + +- [x] Create `tests/parser/c/generate_c_parser_goldens.py`. +- [x] Mirror the Fortran parser golden generator structure. +- [x] Serialize only dataclass/JSON-stable C parse models. +- [x] Strip parent/back-reference fields if future models need them. +- [x] Generate one `CProject` golden per same-stem fixture group, pairing + `.c` and `.h` inputs when both exist. +- [x] Order `.c` before its matched `.h` project input to mirror compilation + while include-expanded parsing remains deferred. +- [x] Support explicit dependent-header project groups ordered from included + header to dependent header. +- [x] Generate separate one-file project goldens for STB single-file library + inputs. +- [x] Support updating all fixtures. +- [x] Support updating selected fixtures. +- [x] Add an environment variable update flow, for example + `C_PARSER_UPDATE_GOLDENS=1`. +- [x] Document whether C uses `C_PARSER_UPDATE_GOLDENS` or a generic + `X2PY_UPDATE_GOLDENS`. +- [x] Create a C error golden generator. +- [x] Store expected error type, message fragments, diagnostic fragments, and + parser entrypoint metadata. + +### Focused Test Buckets + +- [x] Add lexer test file. +- [x] Add preprocessor test file. +- [x] Add declaration-specifier test file. +- [x] Add declarator test file. +- [x] Add function parser test file. +- [x] Add struct/union/enum parser test file. +- [x] Add typedef parser test file. +- [x] Add macro/constant parser test file. +- [x] Add project/include parser test file. +- [x] Add semantic readiness test file when C semantic conversion exists. +- [x] Add public entrypoint test file. +- [ ] Add developer tutorial test file once internal helpers exist. +- [x] Add CLI test file. +- [x] Add fixture/golden test file. +- [x] Add error fixture/golden test file. +- [ ] Add semantic conversion tests in Phase 10. +- [ ] Add `.pyi` tests in Phase 11. + +### Phase 2 Definition Of Done + +- [x] C test directory structure is present. +- [x] C fixture directory structure is present. +- [x] C golden update workflow is documented. +- [x] Partial parser and metadata tests pass against current behavior. +- [x] Fortran tests still pass. +- [x] No real parser claims are made without tests. + +### Phase 2 Test Expectations + +- [x] Run the skipped C roadmap suite and confirm it collects without importing + `c_parser` at module import time. +- [x] Run C skeleton CLI tests. +- [x] Run existing parser CLI tests. +- [x] Run a small targeted test command, for example + `python -m pytest -q tests/parser/test_cli.py tests/parser/test_c_cli_skeleton.py`. +- [x] Do not update Fortran goldens. + +### Phase 2 Risks And Open Questions + +- [x] Decide how much C fixture data is appropriate before parser behavior + exists. +- [x] Decide whether C parser tests should live alongside Fortran parser tests + or under a new top-level C test package. + +## Phase 3: Parser Package Skeleton, Models, And Serialization Contracts + +Branch target: + +- `c-parser/phase-3-models` + +Scope: + +- Create the `c_parser` package. +- Define typed models. +- Define serialization helper contracts. +- Keep actual grammar parsing minimal or placeholder. + +### Package Skeleton Tasks + +- [x] Create `c_parser/__init__.py`. +- [x] Create `c_parser/__main__.py`. +- [x] Create `c_parser/models.py`. +- [x] Create `c_parser/parser.py`. +- [x] Create `c_parser/lexer.py`. +- [x] Create `c_parser/preprocessor.py`. +- [x] Create `c_parser/type_resolver.py`. +- [x] Create `c_parser/project.py`. +- [x] Create `c_parser/cli.py`. +- [x] Create `c_parser/utils.py`. +- [x] Add `c_parser*` to package discovery in `pyproject.toml`. +- [x] Add `c_parser` to coverage source when implementation begins. +- [x] Keep imports from `x2py.cli` explicit and isolated. +- [x] Keep parser orchestration and helper internals on `CParser`, matching the + Fortran parser class structure. +- [ ] Split `CParser` internals into smaller visitor/helper classes only if the + class grows past what remains readable. + +### Error Model Tasks + +- [x] Implement `CParseError` as a `ValueError` subclass. +- [x] Include `filename`. +- [x] Include `line_number`. +- [x] Include `column`. +- [x] Include `source_line`. +- [x] Include `base_message`. +- [x] Include `code`. +- [x] Include parser raise location for debug diagnostics. +- [x] Implement `format_diagnostic(color=False, debug=None)`. +- [x] Use C diagnostic code prefix such as `CPARSE001`. +- [x] Add color handling equivalent to `FortranParseError`. +- [x] Add optional C debug env var. +- [x] Test C parse error attributes. +- [x] Test compiler-style diagnostic rendering. +- [x] Test color and no-color behavior. +- [x] Test debug note behavior. + +### Model Tasks + +- [x] Define `CSourceLocation`. +- [x] Define `CDiagnostic`. +- [x] Define concrete `CType` subclasses, including all supported primitive + scalar and complex types. +- [x] Define `CQualifier` objects (`CConst`, `CVolatile`, `CRestrict`, and + `CAtomic`). +- [x] Define `CPointer`, `CArray`, `CFunctionType`, and `CComposedType`. +- [x] Define `CParameter`. +- [x] Define `CFunction`. +- [x] Use `CVariable` for struct and union members rather than a separate + field object. +- [x] Define `CStruct`. +- [x] Define `CUnion` or use `CStruct(is_union=True)`. +- [x] Define `CEnum`. +- [x] Define `CEnumerator`. +- [x] Define `CTypedef`. +- [x] Define `CVariable`. +- [x] Define `CMacro`. +- [x] Define `CInclude`. +- [x] Define `CFile`. +- [x] Define `CProject`. +- [x] Add helper properties for pointer depth. +- [x] Add helper properties for array rank. +- [x] Preserve effective declaration type source text. +- [x] Store qualifiers on the exact `CType` component they qualify. +- [x] Record incomplete aggregate tags with `is_incomplete=True`. +- [x] Add helper properties for source-location display. + +### Serialization Tasks + +- [x] Add `_to_dict` or equivalent serialization helper. +- [x] Avoid cycles in JSON. +- [x] Keep source locations JSON-serializable. +- [x] Decide whether sets serialize as sorted lists. +- [x] Ensure dataclass defaults produce stable JSON. +- [x] Add tests for empty `CFile` serialization. +- [ ] Add tests for each model's minimal JSON shape. +- [x] Add tests for source-location serialization. +- [x] Add tests that unknown/unresolved metadata is preserved. + +### Public API Skeleton And Partial Parser Tasks + +- [x] Implement `CParser` class. +- [x] Implement `CParser.visit_file` returning partial parser `CFile` models. +- [x] Implement `CParser.visit_project` returning partial parser `CProject` + models. +- [x] Implement module-level `_DEFAULT_PARSER`. +- [x] Implement `parse_c_file`. +- [x] Implement `parse_c_project`. +- [x] Add public API tests for source strings. +- [x] Add public API tests for file paths. +- [x] Add public API tests for empty source. +- [x] Add public API tests for unknown suffix. +- [x] Change parser status from `skeleton` to `partial` once real declaration + and function facts are populated. +- [x] Add tests that public API output contains parsed functions and project + indexes for the supported subset. + +### Phase 3 Definition Of Done + +- [x] `c_parser` imports cleanly. +- [x] Partial public APIs return typed models. +- [x] JSON serialization is stable and tested. +- [x] C CLI uses `c_parser` rather than a temporary inline provider. +- [x] Fortran parser API remains unchanged. +- [x] Docs describe the new package and API status. + +### Phase 3 Risks And Open Questions + +- [x] Decide whether `CUnion` should subclass/share `CStruct`. +- [x] Decide how to represent anonymous structs/unions/enums. +- [ ] Decide whether macros belong in `CFile.macros` only or also symbols. +- [x] Decide on concrete `CType` objects and name-outward + `CComposedType.components` instead of a kind-driven type reference. + +## Phase 4: Lexer And Lightweight Preprocessor + +Branch target: + +- `c-parser/phase-4-lexer` + +Scope: + +- Token/source normalization. +- Comments, continuations, directives, includes, simple macro metadata. +- No internal full macro expansion. +- Raw-source directive metadata first; compiler-assisted preprocessing is the + required path when macros affect public declaration text. + +### Lexer Tasks + +- [x] Preserve original line numbers for all logical records. +- [x] Preserve original source lines for diagnostics. +- [x] Remove block comments `/* ... */` without losing line accounting. +- [x] Remove line comments `// ...`. +- [x] Avoid stripping comment markers inside string literals. +- [x] Avoid stripping comment markers inside character literals. +- [x] Handle escaped quotes inside literals. +- [x] Fold backslash-newline continuations. +- [x] Preserve preprocessor directive line locations. +- [x] Produce token records or logical line records with filename, line, column, + and text. +- [x] Track braces, parentheses, and brackets. +- [x] Add top-level split helpers aware of nesting and literals. +- [x] Add tests for comment stripping. +- [x] Add tests for multiline block comments. +- [x] Add tests for string literal comment markers. +- [x] Add tests for char literal escapes. +- [x] Add tests for backslash-newline continuations. +- [x] Add tests for line/column preservation. + +### Preprocessor Metadata Tasks + +- [x] Recognize `#include "local.h"`. +- [x] Recognize `#include `. +- [x] Store include spelling and include kind. +- [x] Resolve local includes relative to current file when possible. +- [x] Preserve unresolved includes as diagnostics, not hard errors by default. +- [x] Recognize object-like `#define NAME value`. +- [x] Recognize function-like `#define NAME(...) body`. +- [x] Store function-like macros as unsupported/deferred metadata. +- [x] Recognize `#undef`. +- [x] Record conditional directive presence (`#ifdef`, `#ifndef`, `#if`, + `#elif`, `#else`, `#endif`) as provenance metadata if needed. +- [x] Do not select active branches in raw mode. +- [x] Do not implement a parser-side `defined(NAME)`, `&&`, `||`, `!`, `0`, + and `1` evaluator for C API extraction unless a later design explicitly + justifies it. +- [x] Mark macro-shaped declarations as unsupported/deferred in raw mode. +- [x] Defer declarations prefixed by object-like macros in raw mode instead of + reporting invalid type specifier sequences. +- [x] Store macro-dependency metadata in C parser models. +- [x] Store preprocessing mode metadata in `CFile`. +- [x] Store raw directive metadata separately from compiler-preprocessor + configuration metadata. +- [x] Do not implement general macro expansion. +- [x] Do not expand token-paste or stringify macros. +- [x] Do not attempt recursive compiler-compatible macro expansion inside + x2py. +- [x] Add tests for include collection. +- [x] Add tests for object-like macro collection. +- [x] Add tests for function-like macro diagnostics. +- [x] Add tests for object-like macro declaration-prefix deferral. +- [x] Do not misclassify `#if MACRO(...)` or body `else if (...)` forms as + K&R-style definitions. +- [x] Add tests that raw conditional directives do not select active branches. +- [x] Add tests that macro-generated declarations are deferred in raw mode. + +### Compiler-Assisted Preprocessing Tasks + +- [ ] Design a preprocessed-input mode for `.i` files. +- [ ] Design an optional compiler invocation mode for `cc -E` or `clang -E`. +- [x] Document that compiler-assisted preprocessing is required when macros + affect names, types, declarators, attributes, storage classes, calling + conventions, visibility annotations, or active conditional branches. +- [ ] Preserve `#line` markers from compiler-preprocessed input. +- [ ] Map diagnostics from preprocessed declarations back to original files. +- [ ] Map parsed model `source_location` fields from preprocessed declarations + back to original files. +- [ ] Mark preprocessed declarations with origin metadata. +- [ ] Store the preprocessor command/configuration in `CFile` or `CProject`. +- [ ] Store original and preprocessed source paths when both exist. +- [ ] Store macro defines, undefines, include dirs, and compiler/preprocessor + executable used to produce the preprocessed stream. +- [ ] Add tests for parsing a simple `.i` file. +- [ ] Add tests for `#line` source mapping. +- [ ] Add tests that macro-generated declarations are parseable only when they + appear in preprocessed input. + +### Phase 4 Definition Of Done + +- [x] Lexer/preprocessor preserves source locations. +- [x] Includes and macros are collected as metadata. +- [x] Raw conditional directives are handled as metadata/provenance only, not + parser-side branch selection. +- [x] No arbitrary macro expansion is attempted. +- [x] Compiler-assisted preprocessing has a documented design path for + macro-heavy APIs. +- [ ] Tests cover comments, continuations, directive metadata, raw macro + deferral, and preprocessed line mapping. + +### Phase 4 Risks And Open Questions + +- [x] Decide whether to tokenize fully now or keep logical records until + declarator parsing requires tokens. +- [x] Decide whether system headers are recorded only or optionally searched. +- [ ] Decide whether `#pragma` should become diagnostics or metadata. +- [ ] Decide whether compiler invocation belongs in Phase 4 or a later + project-resolution phase. + +## Phase 5: Declarations And Declarators + +Branch target: + +- `c-parser/phase-5-declarations` + +Scope: + +- Shared C declaration parser. +- Declarator model and type construction. +- No broad function/project behavior beyond declarations. + +### Declaration Specifier Tasks + +- [x] Parse storage class `typedef`. +- [x] Parse storage class `extern`. +- [x] Parse storage class `static`. +- [x] Parse storage class `register`. +- [x] Parse storage class `_Thread_local`. +- [x] Parse qualifier `const`. +- [x] Parse qualifier `restrict`. +- [x] Parse qualifier `volatile`. +- [x] Parse qualifier `_Atomic` as basic metadata. +- [x] Parse `void`. +- [x] Parse `char`. +- [x] Parse `signed char`. +- [x] Parse `unsigned char`. +- [x] Parse `short`. +- [x] Parse `short int`. +- [x] Parse `unsigned short`. +- [x] Parse `int`. +- [x] Parse `unsigned`. +- [x] Parse `unsigned int`. +- [x] Parse `long`. +- [x] Parse `long int`. +- [x] Parse `unsigned long`. +- [x] Parse `long long`. +- [x] Parse `unsigned long long`. +- [x] Parse `float`. +- [x] Parse `double`. +- [x] Parse `long double`. +- [x] Parse `_Bool`. +- [x] Parse `_Complex` as deferred or supported with explicit tests. +- [x] Parse `struct name`. +- [x] Parse `union name`. +- [x] Parse `enum name`. +- [x] Parse typedef-name references. +- [x] Preserve original declaration specifier text. +- [x] Diagnose invalid primitive specifier sequences while deferring unresolved + single typedef-name references to project/type resolution. + +### Declarator Tasks + +- [x] Parse identifier declarators. +- [x] Parse pointer declarators. +- [x] Parse pointer qualifiers. +- [x] Parse array declarators. +- [x] Parse multidimensional array declarators. +- [x] Parse static array parameter qualifiers, for example `int a[static 4]`. +- [x] Parse parenthesized declarators. +- [x] Parse function declarators. +- [x] Parse function pointer declarators. +- [x] Parse abstract declarators where needed for unnamed parameters. +- [x] Parse multiple declarators in one declaration. +- [x] Keep declarator entity order stable. +- [x] Preserve original declarator source text. +- [x] Add source locations for each declared entity. +- [x] Reject or diagnose unsupported declarator forms explicitly. + +### Shared Declaration Backend Tasks + +- [x] Implement a helper analogous to `_helper_parse_declaration_line`. +- [x] Feed procedure parameters through the same declaration backend. +- [x] Preserve array/function parameter `declared_type` while exposing the + C-adjusted pointer `type`. +- [x] Feed function return types through the same declaration backend. +- [x] Feed struct/union members through the same declaration backend. +- [x] Feed typedefs through the same declaration backend. +- [x] Feed file-scope variables/constants through the same declaration backend. +- [x] Apply declaration specifiers to declarator-derived type layers. +- [x] Normalize supported C type spelling into concrete `CType` subclasses. +- [x] Preserve typedef references before project resolution. +- [x] Add tests for each declaration role. +- [x] Add tests for declarations with multiple variables. +- [x] Add tests for declarations with initializers. +- [x] Add tests that local executable statements are not parsed as declarations. +- [x] Add exhaustive tests for every supported storage class. +- [x] Add exhaustive tests for every supported type qualifier. +- [x] Add exhaustive tests for every supported primitive spelling. +- [x] Add tests for typedef-name references outside `size_t`-style examples. +- [x] Add tests for `struct name`, `union name`, and `enum name` references in + variables and parameters. +- [x] Add tests for multidimensional arrays. +- [ ] Add diagnostics for declarations ignored by the current partial parser. +- [ ] Add structured source facts for declarations that depend on macros. + +### Top-Level Redeclaration Tasks + +- [x] Merge compatible repeated file-scope tentative variable declarations. +- [x] Prefer initialized file-scope definitions over earlier tentative + declarations. +- [x] Diagnose duplicate initialized file-scope variable definitions. +- [x] Diagnose conflicting file-scope variable redeclarations. +- [x] Complete incomplete struct tags from later same-file definitions. +- [x] Complete incomplete union tags from later same-file definitions. +- [x] Keep local declarations inside function bodies ignored in v1. + +Known declaration implementation gaps, with representative syntax: + +- braced/designated initializer preservation: + `int values[3] = {1, 2, 3};` +- nested anonymous aggregate members: + `struct outer { struct { int x; } inner; };` +- cross-declaration resolution/conflict behavior: + `typedef unsigned long size_t; size_t count(void);` +- preprocessed declarations with line mapping: + `#define API(ret) ret` followed by `API(int) run(void);` + +Represented shapes still needing dedicated active regression tests: + +- multi-level qualifier placement: + `const int * const * volatile chain;` + +### Phase 5 Definition Of Done + +- [x] Shared declaration/declarator parser exists. +- [x] It is used by all declaration roles available so far. +- [x] Primitive, pointer, array, typedef-name, and tag references have tests. +- [x] Unsupported declaration-shaped input raises `CParseError` or structured + diagnostics. + +### Phase 5 Risks And Open Questions + +- [x] Represent the currently supported pointer/array/function declarator + combinations as concrete type components and diagnose unconsumed forms. +- [x] Represent unresolved typedef-name uses as `CTypedef` type objects until + project/type resolution is implemented. + +## Phase 6: Function Parsing + +Branch target: + +- `c-parser/phase-6-functions` + +Scope: + +- Function prototypes and definitions. +- Signature extraction. +- Function body skipping by balanced brace slicing. + +### Function Prototype Tasks + +- [x] Classify top-level declarations ending with `;` as possible prototypes. +- [x] Parse return type through declaration/declarator backend. +- [x] Parse function name. +- [x] Parse ordered parameter list. +- [x] Preserve parameter names. +- [x] Preserve unnamed parameter types when legal. +- [x] Parse `void` parameter list as zero parameters. +- [x] Parse variadic marker `...`. +- [x] Mark `is_variadic`. +- [x] Parse pointer parameters. +- [x] Parse array parameters. +- [x] Parse function pointer parameters. +- [x] Parse `const` parameters. +- [x] Parse `restrict` parameters. +- [x] Parse `volatile` parameters. +- [x] Parse storage class `extern`. +- [x] Parse storage class `static`. +- [x] Add source locations. +- [x] Add tests for simple prototypes. +- [x] Add tests for no-argument prototypes. +- [x] Add tests for `void` arguments. +- [x] Add tests for pointer and array parameters. +- [x] Add tests for const pointer variants. +- [x] Add tests for variadic prototypes. +- [x] Add tests for function pointer parameters. +- [x] Add model field for prototype style so `int f(void)` and `int f()` can + be distinguished. +- [x] Add tests that distinguish explicit `void` parameter lists from + unspecified empty parameter lists. +- [x] Add parser source facts for variadic functions through `is_variadic`. +- [x] Add parser source facts for callback candidates once function pointer + parameters are supported. + +### Function Definition Tasks + +- [x] Classify top-level declarator followed by `{` as function definition. +- [x] Parse signature from the definition header. +- [x] Preserve `is_definition=True`. +- [x] Preserve function-definition start/end locations. +- [x] Add direct `start`/`end` model fields before preserving definition + ranges. +- [x] Skip function body contents for wrapper metadata. +- [x] Balance braces while respecting strings, chars, and comments. +- [x] Ignore local declarations for exported signatures in v1. +- [x] Reject or diagnose K&R style function definitions initially. +- [x] Add tests for simple definitions. +- [x] Add tests for nested braces in function body. +- [x] Add tests for strings containing braces. +- [x] Add tests for K&R unsupported diagnostics. +- [x] Detect K&R definitions before body skipping hides the old-style + declaration list. + +### Function Deduplication Tasks + +- [x] Merge matching prototype and definition in the same file. +- [x] Prefer definition metadata where useful. +- [x] Preserve both source locations if helpful. +- [x] Detect conflicting declarations. +- [x] Detect duplicate definitions. +- [ ] Allow same function under mutually exclusive preprocessor branches. +- [x] Add tests for prototype plus definition. +- [x] Add tests for conflicting prototypes. +- [x] Add tests for duplicate definitions. +- [x] Preserve declaration order before deduplicating prototypes and + definitions. + +### Phase 6 Definition Of Done + +- [x] Basic C function signatures parse from `.h` and `.c`. +- [x] Function bodies are skipped safely. +- [x] Variadic and supported function pointer cases are represented as typed + source facts. +- [x] CLI human and JSON output show functions. +- [ ] Parser diagnostics report no-functions only when appropriate. + +### Phase 6 Risks And Open Questions + +- [ ] Decide whether inline functions in headers are definitions or prototypes + for wrapper purposes. +- [ ] Decide how to handle attributes in function declarations before full + extension support exists. + +## Phase 7: Structs, Unions, Enums, And Typedefs + +Branch target: + +- `c-parser/phase-7-structs-enums` + +Scope: + +- C composite types and typedef aliases. + +### Struct Tasks + +- [x] Parse named `struct name { ... };`. +- [x] Parse forward declaration `struct name;`. +- [x] Parse anonymous `struct { ... }`. +- [x] Parse typedef anonymous struct `typedef struct { ... } name;`. +- [x] Parse typedef named struct `typedef struct tag name;`. +- [x] Parse members with shared declaration backend. +- [x] Parse pointer members. +- [x] Parse array members, including legal flexible final struct members with + invalid-placement and union diagnostics. +- [x] Parse nested anonymous structs as unsupported or metadata. +- [x] Parse bit-fields as member metadata with semantic limitations. +- [x] Preserve member order. +- [x] Preserve precise per-member source locations. +- [x] Mark incomplete structs. +- [x] Add tests for named structs. +- [x] Add tests for forward declarations. +- [x] Add tests for typedef structs. +- [x] Add tests for pointer members. +- [x] Add tests for array members. +- [x] Add tests for named, unnamed, and zero-width bit-field source facts and + locations; defer ABI/wrappability diagnostics to the semantic layer. + +### Union Tasks + +- [x] Parse named unions. +- [x] Parse forward union declarations. +- [x] Parse anonymous unions. +- [x] Parse typedef unions. +- [x] Parse union members with shared declaration backend. +- [x] Retain union member ownership through the containing `CUnion`. +- [ ] Add diagnostics for by-value unions if unsafe. +- [x] Add tests for named unions. +- [x] Add tests for typedef unions. +- [ ] Add tests for union diagnostics. + +### Enum Tasks + +- [x] Parse named enums. +- [x] Parse anonymous enums. +- [x] Parse typedef enums. +- [x] Parse enumerator names. +- [x] Parse explicit enumerator values. +- [x] Preserve symbolic enumerator values. +- [ ] Safely fold simple integer expressions. +- [x] Preserve expression text when folding is unsafe. +- [x] Add tests for plain enums. +- [x] Add tests for explicit values. +- [x] Add tests for expression values. +- [x] Add tests for typedef enums. + +### Typedef Tasks + +- [x] Parse primitive typedefs. +- [x] Parse pointer typedefs. +- [x] Parse array typedefs. +- [x] Parse function pointer typedefs. +- [x] Parse struct/union/enum typedefs. +- [x] Preserve alias chains before resolution. +- [x] Detect duplicate typedefs in same scope. +- [x] Add tests for typedef chains. +- [x] Add tests for primitive typedefs. +- [x] Add tests for opaque handle typedefs. +- [ ] Add tests for function pointer typedef diagnostics. + +### Phase 7 Definition Of Done + +- [x] C composite and typedef models are populated from basic fixtures. +- [x] Shared declaration backend handles members and typedefs. +- [x] Validate legal and invalid flexible-array-member placement and retain + named, unnamed, and zero-width bit-field source facts with tests. +- [x] JSON goldens cover composite type schema. +- [x] Docs list supported and unsupported composite forms. + +### Phase 7 Risks And Open Questions + +- [x] Decide when anonymous structs should become generated internal names. +- [ ] Decide how much enum expression folding is safe without compiler + semantics. +- [ ] Decide how unions map to semantic IR, if at all in v1. + +## Phase 8: Include And Project Resolution + +Branch target: + +- `c-parser/phase-8-project-resolution` + +Scope: + +- Multi-file project parsing. +- Include graph. +- Type and typedef resolution. + +### File Discovery Tasks + +- [x] Discover `.c` files in C mode. +- [x] Discover `.h` files in C mode. +- [ ] Decide whether `.i` is included now or later. +- [x] Keep Fortran directory scanning unchanged. +- [x] Support explicit file lists. +- [x] Support directory recursion only in explicit C mode. +- [x] Preserve deterministic file ordering. +- [x] Add tests for file discovery. + +### Include Resolution Tasks + +- [x] Resolve quoted includes relative to current file. +- [x] Resolve quoted includes through `include_dirs`. +- [x] Record unresolved quoted includes. +- [x] Record system includes without requiring local resolution by default. +- [x] Build `include_graph`. +- [x] Detect include cycles without crashing. +- [x] Preserve include spelling and resolved path separately. +- [x] Add tests for local includes. +- [x] Add tests for include dirs. +- [x] Add tests for missing includes. +- [x] Add tests for include cycles. + +### Project Index Tasks + +- [x] Index functions by name. +- [x] Index functions by file. +- [x] Index typedefs by name. +- [x] Index struct tags by tag namespace. +- [x] Index union tags by tag namespace. +- [x] Index enum tags by tag namespace. +- [x] Index enum constants in ordinary identifier namespace. +- [x] Index macros/constants separately. +- [x] Index variables by name. +- [x] Detect duplicate definitions. +- [x] Distinguish compatible redeclarations from conflicts. +- [x] Add tests for duplicate handling. +- [x] Add tests for project-level function indexes. +- [x] Add tests for project-level typedef indexes. +- [x] Add tests for project-level file-scope variable indexes. +- [x] Add tests for project-level macro indexes. + +### Type Resolution Tasks + +- [x] Resolve typedef chains. +- [x] Detect typedef cycles. +- [x] Resolve struct tag references. +- [x] Resolve union tag references. +- [x] Resolve enum tag references. +- [x] Resolve opaque pointer typedefs. +- [x] Preserve unresolved references for later semantic diagnostics. +- [x] Do not lose original spelling during resolution. +- [x] Add tests for cross-file typedef resolution. +- [x] Add tests for cross-file struct resolution. +- [x] Add tests for opaque handles. +- [x] Add tests for unresolved references. + +### Header/Source Pairing Tasks + +- [x] Pair `foo.c` with `foo.h` by basename. +- [x] Pair source with headers it includes. +- [x] Preserve many-to-many relationships. +- [x] Use pairings for reporting, not for hidden behavior. +- [x] Add tests for header/source pairing. + +### Phase 8 Definition Of Done + +- [x] `parse_c_project` returns a populated `CProject`. +- [x] Include graph is stable and serialized. +- [x] Cross-file typedef/tag resolution works for basic projects. +- [x] Missing project context becomes parser or semantic diagnostics as + appropriate. +- [x] Tests cover directory and file-list parsing. + +### Phase 8 Risks And Open Questions + +- [ ] Decide whether project parsing should parse all included system headers + when found. +- [ ] Decide how to handle generated headers. +- [ ] Decide whether include graph should be path-keyed, module-keyed, or both. + +## Phase 9: Semantic Readiness Integration + +Branch target: + +- `c-parser/phase-9-semantic-readiness` + +Scope: + +- Semantic readiness integration for C parser facts. +- File-level and unit-level blockers, but owned by the semantic layer rather + than the parser. + +### Readiness Schema Tasks + +- [ ] Define stable C readiness dictionary keys for the semantic layer. +- [ ] Include counts for functions, structs, unions, enums, typedefs, macros, + includes, and diagnostics. +- [ ] Include `unsupported_constructs`. +- [ ] Include `unresolved_includes`. +- [ ] Include `unresolved_typedefs`. +- [ ] Include `unresolved_tags`. +- [ ] Include `macro_dependent_declarations`. +- [ ] Include `preprocessing_origin`. +- [ ] Include `unsupported_extensions`. +- [ ] Include `ambiguous_pointer_ownership`. +- [ ] Include `ambiguous_array_extents`. +- [ ] Include `callback_functions`. +- [ ] Include `variadic_functions`. +- [ ] Include `incomplete_public_types`. +- [ ] Include `wrappability_blockers`. +- [ ] Include `unit_blockers`. +- [ ] Include `why_not_wrappable`. +- [ ] Include file-level `wrappable`. + +### Diagnostic Tasks + +- [ ] Report no functions found. +- [ ] Report unresolved includes. +- [ ] Report unresolved typedefs. +- [ ] Report unresolved struct tags. +- [ ] Report unresolved union tags. +- [ ] Report unresolved enum tags. +- [ ] Report incomplete structs used by value. +- [ ] Report incomplete unions used by value. +- [ ] Report variadic functions. +- [ ] Report K&R functions. +- [ ] Report function pointer return types. +- [ ] Report function pointer parameters. +- [ ] Report callback typedef parameters. +- [ ] Report missing callback `.pyi` policy. +- [x] Report macro-dependent declarations. +- [x] Report unsupported attributes. +- [x] Report unsupported compiler extensions. +- [ ] Report unsupported bitfields. +- [ ] Report pointer ownership ambiguity. +- [ ] Report non-const pointer mutability ambiguity. +- [ ] Report arrays with unknown extent relationships. +- [ ] Report opaque pointers as warning or non-blocker if policy allows. + +### Unit Blocker Tasks + +- [ ] Assign function blockers to function units. +- [ ] Assign struct field blockers to struct units. +- [ ] Assign union field blockers to union units. +- [ ] Assign enum value blockers to enum units. +- [ ] Assign typedef blockers to typedef units. +- [ ] Assign include/macro/file-scope-variable blockers to file units when no narrower owner + exists. +- [ ] Use qualified names where available. +- [ ] Avoid per-unit ready flags; keep readiness file-level like Fortran. +- [ ] Add tests for every blocker family. +- [ ] Add semantic readiness formatting tests. + +### Phase 9 Definition Of Done + +- [ ] Readiness output is stable in JSON and human CLI when served by the + semantic layer. +- [ ] Diagnostics identify exactly which units block wrapping. +- [ ] Common unsupported C constructs produce actionable messages. +- [ ] Docs list readiness codes and examples. +- [ ] Tests cover readiness families. + +### Phase 9 Risks And Open Questions + +- [ ] Decide which pointer cases are blockers versus warnings. +- [ ] Decide how semantic readiness should treat opaque handles. +- [ ] Decide the exact readiness code names for callback APIs that are parsed + but missing user-supplied `.pyi` policy. + +## Phase 10: Semantic IR Conversion + +Branch target: + +- `c-parser/phase-10-semantics` + +Scope: + +- Convert C parser models into language-independent semantic IR. + +### Converter Structure Tasks + +- [ ] Create `semantics/c2ir.py`. +- [ ] Implement `CToIRConverter`. +- [ ] Mirror the visitor style of `FortranToIRConverter`. +- [ ] Add compatibility helpers such as `c_file_to_semantic_modules`. +- [ ] Add `c_function_to_semantic_function`. +- [ ] Add `c_struct_to_semantic_class` where appropriate. +- [ ] Add `c_project_to_semantic_modules` if project context is needed. +- [ ] Keep conversion separate from parser internals. + +### Type Mapping Tasks + +- [ ] Map `void` return to `None`. +- [ ] Map `_Bool` to `Bool`. +- [ ] Map `char` to an explicit semantic type policy. +- [ ] Map signed integer widths. +- [ ] Map unsigned integer widths. +- [ ] Map `float` to `Float32`. +- [ ] Map `double` to `Float64`. +- [ ] Map `long double` to a documented type or unsupported diagnostic. +- [ ] Map pointers to constraints/metadata. +- [ ] Map arrays to `Shape` and `ORDER_C`. +- [ ] Map `const` to read-only/ownership metadata. +- [ ] Map `restrict` to aliasing metadata. +- [ ] Map structs to semantic classes or named semantic types. +- [ ] Map unions conservatively. +- [ ] Map enums/constants. +- [ ] Preserve unresolved semantic types as errors, not `Unknown` output. + +### Function Projection Tasks + +- [ ] Convert C functions to `SemanticFunction`. +- [ ] Preserve native function name. +- [ ] Preserve parameter order. +- [ ] Mark pointer mutability. +- [ ] Represent array pointer plus size patterns only when known. +- [ ] Add projection metadata only where native and Python signatures diverge. +- [ ] Treat out parameters conservatively until ownership/intent policy exists. +- [ ] Reject or defer variadic functions. +- [ ] Preserve callback/function-pointer facts from C parser models even if + semantic conversion defers wrapper generation. +- [ ] Defer callback conversion unless `.pyi` policy supplies the required + callback facts. +- [ ] Add semantic tests for scalar functions. +- [ ] Add semantic tests for pointer input. +- [ ] Add semantic tests for const pointer input. +- [ ] Add semantic tests for arrays with explicit size parameter. +- [ ] Add semantic tests for structs/opaque handles. + +### Phase 10 Definition Of Done + +- [ ] C semantic conversion works for the supported parser subset. +- [ ] Unsupported C semantic mappings fail explicitly. +- [ ] `--language c --semantics` can be enabled with tests. +- [ ] Semantic fixture workflow exists for C if stable enough. +- [ ] Docs explain C to semantic IR mapping. + +### Phase 10 Risks And Open Questions + +- [ ] Current semantic IR may need richer pointer/ownership constraints. +- [ ] Unsigned integer semantic type names may need standardization. +- [ ] Struct/union/enum representation may require semantic model extensions. + +## Phase 11: `.pyi` Generation And Parsing Integration + +Branch target: + +- `c-parser/phase-11-pyi` + +Scope: + +- Emit/edit semantic interface stubs for C APIs. +- Extend `.pyi` syntax only through semantic IR needs. + +### Generation Tasks + +- [ ] Enable `--language c --pyi` only after semantic conversion is stable. +- [ ] Generate stubs from C semantic modules. +- [ ] Emit scalar functions. +- [ ] Emit pointer constraints when semantic model supports them. +- [ ] Emit arrays with `ORDER_C`. +- [ ] Emit constants as `Final[...]`. +- [ ] Emit opaque handles as classes or semantic type annotations. +- [ ] Emit structs as classes only when field semantics are intended. +- [ ] Avoid emitting `Unknown`. +- [ ] Emit imports/includes only if represented in semantic IR. +- [ ] Add tests for scalar function stubs. +- [ ] Add tests for constant stubs. +- [ ] Add tests for opaque handle stubs. +- [ ] Add tests for array stubs. + +### Parser Integration Tasks + +- [ ] Confirm existing `.pyi` parser accepts generated C stubs. +- [ ] Extend `.pyi` parser only if semantic IR requires new constructs. +- [ ] Add round-trip tests for C-generated stubs. +- [ ] Add edited-stub tests for C APIs. +- [ ] Add tests that unsupported C stubs fail clearly. +- [ ] Add fixture tests under `tests/pyi/fixtures/c/` if C stubs are stable. + +### Native Projection Tasks + +- [ ] Represent pointer/size hidden relationships where known. +- [ ] Represent returned output buffers only with explicit projection metadata. +- [ ] Represent ownership/lifetime metadata if supported by IR. +- [ ] Define `.pyi` policy fields for callback signatures. +- [ ] Define `.pyi` policy fields for callback direction. +- [ ] Define `.pyi` policy fields for call-only versus stored callback + lifetime. +- [ ] Define `.pyi` policy fields for context/userdata pairing. +- [ ] Define `.pyi` policy fields for callback nullability. +- [ ] Define `.pyi` policy fields for non-default calling conventions. +- [ ] Define `.pyi` policy fields for threading and async invocation. +- [ ] Define `.pyi` policy fields for ownership of callback/context memory. +- [ ] Define `.pyi` policy fields for release/unregistration APIs. +- [ ] Define `.pyi` policy fields for Python exception/error handling. +- [ ] Defer callback projection until those policy fields are supplied by the + user. +- [ ] Defer arbitrary ABI details. + +### Phase 11 Definition Of Done + +- [ ] C `.pyi` output works for supported semantic subset. +- [ ] Generated stubs parse back into semantic IR. +- [ ] C `.pyi` tests are separate from Fortran `.pyi` tests. +- [ ] Docs describe generated C stub shape and limitations. + +### Phase 11 Risks And Open Questions + +- [ ] Existing `.pyi` syntax may not be expressive enough for ownership and + lifetimes. +- [ ] Opaque handles might require new conventions. +- [ ] C callbacks likely need dedicated `.pyi` policy syntax and later semantic + IR extensions. + +## Phase 12: Corpus Testing, Stabilization, And Regression Hardening + +Branch target: + +- `c-parser/phase-12-corpus-stabilization` + +Scope: + +- Harden parser against realistic C APIs. +- Stabilize docs, tests, schema, and CLI. +- Prepare eventual mature integration. + +### Corpus Tasks + +- [ ] Use cJSON as the first pinned real-world C corpus target. +- [ ] Pin cJSON to an exact tag or commit rather than tracking the moving + default branch. +- [ ] Store cJSON provenance in `tests/data/c/corpus/cjson/SOURCE.md`. +- [ ] Store cJSON license text next to the vendored fixture files. +- [ ] Add `tests/data/c/corpus/cjson/cJSON.h`. +- [ ] Add `tests/data/c/corpus/cjson/cJSON.c`. +- [ ] Treat cJSON corpus tests as parse-only at first. +- [ ] Use cJSON to exercise typedef structs, recursive pointers, `const char *` + APIs, `size_t`, public declaration macros, numeric/string constants, + and callback hook members. +- [ ] Keep callback hook members modeled in `c_parser/models.py`, with + semantic readiness requiring explicit user `.pyi` callback policy metadata + before claiming they are wrappable. +- [ ] Add zlib or another macro-heavier C library only after + compiler-assisted preprocessing mode is available. +- [ ] Add small real-world C header corpus. +- [ ] Add scientific C API fixtures. +- [ ] Add source/header project fixtures. +- [ ] Add macro-heavy unsupported fixtures. +- [ ] Add callback fixtures. +- [ ] Add variadic function fixtures. +- [ ] Add opaque handle fixtures. +- [ ] Add array-size pattern fixtures. +- [ ] Add typedef-chain fixtures. +- [ ] Add parse-only corpus tests. +- [ ] Add selected parser JSON goldens for representative corpus files. +- [ ] Keep corpus license provenance documented. + +### Regression Hardening Tasks + +- [x] Run full parser tests. +- [ ] Run semantic tests. +- [ ] Run `.pyi` tests. +- [ ] Run C corpus parse-only tests. +- [x] Run CLI tests. +- [x] Run golden fixture tests. +- [x] Confirm Fortran tests still pass. +- [ ] Audit JSON schema stability. +- [ ] Audit error diagnostic stability. +- [x] Audit docs for implemented behavior. +- [x] Remove stale skeleton wording where implementation has matured. +- [ ] Add developer tutorial for C parser internals. +- [ ] Add public API reference examples. + +### Stabilization Tasks + +- [ ] Decide criteria for merging `c-parser/main` into project `main`. +- [ ] Require green CI for Fortran and C suites. +- [ ] Require docs updated for implemented subset. +- [x] Require fixture/golden workflow documented. +- [ ] Require semantic and `.pyi` behavior documented. +- [ ] Require explicit non-goals still documented. +- [ ] Require migration notes for users. +- [ ] Consider adding CI guard requiring C parser docs updates for C parser + changes, mirroring the Fortran parser reference policy. + +### Phase 12 Definition Of Done + +- [ ] C parser handles a representative stable subset. +- [ ] CLI, JSON, semantic readiness, semantic IR, and `.pyi` workflows are + tested. +- [ ] Fixture/golden workflows are stable. +- [ ] Corpus tests catch regressions. +- [ ] Fortran behavior remains stable. +- [ ] `c-parser/main` is mature enough to consider a planned merge to project + `main`. + +### Phase 12 Risks And Open Questions + +- [ ] Scope creep toward compiler-grade parsing. +- [ ] Macro-heavy APIs require clear raw-source versus compiler-preprocessed + mode behavior. +- [ ] Ownership/lifetime semantics may need broader IR work. +- [ ] C extensions may need fixture-driven prioritization. + +## Cross-Phase Non-Goals For V1 + +- [ ] Do not support full compiler-grade C parsing. +- [ ] Do not support full C preprocessor compatibility. +- [ ] Do not support arbitrary macro expansion. +- [ ] Do not parse macro-generated declarations from raw source as if they were + ordinary C declarations. +- [ ] Do not support token-paste/stringify expansion. +- [ ] Do not support all compiler extensions. +- [ ] Do not support arbitrary GCC extensions. +- [ ] Do not support arbitrary MSVC extensions. +- [ ] Do not parse C++. +- [ ] Do not generate a full ABI model. +- [ ] Do not infer pointer ownership silently. +- [ ] Do not claim callbacks are safely wrappable before the required `.pyi` + callback policy is supplied. +- [ ] Do not modify Fortran parser behavior as part of C parser work unless a + shared change is explicitly planned, tested, and documented. diff --git a/docs/c_parser/c_parser_main_merge_guard.md b/docs/c_parser/c_parser_main_merge_guard.md new file mode 100644 index 000000000..6f7dad4b2 --- /dev/null +++ b/docs/c_parser/c_parser_main_merge_guard.md @@ -0,0 +1,82 @@ +# C Parser Main Merge Guard + +Status: guard policy and tooling. + +The C parser effort must not merge into project `main` until the frontend is +mature, stable, and the implementation checklist is complete or explicitly +waived. Work should target `c-parser/main` and short-lived `c-parser/*` feature +branches. + +## GitHub Limitation + +This repository is private on a GitHub plan where repository rulesets and +classic branch protection are not available through the API. Because of that, +the strongest available repository-level guard is a GitHub Actions check plus +local Git hooks. + +The Actions workflow in `.github/workflows/c-parser-main-guard.yml` rejects PRs +targeting `main` when either: + +- the head branch starts with `c-parser/` +- the PR changes C parser paths + +The only planned override is the label: + +```text +c-parser-ready-for-main +``` + +That label should be used only for the final approved merge after the checklist +is complete. + +Important: GitHub Actions workflows protect `main` only after the workflow file +exists on the protected base branch. Until the project intentionally brings +this guard into `main`, the immediate protection is local hooks plus project +discipline. + +## Local Hook Guard + +Tracked hooks live in: + +```text +.githooks/ +``` + +Enable them in a checkout with: + +```bash +git config core.hooksPath .githooks +``` + +These hooks block: + +- committing C parser paths while checked out on `main` +- merging `c-parser/*` branches into local `main` +- pushing C parser paths or `c-parser/*` work to remote `main` + +They do not block normal work on `c-parser/main`. + +## C Parser Paths + +The guard treats these as C parser paths: + +- `.github/workflows/c-parser-main-guard.yml` +- `.githooks/` +- `docs/c_parser/` +- `c_parser/` +- `tests/c_parser/` +- `tests/parser/c/` +- `tests/data/c/` +- `semantics/c2ir.py` + +## Final Merge Requirements + +Before any final merge to project `main`: + +- the C parser implementation checklist is complete or explicitly waived +- full Fortran tests pass +- C parser tests pass +- CLI behavior is documented and stable +- semantic readiness diagnostics are stable if that layer exists +- semantic IR and `.pyi` behavior are documented if implemented +- the final PR carries `c-parser-ready-for-main` diff --git a/docs/c_parser/c_parser_reference.md b/docs/c_parser/c_parser_reference.md new file mode 100644 index 000000000..3bb75398f --- /dev/null +++ b/docs/c_parser/c_parser_reference.md @@ -0,0 +1,614 @@ +# C Parser Reference + +Status: partial parser reference with raw directive metadata. The `c_parser` +package and explicit C CLI parse path exist, raw includes/simple macros are +recorded, and a first grammar-shaped subset parses simple declarations, +typedefs, variables, function prototypes, and function-definition headers with +start/end locations. Incomplete struct/union declarations and basic +struct/union/enum definitions are represented as concrete objects, and +declarators are parsed through a recursive grammar-style path for pointer, +array, function, and parenthesized combinations. + +This document is the future home for the C parser user and developer reference. +It should evolve into the C equivalent of `fortran_parser.md` as implementation +lands on `c-parser/main`. + +## Purpose + +The C parser frontend will be a wrapper-oriented source extraction system for +x2py. It should extract enough stable semantic information from C sources and +headers to help create or update the semantic interface layer. + +The implementation must be grammar-style: lex and slice source into C grammar +regions, visit declarations and scopes recursively, reuse shared declarator/type +parsing helpers, and store typed model objects. It must not be implemented as a +giant regex parser, a whole-file scanner, or a compiler-wrapper-only frontend. + +It is not intended to be: + +- a compiler-grade C frontend +- a full C preprocessor +- a replacement for semantic `.pyi` interfaces +- a libclang-only wrapper +- a C++ parser +- a complete ABI generator + +## Planned Source Coverage + +Initial source forms: + +- `.c` +- `.h` + +Possible later source form: + +- `.i` preprocessed C input + +Project input should accept explicit files and directories. Directory scanning +must be explicit C mode at first to avoid changing Fortran CLI behavior. + +## Current Status + +Implemented: + +- `c_parser` package +- typed C parser models for partial parse reports and raw metadata +- `CParser`, `parse_c_file`, and `parse_c_project` +- `CParseError` with compiler-style diagnostic formatting +- explicit `x2py --language c --parse` output +- C JSON partial output and `--out` behavior +- rejection of C `--semantics`, `--pyi`, and `--wrap-readiness` +- raw lexer records with comment stripping, line-continuation folding, and + lightweight token source locations +- top-level source splitting that tracks braces, parentheses, brackets, and + string/character literals +- raw `#include` collection for quoted and system includes +- simple object-like `#define` macro collection +- function-like macro metadata with unsupported diagnostics +- object-like declaration-prefix macro dependencies deferred in raw mode +- raw `#undef` directive provenance in macro metadata +- concrete primitive `CType` objects, pointer/array composition, and concrete + qualifier objects +- order-insensitive primitive specifier matching with `CPARSE003` errors for + invalid combinations such as `unsigned float` +- recursive declarator extraction for parenthesized pointer/array precedence +- nameless `CFunctionType` signatures for function pointer typedefs and + parameter source facts +- parameter array/function adjustment that keeps written `declared_type` facts + and exposes effective pointer `type` facts +- simple file-scope variable and `typedef` extraction +- incomplete `struct name;` and `union name;` extraction as concrete tag types + with `is_incomplete=True` +- named and anonymous struct/union/enum definitions +- aggregate member extraction as `CVariable` objects through the declarator + backend, including pointer, array, callback-pointer, flexible-array, and + bit-field source facts with per-member locations +- inline tag typedef aliases and trailing tag object declarators as separate + concrete models +- simple function prototype extraction +- prototype-style metadata distinguishing `int f(void)` from `int f()` +- simple function-definition signature extraction with body skipping +- start/end locations for function definitions, from the signature start + through the closing brace +- unsupported K&R function-definition diagnostics +- C parser project JSON goldens and fatal diagnostic goldens generated from + stable `CProject.to_dict()` and `CParseError` output +- C fixture inputs under `tests/data/c/general/`, diagnostic inputs under + `tests/data/c/errors/parser/`, and partial-parser regression inputs under + `tests/data/c/json/`, `tests/data/c/tinyexpr/`, `tests/data/c/linmath/`, + `tests/data/c/nanosvg/`, and top-level C inputs from `tests/data/c/stb/` + +Still deferred: + +- callback policy metadata beyond parser-side callback candidates +- nested aggregate member definitions and broad compiler-extension declarators +- braced/designated initializer preservation +- cross-declaration and cross-file typedef/tag resolution +- project include graph and cross-file type resolution +- preprocessed-input parsing with `#line`/linemarker source mapping +- macro-expanded declaration parsing from preprocessed input +- semantic readiness, semantic IR conversion, and `.pyi` generation + +## Planned Supported C Subset + +The initial supported subset should focus on stable wrapper-relevant APIs: + +- function prototypes +- function definitions with extractable signatures +- primitive C scalar types +- pointers +- arrays in parameters and aggregate members +- `const`, `restrict`, and `volatile` qualifiers +- `static` and `extern` storage classes where wrapper-relevant +- `struct` definitions +- `union` definitions +- `enum` definitions and enumerators +- `typedef` declarations +- simple global constants +- simple object-like numeric and string macros +- include dependency tracking +- cross-file typedef and tag resolution within parsed project files + +## Initial Unsupported Subset + +The initial C parser should explicitly report or defer: + +- full compiler-grade C parsing +- full preprocessor compatibility +- arbitrary macro expansion +- token pasting and stringification +- macro-generated declarations +- complex conditional compilation evaluation +- all compiler extensions +- arbitrary GCC extensions +- arbitrary MSVC extensions +- C++ parsing +- K&R style function definitions +- full ABI generation +- guaranteed struct layout computation +- full bitfield ABI interpretation +- inline assembly +- `_Generic` semantic evaluation +- complex `_Atomic` behavior +- arbitrary attributes before fixture-driven support exists + +## Planned Preprocessing Policy + +The C parser should be preprocessor-aware, but it should not become a partial +C preprocessor. Partial macro support is risky in C because macros can define +function names, type names, attributes, calling conventions, parameter lists, +and whole declarations. The parser must not infer a public API from unexpanded +macro-shaped declarations. + +Raw-source mode means source normalization plus directive metadata: + +- strip comments and fold backslash-newline continuations while preserving + source locations +- record `#include` directives as structured include dependencies +- record simple object-like `#define` directives as macro metadata +- record `#undef` directives as macro provenance +- record conditional and pragma directives as raw provenance metadata +- record function-like macros as metadata with unsupported/deferred diagnostics +- record function-like wrappers and object-like declaration prefixes as + macro-dependency metadata without claiming they were parsed +- parse only declarations that are already visible as ordinary C without macro + expansion +- do not select active conditional branches from `#if`/`#ifdef` in raw mode +- do not expand macros, token pasting, stringification, or macro-generated + declarations + +Compiler-assisted preprocessing is the required path when macros affect the +declaration text that the C parser needs to understand. Use preprocessed input +when macros define or alter function names, return types, parameter types, +declarators, attributes, storage classes, calling conventions, visibility +annotations, or conditional API selection. x2py may later accept `.i` files or +invoke a configured compiler preprocessor such as `cc -E` or `clang -E`. + +Preprocessed mode must preserve line mapping. That means the parser reads +compiler-preprocessed text, including `#line`/linemarker directives, and maps +every parsed declaration, source location, and diagnostic back to the original +`.h` or `.c` file and line number where possible. Without this mapping, errors +and JSON source locations would point at a generated `.i` file or temporary +preprocessor stream instead of the user's source. + +This means macro-heavy APIs are still in scope. The boundary is that x2py v1 +should not implement recursive, compiler-compatible macro expansion +internally; it should consume compiler-preprocessed output with preserved +origin metadata. + +## Public API + +Implemented module-level entrypoints: + +```python +from c_parser import parse_c_file, parse_c_project +``` + +Implemented signatures: + +```python +parse_c_file( + source_or_path, + filename=None, + macro_defines=None, + include_dirs=None, + preprocessing="raw", + encoding="utf-8", +) + +parse_c_project( + files, + include_dirs=None, + macro_defines=None, + preprocessing="raw", + encoding="utf-8", +) + +``` + +These return typed parser models analogous to the Fortran parser API. The +current partial phase can populate `functions`, `structs`, `unions`, `enums`, +`typedefs`, `variables`, `includes`, `macros`, and metadata `diagnostics`. +Incomplete `struct name;` and `union name;` declarations are concrete +`CStruct`/`CUnion` types with `is_incomplete=True` and source locations. The +parser returns concrete objects instead of a declaration-kind tag: +`CFunction`, `CVariable`, `CTypedef`, `CStruct`, `CUnion`, and `CEnum`. +A declaration such as +`typedef struct node { int value; } node_t;` produces a `CStruct` plus a +`CTypedef`, while `struct point { int x; } origin;` produces a `CStruct` plus +a `CVariable`. + +All types inherit from `CType`. Implemented primitive type classes are +`CVoid`, `CBool`, `CChar`, `CSignedChar`, `CUnsignedChar`, `CShort`, +`CUnsignedShort`, `CInt`, `CUnsignedInt`, `CLong`, `CUnsignedLong`, +`CLongLong`, `CUnsignedLongLong`, `CFloat`, `CDouble`, `CLongDouble`, +`CFloatComplex`, `CDoubleComplex`, and `CLongDoubleComplex`. Qualifiers are +`CConst`, `CVolatile`, `CRestrict`, and `CAtomic`, attached to the precise +type component they qualify. `_Atomic int value;` is stored with a `CAtomic` +qualifier; the distinct `_Atomic(int) value;` type-specifier form remains +diagnosed as unsupported. Equivalent primitive orderings, such as +`int unsigned` and `double long`, map to the same concrete type while +invalid combinations, such as `unsigned float`, raise `CParseError` with +code `CPARSE003`. A single unresolved typedef-name use remains a `CTypedef` +until resolution can establish whether a matching declaration exists. + +Nested declarators are `CComposedType` objects whose `components` are read +from the declared name outward: + +```python +int *values[4]; # CComposedType([CArray(bound="4"), CPointer(), CInt()]) +int (*matrix)[4]; # CComposedType([CPointer(), CArray(bound="4"), CInt()]) +int *(*table)[4]; # CComposedType([CPointer(), CArray(bound="4"), CPointer(), CInt()]) +``` + +`CFunction` has `result_type` and named `CParameter` objects. Its `.type` +property provides the corresponding nameless `CFunctionType`, which is also +used inside pointer typedefs and variables: + +```python +int add(int a, int b); # CFunction(name="add", result_type=CInt(), parameters=[...]) +int (*compare)(int, int); # CVariable(type=CComposedType([CPointer(), CFunctionType(...)])) +``` + +Function parameters preserve both the written type and C's adjusted callable +type: + +```python +void process(int values[4], int callback(int)); +# values.declared_type: CComposedType([CArray(bound="4"), CInt()]) +# values.type: CComposedType([CPointer(), CInt()]) +# callback.declared_type: CFunctionType(...) +# callback.type: CComposedType([CPointer(), CFunctionType(...)]) +``` + +Callback-bearing parameters are marked as parser-side callback candidates, +without claiming semantic wrappability. Struct and union `members` are +`CVariable` objects; optional `bit_width` and `initializer` fields preserve +source facts without inventing separate field or valued-variable classes. +Member records carry their own field location. A legal final incomplete array +member in a struct is marked as `CArray(is_flexible=True)`; non-final, +sole-member, and union incomplete-array member forms are retained with +`C_INVALID_FLEXIBLE_ARRAY_MEMBER` error diagnostics. +Selected unsupported forms, such as static assertions, +attributes, alignment specifiers, `_Atomic(type)`, and nested aggregate member +definitions, are reported in `diagnostics` with explicit `unit_kind` values. +Unconsumed declarator suffixes are also diagnosed instead of producing partial +objects. Functions +include `prototype_style`, currently `"prototype"` for +typed or explicit `void` parameter lists and `"unspecified"` for empty +parameter lists such as `int f()`. Function definitions do not store +executable body text; they include direct `start` and `end` locations. +Compatible top-level function redeclarations are merged, and a matching +prototype plus definition prefers the definition while retaining the prototype +location in `declaration_locations`. File-scope tentative variable +declarations such as `int i; int i;` are merged; a later initialized +definition such as `int i = 1;` is preferred over an earlier tentative +declaration. Duplicate initialized variables, duplicate function definitions, +duplicate complete tag definitions, and incompatible top-level redeclarations +produce diagnostics. Local declarations inside function bodies are ignored +because body contents are intentionally skipped. +Re-export from `x2py` is still deferred; users should import from `c_parser`. + +Project-level facts require `parse_c_project(...)`, not just +`parse_c_file(...)`. A single file can report its own raw directives, includes, +macros, declarations, diagnostics, and unresolved typedef/tag references. A +project parse sees multiple files together and can populate include graphs, +system include records, unresolved include sets, functions by file, enum +constants, likely header/source pairs, and basic cross-file typedef/tag links. + +`macro_defines` is reserved for future compiler-assisted preprocessing +configuration. It must not mean that raw mode evaluates C preprocessor +conditionals or expands macros internally. + +The parser itself should stay parse-only. If the C frontend later gains +wrappability assessment, that should live in the semantic layer after C parser +models are converted to semantic IR or edited `.pyi` policy is loaded, matching +the current Fortran and `.pyi` readiness boundary. + +## CLI Usage + +Initial explicit mode: + +```bash +x2py path/to/api.h --language c --parse +x2py path/to/api.h --language c --parse --json +x2py path/to/api.h --language c --parse --out report.json +``` + +Optional alias, not implemented: + +```bash +x2py path/to/api.h --parse-c +``` + +Auto-detection should come later, after the frontend is stable. + +## Current JSON Output + +Per-file shape: + +```text +{ + "": { + "filename": "", + "language": "c", + "parser_status": "partial", + "preprocessing": "raw", + "functions": [ + { + "name": "run", + "result_type": {"model": "CInt", "qualifiers": [], "source_text": "int"}, + "parameters": [], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": false, + "prototype_style": "prototype", + "source_location": {"filename": "", "line": 1, "...": "..."}, + "start": {"filename": "", "line": 1, "...": "..."}, + "end": null + } + ], + "structs": [], + "unions": [], + "enums": [], + "typedefs": [], + "variables": [], + "macros": [], + "includes": [], + "diagnostics": [] + } +} +``` + +JSON compatibility rules: + +- prefer additive schema changes +- serialize concrete `CType` identity using `"model"`; reserve `"type"` for + actual type relationships such as `CTypedef.type` +- serialize qualifier objects as canonical spellings such as `"const"` +- include `source_location` for declaration/directive records and `location` + for diagnostics +- emit references for reused aggregate or typedef objects rather than + recursive JSON cycles +- preserve unknown or unresolved information rather than dropping it silently +- keep model fields stable enough for golden fixture testing +- document every intentional schema break + +## Planned Readiness Boundary + +The parser should not assess wrappability. + +Any future C readiness rules should be implemented after the parser output is +converted to semantic IR, or after an edited `.pyi` file provides the missing +policy. That keeps the C parser aligned with the current project rule that +readiness is a semantic concern, not a parser concern. + +For C callback-bearing APIs, the parser should still preserve enough source +facts to let later semantic work decide what is safe: + +- callback signature +- callback direction: native-to-Python, Python-to-native, or both +- lifetime: call-only, stored by native, or released by a specific API +- associated context/userdata parameter +- nullability rules +- non-default calling convention +- threading or async behavior +- ownership of callback and context memory +- release/unregistration API +- exception/error policy for Python callback failures + +Those facts should be stored in parser models, but not turned into a parser-side +`wrappable` report. + +## Error Handling + +The parser defines `CParseError` with: + +- `filename` +- `line_number` +- `column` +- `source_line` +- `base_message` +- `code` +- internal parser raise location for debug mode +- `format_diagnostic(color=False, debug=None)` + +The CLI should print compiler-style diagnostics without tracebacks by default. +The parser has the error type and formatter. Raw directive collection can emit +non-fatal metadata diagnostics, such as unresolved local includes or macros +that affect declarations but were recorded rather than expanded. K&R-style function +definitions now raise `CParseError` because the current function parser only +models prototype-style declarations and definitions. Invalid primitive +specifier combinations also raise `CParseError` (`CPARSE003`) because their +invalidity does not depend on later typedef resolution. Known unsupported +declaration extensions are diagnosed rather than partially modeled; additional +syntax diagnostics should be added only with focused tests. + +## Planned Testing Workflow + +Test families should mirror the Fortran parser: + +- focused lexer tests +- declaration-specifier tests +- declarator parser tests +- function prototype tests +- function definition tests +- struct/union/enum tests +- typedef tests +- macro/constant tests +- include/project tests +- semantic readiness tests once C semantic conversion exists +- CLI tests +- semantic conversion tests +- `.pyi` generation/parser tests +- fixture/golden parser tests +- error fixture/golden tests +- corpus parse-only tests + +The C test area now contains active partial-parser/raw-metadata tests plus +narrowly scoped roadmap skips under `tests/parser/c/`. The active tests cover +public entrypoints, empty model serialization, CLI discovery, JSON/output-file +behavior, unsupported C stages, comment stripping, line-continuation folding, +top-level splitting, include collection, simple macro collection, macro-shaped +declaration deferral, raw conditional branch non-selection and provenance, +macro-dependency metadata, project include/index behavior, simple declarations, +variables, typedefs, top-level redeclaration diagnostics, recursive declarator +composition, aggregate definitions, members, enums, simple function +prototypes/definitions, function-definition start/end locations, JSON golden +serialization, fatal diagnostic goldens, and project-level callback typedef +resolution. The `json` regression inputs +intentionally retain recoverable diagnostics from unsupported constructs; they +do not claim complete library parsing. Remaining parser-suite skips cover the +pinned/provenanced corpus target and compiler-preprocessed `.i`/`#line` +behavior; golden inventory checks also skip deliberately while update mode is +rewriting their baselines. Future implementation branches should activate only +the tests for the capability they implement, then merge those branches back +into `c-parser/main`. + +### Declaration Coverage Boundary + +Active declaration tests currently cover: + +- every implemented primitive spelling and selected reordered equivalent + spellings mapped to their concrete `CType` +- all qualifier objects, storage metadata, simple expression initializers, and + multiple declarators +- pointer/array precedence, multidimensional arrays, parameter VLA/static + metadata and pointer adjustment, function-declared callback adjustment, + function pointers, callback arrays, and functions returning function + pointers +- functions, variables, typedefs, struct/union members, enums, incomplete + tags, inline aggregate aliases, anonymous aggregate typedefs, and recursive + struct pointers +- legal and invalid flexible array members, precise field locations, and + named/unnamed/zero-width bit-field source facts +- concrete-type JSON serialization, source locations, and cycle-safe aggregate + references +- diagnostics for selected unsupported attributes, alignment, `_Atomic(type)`, + nested aggregate definitions, K&R definitions, and trailing declarator + extensions +- fatal diagnostics for invalid primitive-specifier combinations while + unresolved single typedef-name uses remain deferred + +This is enough coverage for the currently implemented subset, not for all C +declarations. + +### Missing Implementation With Examples + +| Capability | C example | Current parser boundary | Needed behavior | +| --- | --- | --- | --- | +| Braced/designated initializers | `int values[3] = {1, 2, 3};` and `struct point origin = {.x = 1, .y = 2};` | Simple initializer text such as `int answer = 42;` is preserved; braced forms are not reliably emitted as `CVariable` initializer facts. | Parse or preserve balanced initializer source without treating its braces as an aggregate declaration. | +| Nested aggregate members | `struct outer { struct { int x; } inner; };` | Produces an unsupported-member diagnostic and does not model `inner`. | Build an anonymous `CStruct`/`CUnion` type used by the member variable. | +| Typedef/tag resolution | `typedef unsigned long size_t; size_t count(void);` and `struct state { int id; }; void step(struct state *s);` | Preserves uses as unresolved `CTypedef` or incomplete tag-type objects unless attached inline. | Link uses to declarations across a file/project and diagnose conflicts. | +| Preprocessed declarations | `#define API(ret) ret` followed by `API(int) run(void);` | Raw mode records macro metadata and does not claim the expanded declaration; preprocessed input with line mapping is not implemented. | Accept compiler-expanded input and map each declaration back through `#line` markers. | +| Additional extension families | `int run(void) __attribute__((visibility("default")));` | Known attribute/alignment/`_Atomic(type)` forms are diagnosed; broader compiler extensions are not modeled. | Add fixture-driven support or a focused diagnostic for each required extension family. | + +### Represented But Requiring Stronger Tests + +These forms are not absent from the model, but need explicit active regression +tests before they can be treated as stable: + +```c +const int * const * volatile chain; +``` + +The current parser creates distinct qualified `CPointer` components for +`chain`; dedicated active regression coverage for that multi-level qualifier +shape remains to be added. + +Fixture layout should be separate from Fortran: + +```text +tests/data/c/ + general/ + json/ + tinyexpr/ + linmath/ + nanosvg/ + stb/ + errors/parser/ + corpus/ + scientific/ + +tests/parser/c/ + fixtures/ + general/ + json/ + errors/ + generate_c_parser_goldens.py + errors/generate_c_parser_error_goldens.py +``` + +Parser goldens group same-stem `.c` and `.h` inputs as one project, with the +`.c` translation unit ordered before its header input to mirror compilation; +explicit header dependency groups put included headers before dependent +headers, such as `nanosvg.h` before `nanosvgrast.h`; an input without a +sibling is parsed as a one-file project. Golden filenames use the project +stem, such as `api.json` or `jsmn.json`. Goldens can be regenerated for all +active projects with +`python -m tests.parser.c.generate_c_parser_goldens` or for selected paths +relative to `tests/data/c/` by adding either member filename; any matching +sibling is included automatically. Fatal diagnostic goldens are regenerated +with +`python -m tests.parser.c.errors.generate_c_parser_error_goldens`. +The active fixture tests also honor `C_PARSER_UPDATE_GOLDENS=1`; C does not +use a generic update environment variable. Until include-expanded parsing is +implemented, a paired project records the source-to-header include edge but +parses the `.c` and `.h` members separately. + +STB is treated as a family of independent single-file libraries: each +top-level `.h` or `.c` input generates its own one-file project golden rather +than being merged into one large project. + +The first real-world corpus target should be cJSON, pinned to an exact release +or commit with license and source provenance. cJSON is small enough for early +stabilization while still covering typedef structs, recursive pointers, public +macro declaration wrappers, constants, `const char *` APIs, `size_t`, and +callback hook members. Library files currently under `tests/data/c/json/`, +`tests/data/c/tinyexpr/`, `tests/data/c/linmath/`, and +`tests/data/c/nanosvg/`, plus STB top-level inputs under `tests/data/c/stb/`, +are regression inputs only until corresponding corpus provenance requirements +are met. + +## Planned Documentation Set + +The C parser documentation lives under: + +```text +docs/c_parser/ +``` + +Current documents: + +- `c_parser_reference.md` +- `c_parser_architecture.md` +- `c_parser_cli_workflow.md` +- `c_parser_implementation_checklist.md` +- `c_parser_main_merge_guard.md` + +Documentation update rule: every C parser implementation change must update +all affected files under `docs/c_parser/` in the same change. This includes +changes to parser behavior, public API, models, CLI output, tests, fixture +workflow, semantic conversion, semantic readiness, or `.pyi` output. Do not +wait for a separate documentation request before updating these docs. diff --git a/docs/c_pyi_self_contained_specification.md b/docs/c_pyi_self_contained_specification.md new file mode 100644 index 000000000..b2eb22cf9 --- /dev/null +++ b/docs/c_pyi_self_contained_specification.md @@ -0,0 +1,699 @@ +# Self-Contained C Semantic `.pyi` Implementation Specification + +**Status:** Phase 1 implementation baseline +**Target:** Python wrappers for C libraries on a selected Linux ABI +**Primary requirement:** A semantic `.pyi` file plus a compiled library is +sufficient to generate a wrapper. C header parsing is optional input +generation, not a wrapper-generation dependency. + +## 1. Phase 1 Boundary + +Phase 1 implements the exact callable interface first. Python is intentionally +C-like at this stage: + +- Every visible Python argument corresponds to one native C parameter, in the + same order. +- Every direct Python return annotation corresponds to the direct C return. +- Native `void` is written as `None`. +- Native pointer parameters are supplied by the Python caller as pointer-backed + storage, primarily NumPy zero-dimensional storage or NumPy arrays. +- Output pointer parameters remain input arguments: the caller allocates + mutable storage and observes changes after the call. +- No argument is synthesized, reordered, omitted or converted into a Python + result by the wrapper. + +Therefore, Phase 1 does **not** implement or emit `@native_call`. + +The purpose of this ordering is to prove that x2py can describe, parse, lower +and execute direct C signatures reliably before adding Pythonic adaptations. + +## 2. Non-Negotiable Rules + +1. The semantic `.pyi` must be sufficient to call every supported wrapped + symbol without reading C source at build time. +2. Optional C parsing may generate a starter semantic `.pyi`, but generated + wrappers consume only the semantic `.pyi` and the compiled library. +3. Phase 1 functions use identity parameter mapping only: one Python argument + per C parameter, in native order. +4. Phase 1 returns use identity return mapping only: the Python return is the + direct C return, or `None` for native `void`. +5. A C pointer parameter is never silently represented by a plain immutable + Python scalar. The caller supplies pointer-backed storage. +6. Numeric one-level pointers use NumPy storage notation: + `T[()]` for zero-dimensional storage and `T[dimensions...]` for array + storage. Both lower to one native `T *`. +7. Array dimensions express validation constraints, not additional pointer + depth. `Float64[:, :]` still lowers to one `double *`, never `double **`. +8. With no stride or order modifier, numeric array storage is C-contiguous. +9. `Const(...)` is the canonical spelling for a read-only C pointee/storage + contract. +10. Pointer graphs such as `T **` and deeper are not inferred from NumPy + arrays. They are represented directly as `Ptr[n](T)` and require the + caller to supply a compatible low-level native pointer object. +11. Functions requiring hidden outputs, generated lengths, Python string + conversion, handle conversion, callback thunks, status-to-exception + conversion, packing or copy-back are deferred until after identity calls + work. +12. The current target is a selected Linux ABI. Cross-platform variation and + non-default calling conventions are deferred. + +## 3. Current Artifact + +The current compiler-facing artifact is: + +```text +module.x2py.pyi +``` + +It may use x2py semantic types, but it contains only identity-callable +functions in Phase 1. + +A clean `.pyi` for standard type checkers is not part of Phase 1. + +## 4. Scalar Types Passed By Value + +Bare scalar types represent native by-value parameters and direct native +returns. + +| Semantic type | C interpretation on selected target | +| --- | --- | +| `Int` | ordinary C `int` | +| `Int8`, `Int16`, `Int32`, `Int64` | fixed-width signed integer types | +| `UInt8`, `UInt16`, `UInt32`, `UInt64` | fixed-width unsigned integer types | +| `Float32` | `float` | +| `Float64` | `double` | +| `SizeT` | `size_t` | +| `CLong`, `CULong` | C `long`, `unsigned long` | +| `Bool` | selected C boolean ABI type | + +Example: + +```c +int add(int a, int b); +double multiply(double a, double b); +``` + +```python +def add(a: Int, b: Int) -> Int: ... +def multiply(a: Float64, b: Float64) -> Float64: ... +``` + +No decorator is needed or accepted for these identity calls. + +## 5. Numeric Pointer Storage + +### 5.1 Canonical NumPy Notation + +A numeric NumPy storage annotation means the caller supplies memory whose data +address is passed directly to C. + +| Semantic annotation | Python caller supplies | Native parameter | +| --- | --- | --- | +| `Int[()]` | writable zero-dimensional NumPy array with C `int` dtype | `int *` | +| `Const(Int[()])` | matching NumPy scalar or zero-dimensional storage | `const int *` | +| `Int[:]` | writable one-dimensional C-contiguous NumPy array | `int *` | +| `Const(Int[:])` | read-only one-dimensional C-contiguous NumPy array | `const int *` | +| `Float64[:]` | writable one-dimensional C-contiguous NumPy array | `double *` | +| `Const(Float64[:])` | read-only one-dimensional C-contiguous NumPy array | `const double *` | +| `Float64[0:n]` | writable one-dimensional array whose extent is validated against visible argument `n` | `double *` | +| `Const(Float64[0:n])` | read-only one-dimensional array whose extent is validated against visible argument `n` | `const double *` | +| `Float64[:, :]` | writable rank-two C-contiguous NumPy array | `double *` | +| `Float64[3, 4]` | writable C-contiguous NumPy array with exact shape `(3, 4)` | `double *` | + +`T[()]` and `T[dimensions...]` are the only current spelling for ordinary +NumPy-backed numeric pointer parameters. Do not also write `Ptr(...)`. + +### 5.2 Direct Pointer Objects + +Some native parameters are pointers but are not ordinary one-level numeric +storage. Their exact identity representation uses the canonical pointer +constructor: + +| Semantic annotation | Native parameter | +| --- | --- | +| `Ptr(T)` | `T *` direct low-level pointer object | +| `Ptr(Const(T))` | `const T *` direct low-level pointer object | +| `Ptr[2](T)` | `T **` direct low-level pointer object | +| `Ptr[2](Const(T))` | `const T **` direct low-level pointer object | +| `Ptr[n](T)` | `T` followed by exactly `n` native pointer layers, `n >= 2` | + +`Ptr(x)` is the only canonical depth-one spelling. `Ptr[1](x)` is invalid. + +For ordinary numeric `int *`/`double *` inputs whose scalar or array storage +contract is known, use the NumPy forms instead of `Ptr(Int)` or +`Ptr(Float64)`. `Ptr[n](T)` is necessary for native pointer graphs and for +low-level pointer values that are not represented by a NumPy storage +contract. + +A direct pointer object carries a typed native address. Passing or returning +it does not imply allocation, copying, ownership or automatic destruction. +For example, a raw pointer returned by one native function can be passed to a +second native function under matching `Ptr(...)` annotations. Pointer-object +construction/allocation helpers are runtime API work, not additional +information required in a semantic function signature. + +### 5.3 Pointer To Scalar + +```c +void increment(int *value); +void read_count(const int *value); +``` + +Phase 1 interface: + +```python +def increment(value: Int[()]) -> None: ... +def read_count(value: Const(Int[()])) -> None: ... +``` + +Python use is intentionally storage-oriented: + +```python +value = np.empty((), dtype=np.intc) +value[...] = 7 +increment(value) +updated = value.item() +``` + +The wrapper passes `value`'s data address. It does not construct temporary +scalar storage and does not return the mutation. + +### 5.4 Pointer To Array + +```c +void negate(int n, double *values); +double sum_values(size_t n, const double *values); +``` + +Phase 1 interface: + +```python +def negate(n: Int, values: Float64[0:n]) -> None: ... +def sum_values(n: SizeT, values: Const(Float64[0:n])) -> Float64: ... +``` + +The caller supplies `n` explicitly because it is an actual C parameter. The +wrapper must not derive it from `len(values)` in Phase 1. + +### 5.5 Output Pointer Remains An Argument + +```c +void get_count(int *out); +void get_values(int n, double *out); +``` + +Phase 1 interface: + +```python +def get_count(out: Int[()]) -> None: ... +def get_values(n: Int, out: Float64[0:n]) -> None: ... +``` + +Example Python use: + +```python +out_count = np.empty((), dtype=np.intc) +get_count(out_count) +count = out_count.item() + +out_values = np.empty(n, dtype=np.float64) +get_values(n, out_values) +``` + +Returning `Int` from `get_count()` or allocating and returning +`Float64[0:n]` from `get_values(n)` is a later Pythonic adaptation, not an +identity call. + +## 6. Array Constraints + +### 6.1 Rank And Fixed Dimensions + +Dimensions refine valid NumPy storage while the native argument remains one +data pointer. + +```c +void process_matrix(double *matrix); +void use_row(int (*row)[4]); +void use_matrix(int (*matrix)[4]); +``` + +```python +def process_matrix(matrix: Float64[:, :]) -> None: ... +def use_row(row: Int[4]) -> None: ... +def use_matrix(matrix: Int[:, 4]) -> None: ... +``` + +- `Float64[:, :]` validates rank two and C contiguity, then passes one + `double *`. +- `Int[4]` validates one fixed row of four `int` values, then passes one + address. +- `Int[:, 4]` validates contiguous rows of fixed width four, then passes one + address. + +For function parameters on the selected ABI, `int (*)[4]` is represented as +one pointer plus its fixed row-width contract. It is not represented as +`int **`. + +### 6.2 Pointer Graphs Are Different + +```c +void use_rows(int **rows); +void update_value(int *****value); +``` + +Neither declaration is represented by `Int[:, :]`. NumPy array notation +supplies one contiguous data pointer only. Their exact low-level Phase 1 +interfaces are: + +```python +def use_rows(rows: Ptr[2](Int)) -> None: ... +def update_value(value: Ptr[5](Int)) -> None: ... +``` + +The caller supplies an x2py-compatible native pointer object with the declared +topology. The wrapper passes it unchanged. Constructing pointer rows from +nested Python sequences and exposing `update_value(value: Int) -> Int` are +later Pythonic adaptations. + +### 6.3 Contiguity + +Phase 1 accepts only C-contiguous numeric arrays for `T[:]`, `T[:, :]`, +fixed-dimension forms and dependent dimension forms such as `T[0:n]`. +Dependent dimensions may reference visible scalar arguments only; they +validate storage and do not generate or change native arguments. Strided +inputs, Fortran-order inputs, automatic packing and copy-back are deferred. + +## 7. Direct Native Returns + +### 7.1 Scalars And `void` + +Direct scalar returns and native `void` are identity behavior: + +```c +int status(void); +void reset(void); +``` + +```python +def status() -> Int: ... +def reset() -> None: ... +``` + +An integer return remains an integer return in Phase 1. It is not +automatically converted to an exception. + +### 7.2 Pointer Returns + +A direct returned native pointer can be exposed as a low-level pointer object +without changing the C return topology: + +```c +double *raw_values(void); +struct context *context_current(void); +``` + +```python +class context(Opaque): + pass + +def raw_values() -> Ptr(Float64): ... +def context_current() -> Ptr(context): ... +``` + +If a returned pointer is exposed immediately as NumPy storage, shape and +lifetime information is required. This also remains identity mapping because +the C function directly returns the represented pointer: + +```c +double *create_values(int n); +void free_values(double *values); +``` + +```python +def create_values(n: Int) -> Annotated[ + Float64[0:n], + Owned, + FreeWith("free_values"), +]: ... +``` + +This does not require `@native_call` because the C function directly returns +the pointer represented by the Python return annotation. Until shape and +lifetime handling are implemented, return it as the corresponding direct +low-level pointer object or reject the higher-level NumPy view rather than +guessing. + +## 8. Symbol Names + +Argument and return identity is independent of symbol naming. Phase 1 +supports `@bind` without introducing `@native_call`: + +```c +int library_add(int a, int b); +void c_increment(int *value); +``` + +```python +@bind("library_add") +def add(a: Int, b: Int) -> Int: ... + +@bind("c_increment") +def increment(value: Int[()]) -> None: ... +``` + +`@bind` changes only which exported symbol is loaded. It does not synthesize +arguments, change pointers or alter results. + +## 9. Structures, Enums And Non-Numeric Pointers + +By-value enums and by-value structures can be Phase 1 identity interfaces once +their native representation and layout are complete in the semantic `.pyi`: + +```c +struct point { double x; double y; }; +struct point scale_point(struct point p, double factor); +``` + +```python +class point(Structure): + x: Float64 + y: Float64 + +def scale_point(p: point, factor: Float64) -> point: ... +``` + +Opaque pointers may be represented directly without creating a Pythonic handle +API: + +```c +struct context; +struct context *context_create(void); +void context_destroy(struct context *ctx); +int context_run(struct context *ctx); +``` + +```python +class context(Opaque): + pass + +def context_create() -> Ptr(context): ... +def context_destroy(ctx: Ptr(context)) -> None: ... +def context_run(ctx: Ptr(context)) -> Int: ... +``` + +This is C-like identity behavior: Python receives and passes the native pointer +object. Automatic ownership, destruction, status checking and output-handle +conversion are later policies. + +The following remain outside the first identity subset unless their direct +native representations are implemented explicitly: + +- Python `str` conversion for `char *` or `const char *` (raw byte/character + storage may be represented directly); +- Python callables converted into native function pointers (a pre-existing + low-level native function pointer may later be an identity argument); +- unions; +- variadic functions; +- `void *` beyond an explicitly selected raw/byte-storage representation. + +## 10. Phase 1 Unsupported Transformations + +Phase 1 must reject, or leave unresolved during optional C import generation, +any interface that requires the wrapper to change the native function shape. + +Unsupported now: + +| Desired behavior | Example C shape | Later mechanism | +| --- | --- | --- | +| Pass a Python scalar through a native pointer | `void increment(int *value)` exposed as `value = increment(value)` | `@native_call(Ptr(Arg(0)))` plus readback | +| Generate a hidden length | `double sum(size_t n, const double *x)` exposed as `sum(x)` | `len(Arg(0))` in `@native_call` | +| Turn an output pointer into a Python result | `void get_count(int *out)` exposed as `get_count() -> Int` | `Return(...)` in `@native_call` | +| Convert native status to exception | `int create(...);` with hidden status | `Status[...]` and `Check(...)` | +| Wrap a raw opaque pointer with ownership behavior | `struct ctx *` / `struct ctx **` | handle and lifetime policy | +| Convert Python strings to C strings | `const char *` from `str` | text encoding/termination policy | +| Generate callback thunks | function-pointer argument | callback lifetime/exception policy | +| Pack or copy non-contiguous arrays | pointer to contiguous data | `Pack` / `CopyBack` coercions | + +The later syntax is retained as design direction only. It is not required by +the Phase 1 parser, IR, printer or wrapper generator. + +## 11. Required Phase 1 Readiness Errors + +The wrapper generator or optional importer must report unsupported behavior +instead of silently changing the interface. + +| Code | Condition | +| --- | --- | +| `c_non_identity_call_unsupported` | A declaration or semantic interface requires synthesized, omitted, reordered or transformed parameters/results. | +| `c_pointer_object_mismatch` | A `Ptr(T)` or `Ptr[n](T)` parameter is supplied a value without the declared direct native pointer topology. | +| `c_numpy_pointer_return_policy_required` | A native pointer return is exposed as a shaped NumPy result without implemented lifetime handling or explicit required metadata; a direct raw `Ptr(T)` return remains identity behavior. | +| `c_numpy_dtype_mismatch` | Supplied NumPy storage does not have the exact semantic native element dtype. | +| `c_numpy_rank_mismatch` | Supplied NumPy storage does not satisfy declared zero-dimensional, rank or fixed-shape constraints. | +| `c_numpy_contiguity_required` | Supplied numeric array is not C-contiguous. | +| `c_numpy_writeability_required` | A mutable native pointer receives read-only NumPy storage. | +| `c_opaque_handle_conversion_unsupported` | A raw opaque pointer is requested as an owning/high-level Python handle rather than direct `Ptr(context)` identity. | +| `c_string_conversion_unsupported` | A Python string conversion is requested. | +| `c_callback_unsupported` | A Python callback-to-native-function-pointer mapping is requested. | +| `c_union_unsupported` | A callable interface includes an unsupported union. | +| `c_variadic_function_unsupported` | A variadic native function is requested. | +| `c_calling_convention_unsupported` | A non-default calling convention is required. | + +## 12. Phase 1 Parser And Wrapper Requirements + +The Phase 1 implementation must: + +1. Parse scalar annotations and direct `None`/scalar return annotations. +2. Parse numeric NumPy storage forms: + `T[()]`, `Const(T[()])`, `T[:]`, `Const(T[:])`, `T[:, :]` and fixed + integer dimensions such as `T[3, 4]`, plus dependent dimensions such as + `T[0:n]` referencing a visible scalar parameter. +3. Lower each supported pointer-backed numeric annotation to exactly one + native pointer of its leaf type. +4. Parse and lower direct pointer forms `Ptr(T)` and `Ptr[n](T)` as exactly + one and `n` native pointer layers, and accept only compatible low-level + native pointer objects at runtime. +5. Validate NumPy dtype, rank, fixed dimensions, C contiguity and + writeability before calling native code. +6. Preserve the visible parameter order exactly. +7. Preserve direct native scalar, pointer and native `void` returns. +8. Parse and apply `@bind("symbol")` for identity symbol renaming. +9. Parse complete by-value `Structure`, `Enum[T]` and opaque pointer leaf + declarations if those existing declaration features are already runnable; + otherwise report them as not yet supported without approximating them. +10. Reject `@native_call`, `Arg`, `Return`, `Returns`, `Status`, `Check`, + `Pack`, `CopyBack` and callback conversion constructs as later-phase + syntax if encountered in a Phase 1 runnable input. +11. Never consult C source after a supported semantic `.pyi` has been parsed. + +## 13. Phase 1 Tests + +### 13.1 By-Value Scalar Identity + +```c +int add(int a, int b); +``` + +```python +def add(a: Int, b: Int) -> Int: ... +``` + +The wrapper passes two native `int` values and returns one native `int`. + +### 13.2 Mutable Scalar Pointer Storage + +```c +void increment(int *value); +``` + +```python +def increment(value: Int[()]) -> None: ... +``` + +Tests must verify that a writable zero-dimensional NumPy array is passed by +data address and that native mutation is observed after the call. A plain +Python `int` must be rejected for this signature. + +### 13.3 Read-Only Scalar Pointer Storage + +```c +void read_count(const int *value); +``` + +```python +def read_count(value: Const(Int[()])) -> None: ... +``` + +Tests must verify matching scalar storage/input acceptance and exact native +pointer lowering without writable requirements. + +### 13.4 Array Pointer With Explicit Count + +```c +double sum_values(size_t n, const double *values); +``` + +```python +def sum_values(n: SizeT, values: Const(Float64[0:n])) -> Float64: ... +``` + +Tests must verify that the caller passes `n`, that the wrapper passes it +unchanged, and that no hidden `len(values)` argument is generated. + +### 13.5 Explicit Output Storage + +```c +void get_count(int *out); +void get_values(int n, double *out); +``` + +```python +def get_count(out: Int[()]) -> None: ... +def get_values(n: Int, out: Float64[0:n]) -> None: ... +``` + +Tests must verify mutation of caller-allocated output storage and that the +functions return `None`. + +### 13.6 Matrices And Pointer-To-Fixed-Array + +```c +void matrix_data(double *matrix); +void matrix_rows(int (*matrix)[4]); +``` + +```python +def matrix_data(matrix: Float64[:, :]) -> None: ... +def matrix_rows(matrix: Int[:, 4]) -> None: ... +``` + +Tests must verify one native pointer argument for each function, rank/shape +validation, and rejection of a representation treating either argument as +`T **`. + +### 13.7 Direct Pointer Graph Identity + +```c +void use_rows(int **rows); +void update_value(int *****value); +``` + +```python +def use_rows(rows: Ptr[2](Int)) -> None: ... +def update_value(value: Ptr[5](Int)) -> None: ... +``` + +Tests must verify exact pointer depth in the parsed ABI contract and that +these arguments accept only matching direct low-level pointer objects. They +must not accept `Int[:, :]` or add any `@native_call` transformation. + +### 13.8 Raw Opaque Pointer Identity + +```c +struct context; +struct context *context_create(void); +void context_destroy(struct context *ctx); +``` + +```python +class context(Opaque): + pass + +def context_create() -> Ptr(context): ... +def context_destroy(ctx: Ptr(context)) -> None: ... +``` + +Tests must verify that the returned raw native pointer object is accepted by +`context_destroy` without handle wrapping, ownership inference or +`@native_call`. + +### 13.9 Symbol Binding Without Transformation + +```c +int library_add(int a, int b); +``` + +```python +@bind("library_add") +def add(a: Int, b: Int) -> Int: ... +``` + +Tests must verify that `@bind` changes symbol lookup only and leaves +argument/return lowering unchanged. + +### 13.10 Transformation Is Not Phase 1 + +The Phase 1 parser or readiness checker must reject a runnable interface using +later transformation syntax such as: + +```python +@native_call(Ptr(Arg(0))) +def increment(value: Int) -> Returns["value", Int]: ... +``` + +The supported Phase 1 spelling for the same C function is: + +```python +def increment(value: Int[()]) -> None: ... +``` + +## 14. Phase 2: Pythonic Adaptations After Identity Works + +After Phase 1 can call direct signatures reliably, `@native_call` introduces +Python-facing APIs that differ from their C parameter lists. The settled +design direction is: + +```python +# C: void increment(int *value); +@native_call(Ptr(Arg(0))) +def increment_value(value: Int) -> Returns["value", Int]: ... + +# C: double sum_values(size_t n, const double *values); +@native_call(As[SizeT](len(Arg(0))), Arg(0), returns=Return(0)) +def sum_values(values: Const(Float64[:])) -> Float64: ... + +# C: void get_values(int n, double *out); +@native_call(Arg(0), Return(0)) +def get_values(n: Int) -> Float64[0:n]: ... + +# C: int context_create(struct context **out); +@native_call( + Ptr(Return(0)), + returns=Status[Int, Check(success=0, raises=RuntimeError)], +) +def context_create() -> Annotated[context, Owned, FreeWith("context_destroy")]: ... +``` + +Phase 2 also introduces policies and coercions such as: + +- Python `str` to configured native text conversion; +- callback thunk creation and lifetime/exception handling; +- `Pack` and `CopyBack` for non-contiguous arrays; +- opaque handles and native ownership management; +- status conversion and hidden native outputs; +- derived arguments such as `len(Arg(i))`, `.shape[...]`, `.size` and + `.step`. + +None of these transformations is necessary to complete Phase 1. + +## 15. Decisions Deferred Beyond Phase 1 + +The following decisions do not block the identity-call implementation: + +1. Final implementation order within Phase 2 transformations. +2. Bare-string convenience defaults, writable text buffers and arrays of + strings. +3. Callback policies beyond the basic future design direction. +4. Convenience construction of pointer rows from nested Python sequences and + other high-level builders for `T **` and deeper graphs. Direct + `Ptr[n](T)` pointer objects are already Phase 1 identity values. +5. Converting native pointer returns into NumPy views beyond explicitly shaped, + explicitly owned or borrowed storage. Returning direct `Ptr(T)` objects is + already identity behavior. +6. Strided/Fortran-order storage, packing and copy-back. +7. Clean generated `.pyi` files for IDEs and type checkers. +8. Module/library selection, platform variants and non-default calling + conventions. +9. Unions, writable native globals and variadic functions. + +No deferred behavior may be silently inferred by the Phase 1 wrapper +generator. diff --git a/fortran_parser.md b/fortran_parser.md index 8c97e92c5..f4c2d4b44 100644 --- a/fortran_parser.md +++ b/fortran_parser.md @@ -62,14 +62,16 @@ and practical usage from terminal and Python. - `procedure ... :: ...` bindings with attributes (e.g. `pass(self)`, `nopass`) - `generic ... :: name => target1, target2` -### 1.6 Readiness diagnostics +### 1.6 Parser diagnostics and semantic readiness boundary -- Unsupported-pattern checks -- Unknown argument declaration reporting -- Final boolean readiness (`wrappable`) -- Unit-scoped blocker records (`unit_blockers`) for wrapper-relevant - procedures and derived types, plus file-level blockers when diagnostics are - not owned by a single unit. The ready-to-wrap flag remains file-level only. +- Parser diagnostics report source-level parse errors and unsupported parser + constructs. +- Parser JSON remains parse-only and does not contain `wrap_readiness`, + `wrappable`, `unit_blockers`, or other readiness payloads. +- Wrap-readiness is assessed from semantic IR, either after converting parsed + Fortran source or after loading an edited `.pyi` semantic interface. +- The semantic readiness report owns the final file-level `wrappable` flag and + blocker messages. ## 2) Public API surface @@ -77,7 +79,8 @@ Supported public API: - `parse_fortran_file(source_or_path, filename=None, macro_defines=None, encoding="utf-8") -> FortranFile` - `parse_fortran_project(files, encoding="utf-8") -> FortranProject` -- `assess_wrap_readiness(code, filename=None) -> dict` +- `assess_semantic_wrap_readiness(semantic_ir, source=None) -> dict` +- `assess_pyi_wrap_readiness(path_or_paths, encoding="utf-8") -> dict` ## Parser organization notes @@ -88,9 +91,8 @@ sections so maintainers can navigate the file by concern instead of by history: - Module-level helper blocks (source-form rules, preprocessor logic, diagnostics, compile-time expression resolution, dependency ordering) - `FortranParser` internals grouped by domain: - - internal visitor entrypoints (`visit_file`, `visit_project`, - `visit_wrap_readiness`). The public API remains the module-level wrappers - listed above. + - internal visitor entrypoints (`visit_file`, `visit_project`). The public + API remains the module-level wrappers listed above. - source-unit visitors for files, modules, submodules, programs, procedures, interfaces, derived types, and block data - recursive source-unit slicing (`header`, specification part, execution @@ -340,7 +342,7 @@ python -m x2py tests/data/fortran/general/basic_subroutine.f90 --json Write parser JSON: ```bash -python -m x2py tests/data/fortran/general/basic_subroutine.f90 --json-out report.json +python -m x2py tests/data/fortran/general/basic_subroutine.f90 --parse --json --out report.json ``` Expected JSON layout: @@ -353,7 +355,6 @@ Expected JSON layout: - `submodules` - `programs` - `block_data` - - `wrap_readiness` `use` import shape: @@ -394,14 +395,24 @@ checks. Prefer reading `source`, `target`, or `local_name` in new code. ### 3.4 Wrap-readiness summary +```bash +python -m x2py tests/data/fortran/general/basic_subroutine.f90 --wrap-readiness +``` + +This mode parses the source, converts it to semantic IR, and prints the +per-file semantic readiness status. A non-wrappable file is reported as +`Wrappable: no` followed by a `Why not wrappable` section listing semantic +blockers, for example unresolved semantic types, missing compile-time constant +values, or incomplete callback signatures. + +The readiness stage can be combined with parser output: + ```bash python -m x2py tests/data/fortran/general/basic_subroutine.f90 --parse --wrap-readiness ``` -This mode prints only the per-file readiness status. A non-wrappable file is -reported as `Wrappable: no` followed by a `Why not wrappable` section listing -the blocking diagnostics, for example unresolved imported derived-type -arguments/fields or unresolved symbolic kind arguments/fields. +With `--json`, combined parse/readiness output is split into top-level `parse` +and `wrap_readiness` sections. Parser JSON stays parse-only. Semantic IR JSON uses the same output channels, but the per-file payload is the semantic model projection instead of raw parser output: @@ -486,28 +497,31 @@ Expected behavior: - Resolves dependencies and module imports across files. - Returns aggregate namespace parse output. -### 4.2 Parse single file and run readiness check +### 4.2 Parse single file and run semantic readiness check ```python from pathlib import Path -from x2py import parse_fortran_file, assess_wrap_readiness +from x2py import parse_fortran_file, assess_semantic_wrap_readiness +from semantics.fortran2ir import fortran_file_to_semantic_modules p = Path("tests/data/fortran/general/basic_subroutine.f90") code = p.read_text() parsed = parse_fortran_file(code, filename=str(p)) -readiness = assess_wrap_readiness(code, filename=str(p)) +modules = fortran_file_to_semantic_modules(parsed, standalone_module_name=p.stem) +readiness = assess_semantic_wrap_readiness(modules, source=str(p)) print("procedures", len(parsed.procedures)) print("wrappable", readiness["wrappable"]) -print("unsupported", len(readiness["unsupported_constructs"])) +print("blockers", len(readiness["wrappability_blockers"])) ``` Expected behavior: - `parsed` is a `FortranFile` aggregate model with parsed units and symbols. -- `readiness` includes counts, unsupported hits, unknown args, unresolved - imported derived-type/kind dependencies, unit-scoped blockers, and the +- `modules` is the semantic IR projection used by `.pyi` printing and + readiness. +- `readiness` includes semantic API counts, semantic blockers, and the file-level `wrappable` flag. ### 4.3 Structured argument specifications @@ -966,8 +980,8 @@ Failed to resolve declared argument '' in procedure ''. ## 7) Scope note This parser is intentionally wrapper-focused and not a complete Fortran front -end. Unsupported syntax should be surfaced through diagnostics/readiness output -for incremental parser extension. +end. Unsupported syntax should be surfaced through parser diagnostics or later +semantic readiness output for incremental parser extension. ### External callback dummy declarations @@ -985,7 +999,8 @@ Use the stable top-level API: - `parse_fortran_file(source_or_path, filename=None, macro_defines=None, encoding="utf-8") -> FortranFile` - `parse_fortran_project(files, encoding="utf-8") -> FortranProject` -- `assess_wrap_readiness(code, filename=None) -> dict` +- `assess_semantic_wrap_readiness(semantic_ir, source=None) -> dict` +- `assess_pyi_wrap_readiness(path_or_paths, encoding="utf-8") -> dict` Lower-level unit parsers are internal `FortranParser` methods. diff --git a/pyproject.toml b/pyproject.toml index ba2820128..b8ec4d5ac 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -14,13 +14,13 @@ dependencies = [ [tool.setuptools.packages.find] where = ["."] -include = ["fortran_parser*", "semantics*", "x2py*",] +include = ["c_parser*", "fortran_parser*", "semantics*", "x2py*",] [project.scripts] x2py = "x2py.cli:main" [tool.coverage.run] -source = ["fortran_parser", "semantics", "x2py"] +source = ["c_parser", "fortran_parser", "semantics", "x2py"] branch = true parallel = true diff --git a/tests/data/c/README.md b/tests/data/c/README.md new file mode 100644 index 000000000..d9e058228 --- /dev/null +++ b/tests/data/c/README.md @@ -0,0 +1,33 @@ +C fixture data +============== + +This tree holds C-only parser fixtures. Keep these files separate from the +Fortran fixture data so C parser tests can grow without changing the existing +Fortran workflows. + +Directories: + +- `general/`: small hand-written C headers and sources that mirror the themes + in `tests/data/fortran/general/`, plus C-specific API shapes. +- `json/`: JSON-library source/header inputs used for grouped project + regression goldens; diagnostics are permitted in these real-world inputs. +- `tinyexpr/`: tinyexpr source/header inputs used for grouped project + regression goldens; diagnostics are permitted in these real-world inputs. +- `linmath/`: header-only linmath input used for a one-file project regression + golden; diagnostics are permitted in this macro-heavy real-world input. +- `nanosvg/`: NanoSVG headers used for one dependent-header project golden; + `nanosvgrast.h` is parsed with its `nanosvg.h` dependency. +- `stb/`: top-level stb single-file library C inputs, each treated as its own + one-file project regression golden; nested repository metadata is not a + parser fixture. +- `errors/parser/`: invalid C snippets for parser diagnostic goldens. +- `corpus/`: future pinned third-party C corpus fixtures with license + provenance. +- `scientific/`: future scientific C API fixtures. + +The C parser is still partial. Fixtures may contain constructs that are not +fully parsed yet when they are useful roadmap examples. + +The third-party regression inputs do not replace the planned pinned corpus +layout. Before corpus tests claim library coverage, exact provenance and +license requirements must be recorded under `corpus/`. diff --git a/tests/data/c/errors/parser/README.md b/tests/data/c/errors/parser/README.md new file mode 100644 index 000000000..bf09a658d --- /dev/null +++ b/tests/data/c/errors/parser/README.md @@ -0,0 +1,9 @@ +C parser error fixtures +======================= + +Fatal C parser diagnostic inputs belong here. Expected outputs are generated +by: + +```bash +python -m tests.parser.c.errors.generate_c_parser_error_goldens +``` diff --git a/tests/data/c/errors/parser/invalid_type_specifiers.h b/tests/data/c/errors/parser/invalid_type_specifiers.h new file mode 100644 index 000000000..22edf55b0 --- /dev/null +++ b/tests/data/c/errors/parser/invalid_type_specifiers.h @@ -0,0 +1 @@ +unsigned float value; diff --git a/tests/data/c/general/README.md b/tests/data/c/general/README.md new file mode 100644 index 000000000..55d342545 --- /dev/null +++ b/tests/data/c/general/README.md @@ -0,0 +1,22 @@ +General C fixtures +================== + +These fixtures mirror the themes of `tests/data/fortran/general/` using C API +shapes: + +- `basic_array_update.*`: equivalent to a simple subroutine mutating an array. +- `math_api.*`: scalar functions plus vector input/output arrays. +- `particles.*`: derived-type-like particle records and handle typedefs. +- `mesh.h`: nested record and pointer ownership shapes. +- `constants.h`: module variables, constants, enums, and macros. +- `shape_exprs.h`: compile-time expression bounds and multidimensional arrays. +- `modern_math_physics.*`: a compact public API with structs, globals, and + function definitions. +- `name_reuse.h`: C tag namespace and ordinary identifier reuse examples. +- `c_richer_features.h`: C-specific callbacks, opaque handles, unions, + bitfields, conditionals, and a macro-shaped declaration. The macro-shaped + declaration is deferred in raw mode and is intended to become supported only + through compiler-preprocessed input that exposes an ordinary C declaration. + +These are fixture inputs, not generated goldens. Some constructs are richer +than the current partial parser can model. diff --git a/tests/data/c/general/basic_array_update.c b/tests/data/c/general/basic_array_update.c new file mode 100644 index 000000000..4608df7f5 --- /dev/null +++ b/tests/data/c/general/basic_array_update.c @@ -0,0 +1,15 @@ +#include "basic_array_update.h" + +void add1(int n, double x[static 1]) +{ + for (int i = 0; i < n; ++i) { + x[i] += 1.0; + } +} + +void add1_strided(int n, double *restrict x, int incx) +{ + for (int i = 0; i < n; ++i) { + x[i * incx] += 1.0; + } +} diff --git a/tests/data/c/general/basic_array_update.h b/tests/data/c/general/basic_array_update.h new file mode 100644 index 000000000..d9b7bcf95 --- /dev/null +++ b/tests/data/c/general/basic_array_update.h @@ -0,0 +1,7 @@ +#ifndef X2PY_GENERAL_BASIC_ARRAY_UPDATE_H +#define X2PY_GENERAL_BASIC_ARRAY_UPDATE_H + +void add1(int n, double x[static 1]); +void add1_strided(int n, double *restrict x, int incx); + +#endif diff --git a/tests/data/c/general/c_richer_features.h b/tests/data/c/general/c_richer_features.h new file mode 100644 index 000000000..22d1eb1ec --- /dev/null +++ b/tests/data/c/general/c_richer_features.h @@ -0,0 +1,58 @@ +#ifndef X2PY_GENERAL_C_RICHER_FEATURES_H +#define X2PY_GENERAL_C_RICHER_FEATURES_H + +#include + +#define X2PY_API(ret) ret +#define X2PY_STRINGIFY(value) #value + +#ifdef X2PY_ENABLE_FAST_PATH +int x2py_fast_path(void); +#else +int x2py_slow_path(void); +#endif + +typedef int (*x2py_compare_fn)(const void *left, const void *right); + +enum x2py_status { + X2PY_STATUS_OK = 0, + X2PY_STATUS_RETRY = 1, + X2PY_STATUS_ERROR = -1 +}; + +union x2py_scalar { + int i32; + unsigned long u64; + double f64; +}; + +struct x2py_flags { + unsigned ready : 1; + unsigned mode : 3; + unsigned reserved : 28; +}; + +struct x2py_context; +typedef struct x2py_context *x2py_context_handle; + +/* Raw mode must defer this macro-shaped declaration. It is a future supported + case only after compiler preprocessing expands X2PY_API into ordinary C. */ +X2PY_API(int) x2py_sort( + void *items, + size_t count, + size_t item_size, + x2py_compare_fn compare +); + +int x2py_register_callback( + x2py_context_handle context, + void (*callback)(void *userdata, enum x2py_status status), + void *userdata +); + +const char *x2py_status_message(enum x2py_status status); +void x2py_fill_matrix(size_t rows, size_t cols, double matrix[static rows][cols]); + +#undef X2PY_API + +#endif diff --git a/tests/data/c/general/constants.h b/tests/data/c/general/constants.h new file mode 100644 index 000000000..7dc642ec1 --- /dev/null +++ b/tests/data/c/general/constants.h @@ -0,0 +1,23 @@ +#ifndef X2PY_GENERAL_CONSTANTS_H +#define X2PY_GENERAL_CONSTANTS_H + +#include + +#define X2PY_GENERAL_NMAX 100 +#define X2PY_GENERAL_ORIGIN_RANK 3 + +typedef int c_int_like; +typedef double c_double_like; + +enum coordinate_axis { + COORD_X = 0, + COORD_Y = 1, + COORD_Z = 2 +}; + +extern c_int_like nmax; +extern c_double_like origin[3]; +extern const char *coordinate_axis_name(enum coordinate_axis axis); +size_t coordinate_axis_count(void); + +#endif diff --git a/tests/data/c/general/math_api.c b/tests/data/c/general/math_api.c new file mode 100644 index 000000000..c2616c8fa --- /dev/null +++ b/tests/data/c/general/math_api.c @@ -0,0 +1,37 @@ +#include "math_api.h" + +#include + +double norm2(int n, const double x[static 1]) +{ + double accum = 0.0; + for (int i = 0; i < n; ++i) { + accum += x[i] * x[i]; + } + return sqrt(accum); +} + +void scale(int n, double alpha, double x[static 1]) +{ + for (int i = 0; i < n; ++i) { + x[i] *= alpha; + } +} + +double dot(int n, const double *restrict x, const double *restrict y) +{ + double accum = 0.0; + for (int i = 0; i < n; ++i) { + accum += x[i] * y[i]; + } + return accum; +} + +void fill_identity3(double a[static 3][3]) +{ + for (int row = 0; row < 3; ++row) { + for (int col = 0; col < 3; ++col) { + a[row][col] = row == col ? 1.0 : 0.0; + } + } +} diff --git a/tests/data/c/general/math_api.h b/tests/data/c/general/math_api.h new file mode 100644 index 000000000..5d4ff6686 --- /dev/null +++ b/tests/data/c/general/math_api.h @@ -0,0 +1,9 @@ +#ifndef X2PY_GENERAL_MATH_API_H +#define X2PY_GENERAL_MATH_API_H + +double norm2(int n, const double x[static 1]); +void scale(int n, double alpha, double x[static 1]); +double dot(int n, const double *restrict x, const double *restrict y); +void fill_identity3(double a[static 3][3]); + +#endif diff --git a/tests/data/c/general/mesh.h b/tests/data/c/general/mesh.h new file mode 100644 index 000000000..9279fe96b --- /dev/null +++ b/tests/data/c/general/mesh.h @@ -0,0 +1,24 @@ +#ifndef X2PY_GENERAL_MESH_H +#define X2PY_GENERAL_MESH_H + +#include + +struct node { + int id; + double xyz[3]; +}; + +struct mesh { + size_t nnodes; + struct node *nodes; +}; + +typedef struct node node; +typedef struct mesh mesh; + +void node_move(struct node *node, const double delta[static 3]); +int mesh_init(struct mesh *mesh, size_t nnodes); +void mesh_clear(struct mesh *mesh); +struct node *mesh_node_at(struct mesh *mesh, size_t index); + +#endif diff --git a/tests/data/c/general/modern_math_physics.c b/tests/data/c/general/modern_math_physics.c new file mode 100644 index 000000000..d9cda6c5d --- /dev/null +++ b/tests/data/c/general/modern_math_physics.c @@ -0,0 +1,52 @@ +#include "modern_math_physics.h" + +#include + +int modern_counter = 0; +static double hidden_scale = 1.0; + +void init_particle(modern_particle *p, int pid, double mass, double x, double y, double z) +{ + p->id = pid; + p->mass = mass; + p->position[0] = x; + p->position[1] = y; + p->position[2] = z; + modern_counter += 1; +} + +double kinetic_energy(const modern_particle *p, double vx, double vy, double vz) +{ + return 0.5 * p->mass * (vx * vx + vy * vy + vz * vz) * hidden_scale; +} + +void scale_vector(int n, double v[static 1], double alpha) +{ + for (int i = 0; i < n; ++i) { + v[i] = alpha * v[i]; + } +} + +double dot3(const double a[static 3], const double b[static 3]) +{ + return a[0] * b[0] + a[1] * b[1] + a[2] * b[2]; +} + +void fill_identity3_modern(double a[static 3][3]) +{ + for (int row = 0; row < 3; ++row) { + for (int col = 0; col < 3; ++col) { + a[row][col] = row == col ? 1.0 : 0.0; + } + } +} + +void normalize_particle(modern_particle *p) +{ + double n = sqrt(dot3(p->position, p->position)); + if (n > 0.0) { + p->position[0] /= n; + p->position[1] /= n; + p->position[2] /= n; + } +} diff --git a/tests/data/c/general/modern_math_physics.h b/tests/data/c/general/modern_math_physics.h new file mode 100644 index 000000000..ee5515615 --- /dev/null +++ b/tests/data/c/general/modern_math_physics.h @@ -0,0 +1,26 @@ +#ifndef X2PY_GENERAL_MODERN_MATH_PHYSICS_H +#define X2PY_GENERAL_MODERN_MATH_PHYSICS_H + +extern int modern_counter; + +struct modern_particle { + int id; + double mass; + double position[3]; +}; + +struct vector3 { + double values[3]; +}; + +typedef struct modern_particle modern_particle; +typedef struct vector3 vector3; + +void init_particle(modern_particle *p, int pid, double mass, double x, double y, double z); +double kinetic_energy(const modern_particle *p, double vx, double vy, double vz); +void scale_vector(int n, double v[static 1], double alpha); +double dot3(const double a[static 3], const double b[static 3]); +void fill_identity3_modern(double a[static 3][3]); +void normalize_particle(modern_particle *p); + +#endif diff --git a/tests/data/c/general/name_reuse.h b/tests/data/c/general/name_reuse.h new file mode 100644 index 000000000..93ff48562 --- /dev/null +++ b/tests/data/c/general/name_reuse.h @@ -0,0 +1,23 @@ +#ifndef X2PY_GENERAL_NAME_REUSE_H +#define X2PY_GENERAL_NAME_REUSE_H + +#include + +struct same_name { + int payload; +}; + +extern int same_name_i; +extern float same_name_r; +extern bool same_name_l; +extern double _Complex same_name_c; +extern char same_name_s[8]; + +void do_work_i(int *same_name); +void do_work_r(float same_name); +void do_work_l(bool same_name, struct same_name *shared); +double _Complex convert_to_complex(int same_name); +int convert_to_string(float same_name, char shared[static 16]); +bool convert_to_logical(const char *same_name); + +#endif diff --git a/tests/data/c/general/particles.c b/tests/data/c/general/particles.c new file mode 100644 index 000000000..1566e7c7f --- /dev/null +++ b/tests/data/c/general/particles.c @@ -0,0 +1,34 @@ +#include "particles.h" + +static struct particle current_particle; + +void particle_touch(struct particle *p) +{ + if (p != 0) { + current_particle = *p; + } +} + +void particle_reset(particle *p) +{ + if (p != 0) { + p->id = 0; + p->x[0] = 0.0; + p->x[1] = 0.0; + p->x[2] = 0.0; + } +} + +void particle_move(particle *p, const double delta[static 3]) +{ + if (p != 0) { + p->x[0] += delta[0]; + p->x[1] += delta[1]; + p->x[2] += delta[2]; + } +} + +const struct particle *particle_current(void) +{ + return ¤t_particle; +} diff --git a/tests/data/c/general/particles.h b/tests/data/c/general/particles.h new file mode 100644 index 000000000..cc093d52e --- /dev/null +++ b/tests/data/c/general/particles.h @@ -0,0 +1,17 @@ +#ifndef X2PY_GENERAL_PARTICLES_H +#define X2PY_GENERAL_PARTICLES_H + +struct particle { + int id; + double x[3]; +}; + +typedef struct particle particle; +typedef struct particle *particle_handle; + +void particle_touch(struct particle *p); +void particle_reset(particle *p); +void particle_move(particle *p, const double delta[static 3]); +const struct particle *particle_current(void); + +#endif diff --git a/tests/data/c/general/shape_exprs.h b/tests/data/c/general/shape_exprs.h new file mode 100644 index 000000000..17c21c20e --- /dev/null +++ b/tests/data/c/general/shape_exprs.h @@ -0,0 +1,30 @@ +#ifndef X2PY_GENERAL_SHAPE_EXPRS_H +#define X2PY_GENERAL_SHAPE_EXPRS_H + +#define X2PY_EXPR_N0 4 +#define X2PY_EXPR_N1 (X2PY_EXPR_N0 + 2) +#define X2PY_EXPR_A 8 +#define X2PY_EXPR_B 3 +#define X2PY_EXPR_C 2 + +void fill_grid(int x[static 1][X2PY_EXPR_N1]); +void update_plane(int n, float x[static 1][n]); + +void use_expr( + int x[static X2PY_EXPR_N1], + float y[static X2PY_EXPR_N0 * 2] +); + +void all_exprs( + int x1[static X2PY_EXPR_A + X2PY_EXPR_B], + int x2[static X2PY_EXPR_A - X2PY_EXPR_B], + int x3[static X2PY_EXPR_B * X2PY_EXPR_C], + int x4[static X2PY_EXPR_A / X2PY_EXPR_C], + int x5[static 1 << X2PY_EXPR_B], + int x6[static (X2PY_EXPR_A + X2PY_EXPR_B) * X2PY_EXPR_C - 1], + int x7[static -(-X2PY_EXPR_A + X2PY_EXPR_B)], + int x8[static (X2PY_EXPR_A + X2PY_EXPR_B) * (X2PY_EXPR_C + 1) - 1], + int x9[static (X2PY_EXPR_A - X2PY_EXPR_B) * (X2PY_EXPR_A - X2PY_EXPR_C)] +); + +#endif diff --git a/tests/data/c/json/cJSON.c b/tests/data/c/json/cJSON.c new file mode 100644 index 000000000..88c2d95b3 --- /dev/null +++ b/tests/data/c/json/cJSON.c @@ -0,0 +1,3206 @@ +/* + Copyright (c) 2009-2017 Dave Gamble and cJSON contributors + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in + all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + THE SOFTWARE. +*/ + +/* cJSON */ +/* JSON parser in C. */ + +/* disable warnings about old C89 functions in MSVC */ +#if !defined(_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) +#define _CRT_SECURE_NO_DEPRECATE +#endif + +#ifdef __GNUC__ +#pragma GCC visibility push(default) +#endif +#if defined(_MSC_VER) +#pragma warning (push) +/* disable warning about single line comments in system headers */ +#pragma warning (disable : 4001) +#endif + +#include +#include +#include +#include +#include +#include +#include + +#ifdef ENABLE_LOCALES +#include +#endif + +#if defined(_MSC_VER) +#pragma warning (pop) +#endif +#ifdef __GNUC__ +#pragma GCC visibility pop +#endif + +#include "cJSON.h" + +/* define our own boolean type */ +#ifdef true +#undef true +#endif +#define true ((cJSON_bool)1) + +#ifdef false +#undef false +#endif +#define false ((cJSON_bool)0) + +/* define isnan and isinf for ANSI C, if in C99 or above, isnan and isinf has been defined in math.h */ +#ifndef isinf +#define isinf(d) (isnan((d - d)) && !isnan(d)) +#endif +#ifndef isnan +#define isnan(d) (d != d) +#endif + +#ifndef NAN +#ifdef _WIN32 +#define NAN sqrt(-1.0) +#else +#define NAN 0.0/0.0 +#endif +#endif + +typedef struct { + const unsigned char *json; + size_t position; +} error; +static error global_error = { NULL, 0 }; + +CJSON_PUBLIC(const char *) cJSON_GetErrorPtr(void) +{ + return (const char*) (global_error.json + global_error.position); +} + +CJSON_PUBLIC(char *) cJSON_GetStringValue(const cJSON * const item) +{ + if (!cJSON_IsString(item)) + { + return NULL; + } + + return item->valuestring; +} + +CJSON_PUBLIC(double) cJSON_GetNumberValue(const cJSON * const item) +{ + if (!cJSON_IsNumber(item)) + { + return (double) NAN; + } + + return item->valuedouble; +} + +/* This is a safeguard to prevent copy-pasters from using incompatible C and header files */ +#if (CJSON_VERSION_MAJOR != 1) || (CJSON_VERSION_MINOR != 7) || (CJSON_VERSION_PATCH != 19) + #error cJSON.h and cJSON.c have different versions. Make sure that both have the same. +#endif + +CJSON_PUBLIC(const char*) cJSON_Version(void) +{ + static char version[15]; + sprintf(version, "%i.%i.%i", CJSON_VERSION_MAJOR, CJSON_VERSION_MINOR, CJSON_VERSION_PATCH); + + return version; +} + +/* Case insensitive string comparison, doesn't consider two NULL pointers equal though */ +static int case_insensitive_strcmp(const unsigned char *string1, const unsigned char *string2) +{ + if ((string1 == NULL) || (string2 == NULL)) + { + return 1; + } + + if (string1 == string2) + { + return 0; + } + + for(; tolower(*string1) == tolower(*string2); (void)string1++, string2++) + { + if (*string1 == '\0') + { + return 0; + } + } + + return tolower(*string1) - tolower(*string2); +} + +typedef struct internal_hooks +{ + void *(CJSON_CDECL *allocate)(size_t size); + void (CJSON_CDECL *deallocate)(void *pointer); + void *(CJSON_CDECL *reallocate)(void *pointer, size_t size); +} internal_hooks; + +#if defined(_MSC_VER) +/* work around MSVC error C2322: '...' address of dllimport '...' is not static */ +static void * CJSON_CDECL internal_malloc(size_t size) +{ + return malloc(size); +} +static void CJSON_CDECL internal_free(void *pointer) +{ + free(pointer); +} +static void * CJSON_CDECL internal_realloc(void *pointer, size_t size) +{ + return realloc(pointer, size); +} +#else +#define internal_malloc malloc +#define internal_free free +#define internal_realloc realloc +#endif + +/* strlen of character literals resolved at compile time */ +#define static_strlen(string_literal) (sizeof(string_literal) - sizeof("")) + +static internal_hooks global_hooks = { internal_malloc, internal_free, internal_realloc }; + +static unsigned char* cJSON_strdup(const unsigned char* string, const internal_hooks * const hooks) +{ + size_t length = 0; + unsigned char *copy = NULL; + + if (string == NULL) + { + return NULL; + } + + length = strlen((const char*)string) + sizeof(""); + copy = (unsigned char*)hooks->allocate(length); + if (copy == NULL) + { + return NULL; + } + memcpy(copy, string, length); + + return copy; +} + +CJSON_PUBLIC(void) cJSON_InitHooks(cJSON_Hooks* hooks) +{ + if (hooks == NULL) + { + /* Reset hooks */ + global_hooks.allocate = malloc; + global_hooks.deallocate = free; + global_hooks.reallocate = realloc; + return; + } + + global_hooks.allocate = malloc; + if (hooks->malloc_fn != NULL) + { + global_hooks.allocate = hooks->malloc_fn; + } + + global_hooks.deallocate = free; + if (hooks->free_fn != NULL) + { + global_hooks.deallocate = hooks->free_fn; + } + + /* use realloc only if both free and malloc are used */ + global_hooks.reallocate = NULL; + if ((global_hooks.allocate == malloc) && (global_hooks.deallocate == free)) + { + global_hooks.reallocate = realloc; + } +} + +/* Internal constructor. */ +static cJSON *cJSON_New_Item(const internal_hooks * const hooks) +{ + cJSON* node = (cJSON*)hooks->allocate(sizeof(cJSON)); + if (node) + { + memset(node, '\0', sizeof(cJSON)); + } + + return node; +} + +/* Delete a cJSON structure. */ +CJSON_PUBLIC(void) cJSON_Delete(cJSON *item) +{ + cJSON *next = NULL; + while (item != NULL) + { + next = item->next; + if (!(item->type & cJSON_IsReference) && (item->child != NULL)) + { + cJSON_Delete(item->child); + } + if (!(item->type & cJSON_IsReference) && (item->valuestring != NULL)) + { + global_hooks.deallocate(item->valuestring); + item->valuestring = NULL; + } + if (!(item->type & cJSON_StringIsConst) && (item->string != NULL)) + { + global_hooks.deallocate(item->string); + item->string = NULL; + } + global_hooks.deallocate(item); + item = next; + } +} + +/* get the decimal point character of the current locale */ +static unsigned char get_decimal_point(void) +{ +#ifdef ENABLE_LOCALES + struct lconv *lconv = localeconv(); + return (unsigned char) lconv->decimal_point[0]; +#else + return '.'; +#endif +} + +typedef struct +{ + const unsigned char *content; + size_t length; + size_t offset; + size_t depth; /* How deeply nested (in arrays/objects) is the input at the current offset. */ + internal_hooks hooks; +} parse_buffer; + +/* check if the given size is left to read in a given parse buffer (starting with 1) */ +#define can_read(buffer, size) ((buffer != NULL) && (((buffer)->offset + size) <= (buffer)->length)) +/* check if the buffer can be accessed at the given index (starting with 0) */ +#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) +#define cannot_access_at_index(buffer, index) (!can_access_at_index(buffer, index)) +/* get a pointer to the buffer at the position */ +#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) + +/* Parse the input text to generate a number, and populate the result into item. */ +static cJSON_bool parse_number(cJSON * const item, parse_buffer * const input_buffer) +{ + double number = 0; + unsigned char *after_end = NULL; + unsigned char *number_c_string; + unsigned char decimal_point = get_decimal_point(); + size_t i = 0; + size_t number_string_length = 0; + cJSON_bool has_decimal_point = false; + + if ((input_buffer == NULL) || (input_buffer->content == NULL)) + { + return false; + } + + /* copy the number into a temporary buffer and replace '.' with the decimal point + * of the current locale (for strtod) + * This also takes care of '\0' not necessarily being available for marking the end of the input */ + for (i = 0; can_access_at_index(input_buffer, i); i++) + { + switch (buffer_at_offset(input_buffer)[i]) + { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + case '+': + case '-': + case 'e': + case 'E': + number_string_length++; + break; + + case '.': + number_string_length++; + has_decimal_point = true; + break; + + default: + goto loop_end; + } + } +loop_end: + /* malloc for temporary buffer, add 1 for '\0' */ + number_c_string = (unsigned char *) input_buffer->hooks.allocate(number_string_length + 1); + if (number_c_string == NULL) + { + return false; /* allocation failure */ + } + + memcpy(number_c_string, buffer_at_offset(input_buffer), number_string_length); + number_c_string[number_string_length] = '\0'; + + if (has_decimal_point) + { + for (i = 0; i < number_string_length; i++) + { + if (number_c_string[i] == '.') + { + /* replace '.' with the decimal point of the current locale (for strtod) */ + number_c_string[i] = decimal_point; + } + } + } + + number = strtod((const char*)number_c_string, (char**)&after_end); + if (number_c_string == after_end) + { + /* free the temporary buffer */ + input_buffer->hooks.deallocate(number_c_string); + return false; /* parse_error */ + } + + item->valuedouble = number; + + /* use saturation in case of overflow */ + if (number >= INT_MAX) + { + item->valueint = INT_MAX; + } + else if (number <= (double)INT_MIN) + { + item->valueint = INT_MIN; + } + else + { + item->valueint = (int)number; + } + + item->type = cJSON_Number; + + input_buffer->offset += (size_t)(after_end - number_c_string); + /* free the temporary buffer */ + input_buffer->hooks.deallocate(number_c_string); + return true; +} + +/* don't ask me, but the original cJSON_SetNumberValue returns an integer or double */ +CJSON_PUBLIC(double) cJSON_SetNumberHelper(cJSON *object, double number) +{ + if (object == NULL) + { + return (double)NAN; + } + + if (number >= INT_MAX) + { + object->valueint = INT_MAX; + } + else if (number <= (double)INT_MIN) + { + object->valueint = INT_MIN; + } + else + { + object->valueint = (int)number; + } + + return object->valuedouble = number; +} + +/* Note: when passing a NULL valuestring, cJSON_SetValuestring treats this as an error and return NULL */ +CJSON_PUBLIC(char*) cJSON_SetValuestring(cJSON *object, const char *valuestring) +{ + char *copy = NULL; + size_t v1_len; + size_t v2_len; + /* if object's type is not cJSON_String or is cJSON_IsReference, it should not set valuestring */ + if ((object == NULL) || !(object->type & cJSON_String) || (object->type & cJSON_IsReference)) + { + return NULL; + } + /* return NULL if the object is corrupted or valuestring is NULL */ + if (object->valuestring == NULL || valuestring == NULL) + { + return NULL; + } + + v1_len = strlen(valuestring); + v2_len = strlen(object->valuestring); + + if (v1_len <= v2_len) + { + /* strcpy does not handle overlapping string: [X1, X2] [Y1, Y2] => X2 < Y1 or Y2 < X1 */ + if (!( valuestring + v1_len < object->valuestring || object->valuestring + v2_len < valuestring )) + { + return NULL; + } + strcpy(object->valuestring, valuestring); + return object->valuestring; + } + copy = (char*) cJSON_strdup((const unsigned char*)valuestring, &global_hooks); + if (copy == NULL) + { + return NULL; + } + if (object->valuestring != NULL) + { + cJSON_free(object->valuestring); + } + object->valuestring = copy; + + return copy; +} + +typedef struct +{ + unsigned char *buffer; + size_t length; + size_t offset; + size_t depth; /* current nesting depth (for formatted printing) */ + cJSON_bool noalloc; + cJSON_bool format; /* is this print a formatted print */ + internal_hooks hooks; +} printbuffer; + +/* realloc printbuffer if necessary to have at least "needed" bytes more */ +static unsigned char* ensure(printbuffer * const p, size_t needed) +{ + unsigned char *newbuffer = NULL; + size_t newsize = 0; + + if ((p == NULL) || (p->buffer == NULL)) + { + return NULL; + } + + if ((p->length > 0) && (p->offset >= p->length)) + { + /* make sure that offset is valid */ + return NULL; + } + + if (needed > INT_MAX) + { + /* sizes bigger than INT_MAX are currently not supported */ + return NULL; + } + + needed += p->offset + 1; + if (needed <= p->length) + { + return p->buffer + p->offset; + } + + if (p->noalloc) { + return NULL; + } + + /* calculate new buffer size */ + if (needed > (INT_MAX / 2)) + { + /* overflow of int, use INT_MAX if possible */ + if (needed <= INT_MAX) + { + newsize = INT_MAX; + } + else + { + return NULL; + } + } + else + { + newsize = needed * 2; + } + + if (p->hooks.reallocate != NULL) + { + /* reallocate with realloc if available */ + newbuffer = (unsigned char*)p->hooks.reallocate(p->buffer, newsize); + if (newbuffer == NULL) + { + p->hooks.deallocate(p->buffer); + p->length = 0; + p->buffer = NULL; + + return NULL; + } + } + else + { + /* otherwise reallocate manually */ + newbuffer = (unsigned char*)p->hooks.allocate(newsize); + if (!newbuffer) + { + p->hooks.deallocate(p->buffer); + p->length = 0; + p->buffer = NULL; + + return NULL; + } + + memcpy(newbuffer, p->buffer, p->offset + 1); + p->hooks.deallocate(p->buffer); + } + p->length = newsize; + p->buffer = newbuffer; + + return newbuffer + p->offset; +} + +/* calculate the new length of the string in a printbuffer and update the offset */ +static void update_offset(printbuffer * const buffer) +{ + const unsigned char *buffer_pointer = NULL; + if ((buffer == NULL) || (buffer->buffer == NULL)) + { + return; + } + buffer_pointer = buffer->buffer + buffer->offset; + + buffer->offset += strlen((const char*)buffer_pointer); +} + +/* securely comparison of floating-point variables */ +static cJSON_bool compare_double(double a, double b) +{ + double maxVal = fabs(a) > fabs(b) ? fabs(a) : fabs(b); + return (fabs(a - b) <= maxVal * DBL_EPSILON); +} + +/* Render the number nicely from the given item into a string. */ +static cJSON_bool print_number(const cJSON * const item, printbuffer * const output_buffer) +{ + unsigned char *output_pointer = NULL; + double d = item->valuedouble; + int length = 0; + size_t i = 0; + unsigned char number_buffer[26] = {0}; /* temporary buffer to print the number into */ + unsigned char decimal_point = get_decimal_point(); + double test = 0.0; + + if (output_buffer == NULL) + { + return false; + } + + /* This checks for NaN and Infinity */ + if (isnan(d) || isinf(d)) + { + length = sprintf((char*)number_buffer, "null"); + } + else if(d == (double)item->valueint) + { + length = sprintf((char*)number_buffer, "%d", item->valueint); + } + else + { + /* Try 15 decimal places of precision to avoid nonsignificant nonzero digits */ + length = sprintf((char*)number_buffer, "%1.15g", d); + + /* Check whether the original double can be recovered */ + if ((sscanf((char*)number_buffer, "%lg", &test) != 1) || !compare_double((double)test, d)) + { + /* If not, print with 17 decimal places of precision */ + length = sprintf((char*)number_buffer, "%1.17g", d); + } + } + + /* sprintf failed or buffer overrun occurred */ + if ((length < 0) || (length > (int)(sizeof(number_buffer) - 1))) + { + return false; + } + + /* reserve appropriate space in the output */ + output_pointer = ensure(output_buffer, (size_t)length + sizeof("")); + if (output_pointer == NULL) + { + return false; + } + + /* copy the printed number to the output and replace locale + * dependent decimal point with '.' */ + for (i = 0; i < ((size_t)length); i++) + { + if (number_buffer[i] == decimal_point) + { + output_pointer[i] = '.'; + continue; + } + + output_pointer[i] = number_buffer[i]; + } + output_pointer[i] = '\0'; + + output_buffer->offset += (size_t)length; + + return true; +} + +/* parse 4 digit hexadecimal number */ +static unsigned parse_hex4(const unsigned char * const input) +{ + unsigned int h = 0; + size_t i = 0; + + for (i = 0; i < 4; i++) + { + /* parse digit */ + if ((input[i] >= '0') && (input[i] <= '9')) + { + h += (unsigned int) input[i] - '0'; + } + else if ((input[i] >= 'A') && (input[i] <= 'F')) + { + h += (unsigned int) 10 + input[i] - 'A'; + } + else if ((input[i] >= 'a') && (input[i] <= 'f')) + { + h += (unsigned int) 10 + input[i] - 'a'; + } + else /* invalid */ + { + return 0; + } + + if (i < 3) + { + /* shift left to make place for the next nibble */ + h = h << 4; + } + } + + return h; +} + +/* converts a UTF-16 literal to UTF-8 + * A literal can be one or two sequences of the form \uXXXX */ +static unsigned char utf16_literal_to_utf8(const unsigned char * const input_pointer, const unsigned char * const input_end, unsigned char **output_pointer) +{ + long unsigned int codepoint = 0; + unsigned int first_code = 0; + const unsigned char *first_sequence = input_pointer; + unsigned char utf8_length = 0; + unsigned char utf8_position = 0; + unsigned char sequence_length = 0; + unsigned char first_byte_mark = 0; + + if ((input_end - first_sequence) < 6) + { + /* input ends unexpectedly */ + goto fail; + } + + /* get the first utf16 sequence */ + first_code = parse_hex4(first_sequence + 2); + + /* check that the code is valid */ + if (((first_code >= 0xDC00) && (first_code <= 0xDFFF))) + { + goto fail; + } + + /* UTF16 surrogate pair */ + if ((first_code >= 0xD800) && (first_code <= 0xDBFF)) + { + const unsigned char *second_sequence = first_sequence + 6; + unsigned int second_code = 0; + sequence_length = 12; /* \uXXXX\uXXXX */ + + if ((input_end - second_sequence) < 6) + { + /* input ends unexpectedly */ + goto fail; + } + + if ((second_sequence[0] != '\\') || (second_sequence[1] != 'u')) + { + /* missing second half of the surrogate pair */ + goto fail; + } + + /* get the second utf16 sequence */ + second_code = parse_hex4(second_sequence + 2); + /* check that the code is valid */ + if ((second_code < 0xDC00) || (second_code > 0xDFFF)) + { + /* invalid second half of the surrogate pair */ + goto fail; + } + + + /* calculate the unicode codepoint from the surrogate pair */ + codepoint = 0x10000 + (((first_code & 0x3FF) << 10) | (second_code & 0x3FF)); + } + else + { + sequence_length = 6; /* \uXXXX */ + codepoint = first_code; + } + + /* encode as UTF-8 + * takes at maximum 4 bytes to encode: + * 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx */ + if (codepoint < 0x80) + { + /* normal ascii, encoding 0xxxxxxx */ + utf8_length = 1; + } + else if (codepoint < 0x800) + { + /* two bytes, encoding 110xxxxx 10xxxxxx */ + utf8_length = 2; + first_byte_mark = 0xC0; /* 11000000 */ + } + else if (codepoint < 0x10000) + { + /* three bytes, encoding 1110xxxx 10xxxxxx 10xxxxxx */ + utf8_length = 3; + first_byte_mark = 0xE0; /* 11100000 */ + } + else if (codepoint <= 0x10FFFF) + { + /* four bytes, encoding 1110xxxx 10xxxxxx 10xxxxxx 10xxxxxx */ + utf8_length = 4; + first_byte_mark = 0xF0; /* 11110000 */ + } + else + { + /* invalid unicode codepoint */ + goto fail; + } + + /* encode as utf8 */ + for (utf8_position = (unsigned char)(utf8_length - 1); utf8_position > 0; utf8_position--) + { + /* 10xxxxxx */ + (*output_pointer)[utf8_position] = (unsigned char)((codepoint | 0x80) & 0xBF); + codepoint >>= 6; + } + /* encode first byte */ + if (utf8_length > 1) + { + (*output_pointer)[0] = (unsigned char)((codepoint | first_byte_mark) & 0xFF); + } + else + { + (*output_pointer)[0] = (unsigned char)(codepoint & 0x7F); + } + + *output_pointer += utf8_length; + + return sequence_length; + +fail: + return 0; +} + +/* Parse the input text into an unescaped cinput, and populate item. */ +static cJSON_bool parse_string(cJSON * const item, parse_buffer * const input_buffer) +{ + const unsigned char *input_pointer = buffer_at_offset(input_buffer) + 1; + const unsigned char *input_end = buffer_at_offset(input_buffer) + 1; + unsigned char *output_pointer = NULL; + unsigned char *output = NULL; + + /* not a string */ + if (buffer_at_offset(input_buffer)[0] != '\"') + { + goto fail; + } + + { + /* calculate approximate size of the output (overestimate) */ + size_t allocation_length = 0; + size_t skipped_bytes = 0; + while (((size_t)(input_end - input_buffer->content) < input_buffer->length) && (*input_end != '\"')) + { + /* is escape sequence */ + if (input_end[0] == '\\') + { + if ((size_t)(input_end + 1 - input_buffer->content) >= input_buffer->length) + { + /* prevent buffer overflow when last input character is a backslash */ + goto fail; + } + skipped_bytes++; + input_end++; + } + input_end++; + } + if (((size_t)(input_end - input_buffer->content) >= input_buffer->length) || (*input_end != '\"')) + { + goto fail; /* string ended unexpectedly */ + } + + /* This is at most how much we need for the output */ + allocation_length = (size_t) (input_end - buffer_at_offset(input_buffer)) - skipped_bytes; + output = (unsigned char*)input_buffer->hooks.allocate(allocation_length + sizeof("")); + if (output == NULL) + { + goto fail; /* allocation failure */ + } + } + + output_pointer = output; + /* loop through the string literal */ + while (input_pointer < input_end) + { + if (*input_pointer != '\\') + { + *output_pointer++ = *input_pointer++; + } + /* escape sequence */ + else + { + unsigned char sequence_length = 2; + if ((input_end - input_pointer) < 1) + { + goto fail; + } + + switch (input_pointer[1]) + { + case 'b': + *output_pointer++ = '\b'; + break; + case 'f': + *output_pointer++ = '\f'; + break; + case 'n': + *output_pointer++ = '\n'; + break; + case 'r': + *output_pointer++ = '\r'; + break; + case 't': + *output_pointer++ = '\t'; + break; + case '\"': + case '\\': + case '/': + *output_pointer++ = input_pointer[1]; + break; + + /* UTF-16 literal */ + case 'u': + sequence_length = utf16_literal_to_utf8(input_pointer, input_end, &output_pointer); + if (sequence_length == 0) + { + /* failed to convert UTF16-literal to UTF-8 */ + goto fail; + } + break; + + default: + goto fail; + } + input_pointer += sequence_length; + } + } + + /* zero terminate the output */ + *output_pointer = '\0'; + + item->type = cJSON_String; + item->valuestring = (char*)output; + + input_buffer->offset = (size_t) (input_end - input_buffer->content); + input_buffer->offset++; + + return true; + +fail: + if (output != NULL) + { + input_buffer->hooks.deallocate(output); + output = NULL; + } + + if (input_pointer != NULL) + { + input_buffer->offset = (size_t)(input_pointer - input_buffer->content); + } + + return false; +} + +/* Render the cstring provided to an escaped version that can be printed. */ +static cJSON_bool print_string_ptr(const unsigned char * const input, printbuffer * const output_buffer) +{ + const unsigned char *input_pointer = NULL; + unsigned char *output = NULL; + unsigned char *output_pointer = NULL; + size_t output_length = 0; + /* numbers of additional characters needed for escaping */ + size_t escape_characters = 0; + + if (output_buffer == NULL) + { + return false; + } + + /* empty string */ + if (input == NULL) + { + output = ensure(output_buffer, sizeof("\"\"")); + if (output == NULL) + { + return false; + } + strcpy((char*)output, "\"\""); + + return true; + } + + /* set "flag" to 1 if something needs to be escaped */ + for (input_pointer = input; *input_pointer; input_pointer++) + { + switch (*input_pointer) + { + case '\"': + case '\\': + case '\b': + case '\f': + case '\n': + case '\r': + case '\t': + /* one character escape sequence */ + escape_characters++; + break; + default: + if (*input_pointer < 32) + { + /* UTF-16 escape sequence uXXXX */ + escape_characters += 5; + } + break; + } + } + output_length = (size_t)(input_pointer - input) + escape_characters; + + output = ensure(output_buffer, output_length + sizeof("\"\"")); + if (output == NULL) + { + return false; + } + + /* no characters have to be escaped */ + if (escape_characters == 0) + { + output[0] = '\"'; + memcpy(output + 1, input, output_length); + output[output_length + 1] = '\"'; + output[output_length + 2] = '\0'; + + return true; + } + + output[0] = '\"'; + output_pointer = output + 1; + /* copy the string */ + for (input_pointer = input; *input_pointer != '\0'; (void)input_pointer++, output_pointer++) + { + if ((*input_pointer > 31) && (*input_pointer != '\"') && (*input_pointer != '\\')) + { + /* normal character, copy */ + *output_pointer = *input_pointer; + } + else + { + /* character needs to be escaped */ + *output_pointer++ = '\\'; + switch (*input_pointer) + { + case '\\': + *output_pointer = '\\'; + break; + case '\"': + *output_pointer = '\"'; + break; + case '\b': + *output_pointer = 'b'; + break; + case '\f': + *output_pointer = 'f'; + break; + case '\n': + *output_pointer = 'n'; + break; + case '\r': + *output_pointer = 'r'; + break; + case '\t': + *output_pointer = 't'; + break; + default: + /* escape and print as unicode codepoint */ + sprintf((char*)output_pointer, "u%04x", *input_pointer); + output_pointer += 4; + break; + } + } + } + output[output_length + 1] = '\"'; + output[output_length + 2] = '\0'; + + return true; +} + +/* Invoke print_string_ptr (which is useful) on an item. */ +static cJSON_bool print_string(const cJSON * const item, printbuffer * const p) +{ + return print_string_ptr((unsigned char*)item->valuestring, p); +} + +/* Predeclare these prototypes. */ +static cJSON_bool parse_value(cJSON * const item, parse_buffer * const input_buffer); +static cJSON_bool print_value(const cJSON * const item, printbuffer * const output_buffer); +static cJSON_bool parse_array(cJSON * const item, parse_buffer * const input_buffer); +static cJSON_bool print_array(const cJSON * const item, printbuffer * const output_buffer); +static cJSON_bool parse_object(cJSON * const item, parse_buffer * const input_buffer); +static cJSON_bool print_object(const cJSON * const item, printbuffer * const output_buffer); + +/* Utility to jump whitespace and cr/lf */ +static parse_buffer *buffer_skip_whitespace(parse_buffer * const buffer) +{ + if ((buffer == NULL) || (buffer->content == NULL)) + { + return NULL; + } + + if (cannot_access_at_index(buffer, 0)) + { + return buffer; + } + + while (can_access_at_index(buffer, 0) && (buffer_at_offset(buffer)[0] <= 32)) + { + buffer->offset++; + } + + if (buffer->offset == buffer->length) + { + buffer->offset--; + } + + return buffer; +} + +/* skip the UTF-8 BOM (byte order mark) if it is at the beginning of a buffer */ +static parse_buffer *skip_utf8_bom(parse_buffer * const buffer) +{ + if ((buffer == NULL) || (buffer->content == NULL) || (buffer->offset != 0)) + { + return NULL; + } + + if (can_access_at_index(buffer, 4) && (strncmp((const char*)buffer_at_offset(buffer), "\xEF\xBB\xBF", 3) == 0)) + { + buffer->offset += 3; + } + + return buffer; +} + +CJSON_PUBLIC(cJSON *) cJSON_ParseWithOpts(const char *value, const char **return_parse_end, cJSON_bool require_null_terminated) +{ + size_t buffer_length; + + if (NULL == value) + { + return NULL; + } + + /* Adding null character size due to require_null_terminated. */ + buffer_length = strlen(value) + sizeof(""); + + return cJSON_ParseWithLengthOpts(value, buffer_length, return_parse_end, require_null_terminated); +} + +/* Parse an object - create a new root, and populate. */ +CJSON_PUBLIC(cJSON *) cJSON_ParseWithLengthOpts(const char *value, size_t buffer_length, const char **return_parse_end, cJSON_bool require_null_terminated) +{ + parse_buffer buffer = { 0, 0, 0, 0, { 0, 0, 0 } }; + cJSON *item = NULL; + + /* reset error position */ + global_error.json = NULL; + global_error.position = 0; + + if (value == NULL || 0 == buffer_length) + { + goto fail; + } + + buffer.content = (const unsigned char*)value; + buffer.length = buffer_length; + buffer.offset = 0; + buffer.hooks = global_hooks; + + item = cJSON_New_Item(&global_hooks); + if (item == NULL) /* memory fail */ + { + goto fail; + } + + if (!parse_value(item, buffer_skip_whitespace(skip_utf8_bom(&buffer)))) + { + /* parse failure. ep is set. */ + goto fail; + } + + /* if we require null-terminated JSON without appended garbage, skip and then check for a null terminator */ + if (require_null_terminated) + { + buffer_skip_whitespace(&buffer); + if ((buffer.offset >= buffer.length) || buffer_at_offset(&buffer)[0] != '\0') + { + goto fail; + } + } + if (return_parse_end) + { + *return_parse_end = (const char*)buffer_at_offset(&buffer); + } + + return item; + +fail: + if (item != NULL) + { + cJSON_Delete(item); + } + + if (value != NULL) + { + error local_error; + local_error.json = (const unsigned char*)value; + local_error.position = 0; + + if (buffer.offset < buffer.length) + { + local_error.position = buffer.offset; + } + else if (buffer.length > 0) + { + local_error.position = buffer.length - 1; + } + + if (return_parse_end != NULL) + { + *return_parse_end = (const char*)local_error.json + local_error.position; + } + + global_error = local_error; + } + + return NULL; +} + +/* Default options for cJSON_Parse */ +CJSON_PUBLIC(cJSON *) cJSON_Parse(const char *value) +{ + return cJSON_ParseWithOpts(value, 0, 0); +} + +CJSON_PUBLIC(cJSON *) cJSON_ParseWithLength(const char *value, size_t buffer_length) +{ + return cJSON_ParseWithLengthOpts(value, buffer_length, 0, 0); +} + +#define cjson_min(a, b) (((a) < (b)) ? (a) : (b)) + +static unsigned char *print(const cJSON * const item, cJSON_bool format, const internal_hooks * const hooks) +{ + static const size_t default_buffer_size = 256; + printbuffer buffer[1]; + unsigned char *printed = NULL; + + memset(buffer, 0, sizeof(buffer)); + + /* create buffer */ + buffer->buffer = (unsigned char*) hooks->allocate(default_buffer_size); + buffer->length = default_buffer_size; + buffer->format = format; + buffer->hooks = *hooks; + if (buffer->buffer == NULL) + { + goto fail; + } + + /* print the value */ + if (!print_value(item, buffer)) + { + goto fail; + } + update_offset(buffer); + + /* check if reallocate is available */ + if (hooks->reallocate != NULL) + { + printed = (unsigned char*) hooks->reallocate(buffer->buffer, buffer->offset + 1); + if (printed == NULL) { + goto fail; + } + buffer->buffer = NULL; + } + else /* otherwise copy the JSON over to a new buffer */ + { + printed = (unsigned char*) hooks->allocate(buffer->offset + 1); + if (printed == NULL) + { + goto fail; + } + memcpy(printed, buffer->buffer, cjson_min(buffer->length, buffer->offset + 1)); + printed[buffer->offset] = '\0'; /* just to be sure */ + + /* free the buffer */ + hooks->deallocate(buffer->buffer); + buffer->buffer = NULL; + } + + return printed; + +fail: + if (buffer->buffer != NULL) + { + hooks->deallocate(buffer->buffer); + buffer->buffer = NULL; + } + + if (printed != NULL) + { + hooks->deallocate(printed); + printed = NULL; + } + + return NULL; +} + +/* Render a cJSON item/entity/structure to text. */ +CJSON_PUBLIC(char *) cJSON_Print(const cJSON *item) +{ + return (char*)print(item, true, &global_hooks); +} + +CJSON_PUBLIC(char *) cJSON_PrintUnformatted(const cJSON *item) +{ + return (char*)print(item, false, &global_hooks); +} + +CJSON_PUBLIC(char *) cJSON_PrintBuffered(const cJSON *item, int prebuffer, cJSON_bool fmt) +{ + printbuffer p = { 0, 0, 0, 0, 0, 0, { 0, 0, 0 } }; + + if (prebuffer < 0) + { + return NULL; + } + + p.buffer = (unsigned char*)global_hooks.allocate((size_t)prebuffer); + if (!p.buffer) + { + return NULL; + } + + p.length = (size_t)prebuffer; + p.offset = 0; + p.noalloc = false; + p.format = fmt; + p.hooks = global_hooks; + + if (!print_value(item, &p)) + { + global_hooks.deallocate(p.buffer); + p.buffer = NULL; + return NULL; + } + + return (char*)p.buffer; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_PrintPreallocated(cJSON *item, char *buffer, const int length, const cJSON_bool format) +{ + printbuffer p = { 0, 0, 0, 0, 0, 0, { 0, 0, 0 } }; + + if ((length < 0) || (buffer == NULL)) + { + return false; + } + + p.buffer = (unsigned char*)buffer; + p.length = (size_t)length; + p.offset = 0; + p.noalloc = true; + p.format = format; + p.hooks = global_hooks; + + return print_value(item, &p); +} + +/* Parser core - when encountering text, process appropriately. */ +static cJSON_bool parse_value(cJSON * const item, parse_buffer * const input_buffer) +{ + if ((input_buffer == NULL) || (input_buffer->content == NULL)) + { + return false; /* no input */ + } + + /* parse the different types of values */ + /* null */ + if (can_read(input_buffer, 4) && (strncmp((const char*)buffer_at_offset(input_buffer), "null", 4) == 0)) + { + item->type = cJSON_NULL; + input_buffer->offset += 4; + return true; + } + /* false */ + if (can_read(input_buffer, 5) && (strncmp((const char*)buffer_at_offset(input_buffer), "false", 5) == 0)) + { + item->type = cJSON_False; + input_buffer->offset += 5; + return true; + } + /* true */ + if (can_read(input_buffer, 4) && (strncmp((const char*)buffer_at_offset(input_buffer), "true", 4) == 0)) + { + item->type = cJSON_True; + item->valueint = 1; + input_buffer->offset += 4; + return true; + } + /* string */ + if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '\"')) + { + return parse_string(item, input_buffer); + } + /* number */ + if (can_access_at_index(input_buffer, 0) && ((buffer_at_offset(input_buffer)[0] == '-') || ((buffer_at_offset(input_buffer)[0] >= '0') && (buffer_at_offset(input_buffer)[0] <= '9')))) + { + return parse_number(item, input_buffer); + } + /* array */ + if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '[')) + { + return parse_array(item, input_buffer); + } + /* object */ + if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '{')) + { + return parse_object(item, input_buffer); + } + + return false; +} + +/* Render a value to text. */ +static cJSON_bool print_value(const cJSON * const item, printbuffer * const output_buffer) +{ + unsigned char *output = NULL; + + if ((item == NULL) || (output_buffer == NULL)) + { + return false; + } + + switch ((item->type) & 0xFF) + { + case cJSON_NULL: + output = ensure(output_buffer, 5); + if (output == NULL) + { + return false; + } + strcpy((char*)output, "null"); + return true; + + case cJSON_False: + output = ensure(output_buffer, 6); + if (output == NULL) + { + return false; + } + strcpy((char*)output, "false"); + return true; + + case cJSON_True: + output = ensure(output_buffer, 5); + if (output == NULL) + { + return false; + } + strcpy((char*)output, "true"); + return true; + + case cJSON_Number: + return print_number(item, output_buffer); + + case cJSON_Raw: + { + size_t raw_length = 0; + if (item->valuestring == NULL) + { + return false; + } + + raw_length = strlen(item->valuestring) + sizeof(""); + output = ensure(output_buffer, raw_length); + if (output == NULL) + { + return false; + } + memcpy(output, item->valuestring, raw_length); + return true; + } + + case cJSON_String: + return print_string(item, output_buffer); + + case cJSON_Array: + return print_array(item, output_buffer); + + case cJSON_Object: + return print_object(item, output_buffer); + + default: + return false; + } +} + +/* Build an array from input text. */ +static cJSON_bool parse_array(cJSON * const item, parse_buffer * const input_buffer) +{ + cJSON *head = NULL; /* head of the linked list */ + cJSON *current_item = NULL; + + if (input_buffer->depth >= CJSON_NESTING_LIMIT) + { + return false; /* to deeply nested */ + } + input_buffer->depth++; + + if (buffer_at_offset(input_buffer)[0] != '[') + { + /* not an array */ + goto fail; + } + + input_buffer->offset++; + buffer_skip_whitespace(input_buffer); + if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ']')) + { + /* empty array */ + goto success; + } + + /* check if we skipped to the end of the buffer */ + if (cannot_access_at_index(input_buffer, 0)) + { + input_buffer->offset--; + goto fail; + } + + /* step back to character in front of the first element */ + input_buffer->offset--; + /* loop through the comma separated array elements */ + do + { + /* allocate next item */ + cJSON *new_item = cJSON_New_Item(&(input_buffer->hooks)); + if (new_item == NULL) + { + goto fail; /* allocation failure */ + } + + /* attach next item to list */ + if (head == NULL) + { + /* start the linked list */ + current_item = head = new_item; + } + else + { + /* add to the end and advance */ + current_item->next = new_item; + new_item->prev = current_item; + current_item = new_item; + } + + /* parse next value */ + input_buffer->offset++; + buffer_skip_whitespace(input_buffer); + if (!parse_value(current_item, input_buffer)) + { + goto fail; /* failed to parse value */ + } + buffer_skip_whitespace(input_buffer); + } + while (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ',')); + + if (cannot_access_at_index(input_buffer, 0) || buffer_at_offset(input_buffer)[0] != ']') + { + goto fail; /* expected end of array */ + } + +success: + input_buffer->depth--; + + if (head != NULL) { + head->prev = current_item; + } + + item->type = cJSON_Array; + item->child = head; + + input_buffer->offset++; + + return true; + +fail: + if (head != NULL) + { + cJSON_Delete(head); + } + + return false; +} + +/* Render an array to text */ +static cJSON_bool print_array(const cJSON * const item, printbuffer * const output_buffer) +{ + unsigned char *output_pointer = NULL; + size_t length = 0; + cJSON *current_element = item->child; + + if (output_buffer == NULL) + { + return false; + } + + if (output_buffer->depth >= CJSON_NESTING_LIMIT) + { + return false; /* nesting is too deep */ + } + + /* Compose the output array. */ + /* opening square bracket */ + output_pointer = ensure(output_buffer, 1); + if (output_pointer == NULL) + { + return false; + } + + *output_pointer = '['; + output_buffer->offset++; + output_buffer->depth++; + + while (current_element != NULL) + { + if (!print_value(current_element, output_buffer)) + { + return false; + } + update_offset(output_buffer); + if (current_element->next) + { + length = (size_t) (output_buffer->format ? 2 : 1); + output_pointer = ensure(output_buffer, length + 1); + if (output_pointer == NULL) + { + return false; + } + *output_pointer++ = ','; + if(output_buffer->format) + { + *output_pointer++ = ' '; + } + *output_pointer = '\0'; + output_buffer->offset += length; + } + current_element = current_element->next; + } + + output_pointer = ensure(output_buffer, 2); + if (output_pointer == NULL) + { + return false; + } + *output_pointer++ = ']'; + *output_pointer = '\0'; + output_buffer->depth--; + + return true; +} + +/* Build an object from the text. */ +static cJSON_bool parse_object(cJSON * const item, parse_buffer * const input_buffer) +{ + cJSON *head = NULL; /* linked list head */ + cJSON *current_item = NULL; + + if (input_buffer->depth >= CJSON_NESTING_LIMIT) + { + return false; /* to deeply nested */ + } + input_buffer->depth++; + + if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != '{')) + { + goto fail; /* not an object */ + } + + input_buffer->offset++; + buffer_skip_whitespace(input_buffer); + if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '}')) + { + goto success; /* empty object */ + } + + /* check if we skipped to the end of the buffer */ + if (cannot_access_at_index(input_buffer, 0)) + { + input_buffer->offset--; + goto fail; + } + + /* step back to character in front of the first element */ + input_buffer->offset--; + /* loop through the comma separated array elements */ + do + { + /* allocate next item */ + cJSON *new_item = cJSON_New_Item(&(input_buffer->hooks)); + if (new_item == NULL) + { + goto fail; /* allocation failure */ + } + + /* attach next item to list */ + if (head == NULL) + { + /* start the linked list */ + current_item = head = new_item; + } + else + { + /* add to the end and advance */ + current_item->next = new_item; + new_item->prev = current_item; + current_item = new_item; + } + + if (cannot_access_at_index(input_buffer, 1)) + { + goto fail; /* nothing comes after the comma */ + } + + /* parse the name of the child */ + input_buffer->offset++; + buffer_skip_whitespace(input_buffer); + if (!parse_string(current_item, input_buffer)) + { + goto fail; /* failed to parse name */ + } + buffer_skip_whitespace(input_buffer); + + /* swap valuestring and string, because we parsed the name */ + current_item->string = current_item->valuestring; + current_item->valuestring = NULL; + + if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != ':')) + { + goto fail; /* invalid object */ + } + + /* parse the value */ + input_buffer->offset++; + buffer_skip_whitespace(input_buffer); + if (!parse_value(current_item, input_buffer)) + { + goto fail; /* failed to parse value */ + } + buffer_skip_whitespace(input_buffer); + } + while (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ',')); + + if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != '}')) + { + goto fail; /* expected end of object */ + } + +success: + input_buffer->depth--; + + if (head != NULL) { + head->prev = current_item; + } + + item->type = cJSON_Object; + item->child = head; + + input_buffer->offset++; + return true; + +fail: + if (head != NULL) + { + cJSON_Delete(head); + } + + return false; +} + +/* Render an object to text. */ +static cJSON_bool print_object(const cJSON * const item, printbuffer * const output_buffer) +{ + unsigned char *output_pointer = NULL; + size_t length = 0; + cJSON *current_item = item->child; + + if (output_buffer == NULL) + { + return false; + } + + if (output_buffer->depth >= CJSON_NESTING_LIMIT) + { + return false; /* nesting is too deep */ + } + + /* Compose the output: */ + length = (size_t) (output_buffer->format ? 2 : 1); /* fmt: {\n */ + output_pointer = ensure(output_buffer, length + 1); + if (output_pointer == NULL) + { + return false; + } + + *output_pointer++ = '{'; + output_buffer->depth++; + if (output_buffer->format) + { + *output_pointer++ = '\n'; + } + output_buffer->offset += length; + + while (current_item) + { + if (output_buffer->format) + { + size_t i; + output_pointer = ensure(output_buffer, output_buffer->depth); + if (output_pointer == NULL) + { + return false; + } + for (i = 0; i < output_buffer->depth; i++) + { + *output_pointer++ = '\t'; + } + output_buffer->offset += output_buffer->depth; + } + + /* print key */ + if (!print_string_ptr((unsigned char*)current_item->string, output_buffer)) + { + return false; + } + update_offset(output_buffer); + + length = (size_t) (output_buffer->format ? 2 : 1); + output_pointer = ensure(output_buffer, length); + if (output_pointer == NULL) + { + return false; + } + *output_pointer++ = ':'; + if (output_buffer->format) + { + *output_pointer++ = '\t'; + } + output_buffer->offset += length; + + /* print value */ + if (!print_value(current_item, output_buffer)) + { + return false; + } + update_offset(output_buffer); + + /* print comma if not last */ + length = ((size_t)(output_buffer->format ? 1 : 0) + (size_t)(current_item->next ? 1 : 0)); + output_pointer = ensure(output_buffer, length + 1); + if (output_pointer == NULL) + { + return false; + } + if (current_item->next) + { + *output_pointer++ = ','; + } + + if (output_buffer->format) + { + *output_pointer++ = '\n'; + } + *output_pointer = '\0'; + output_buffer->offset += length; + + current_item = current_item->next; + } + + output_pointer = ensure(output_buffer, output_buffer->format ? (output_buffer->depth + 1) : 2); + if (output_pointer == NULL) + { + return false; + } + if (output_buffer->format) + { + size_t i; + for (i = 0; i < (output_buffer->depth - 1); i++) + { + *output_pointer++ = '\t'; + } + } + *output_pointer++ = '}'; + *output_pointer = '\0'; + output_buffer->depth--; + + return true; +} + +/* Get Array size/item / object item. */ +CJSON_PUBLIC(int) cJSON_GetArraySize(const cJSON *array) +{ + cJSON *child = NULL; + size_t size = 0; + + if (array == NULL) + { + return 0; + } + + child = array->child; + + while(child != NULL) + { + size++; + child = child->next; + } + + /* FIXME: Can overflow here. Cannot be fixed without breaking the API */ + + return (int)size; +} + +static cJSON* get_array_item(const cJSON *array, size_t index) +{ + cJSON *current_child = NULL; + + if (array == NULL) + { + return NULL; + } + + current_child = array->child; + while ((current_child != NULL) && (index > 0)) + { + index--; + current_child = current_child->next; + } + + return current_child; +} + +CJSON_PUBLIC(cJSON *) cJSON_GetArrayItem(const cJSON *array, int index) +{ + if (index < 0) + { + return NULL; + } + + return get_array_item(array, (size_t)index); +} + +static cJSON *get_object_item(const cJSON * const object, const char * const name, const cJSON_bool case_sensitive) +{ + cJSON *current_element = NULL; + + if ((object == NULL) || (name == NULL)) + { + return NULL; + } + + current_element = object->child; + if (case_sensitive) + { + while ((current_element != NULL) && (current_element->string != NULL) && (strcmp(name, current_element->string) != 0)) + { + current_element = current_element->next; + } + } + else + { + while ((current_element != NULL) && (case_insensitive_strcmp((const unsigned char*)name, (const unsigned char*)(current_element->string)) != 0)) + { + current_element = current_element->next; + } + } + + if ((current_element == NULL) || (current_element->string == NULL)) { + return NULL; + } + + return current_element; +} + +CJSON_PUBLIC(cJSON *) cJSON_GetObjectItem(const cJSON * const object, const char * const string) +{ + return get_object_item(object, string, false); +} + +CJSON_PUBLIC(cJSON *) cJSON_GetObjectItemCaseSensitive(const cJSON * const object, const char * const string) +{ + return get_object_item(object, string, true); +} + +CJSON_PUBLIC(cJSON_bool) cJSON_HasObjectItem(const cJSON *object, const char *string) +{ + return cJSON_GetObjectItem(object, string) ? 1 : 0; +} + +/* Utility for array list handling. */ +static void suffix_object(cJSON *prev, cJSON *item) +{ + prev->next = item; + item->prev = prev; +} + +/* Utility for handling references. */ +static cJSON *create_reference(const cJSON *item, const internal_hooks * const hooks) +{ + cJSON *reference = NULL; + if (item == NULL) + { + return NULL; + } + + reference = cJSON_New_Item(hooks); + if (reference == NULL) + { + return NULL; + } + + memcpy(reference, item, sizeof(cJSON)); + reference->string = NULL; + reference->type |= cJSON_IsReference; + reference->next = reference->prev = NULL; + return reference; +} + +static cJSON_bool add_item_to_array(cJSON *array, cJSON *item) +{ + cJSON *child = NULL; + + if ((item == NULL) || (array == NULL) || (array == item)) + { + return false; + } + + child = array->child; + /* + * To find the last item in array quickly, we use prev in array + */ + if (child == NULL) + { + /* list is empty, start new one */ + array->child = item; + item->prev = item; + item->next = NULL; + } + else + { + /* append to the end */ + if (child->prev) + { + suffix_object(child->prev, item); + array->child->prev = item; + } + } + + return true; +} + +/* Add item to array/object. */ +CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToArray(cJSON *array, cJSON *item) +{ + return add_item_to_array(array, item); +} + +#if defined(__clang__) || (defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 5)))) + #pragma GCC diagnostic push +#endif +#ifdef __GNUC__ +#pragma GCC diagnostic ignored "-Wcast-qual" +#endif +/* helper function to cast away const */ +static void* cast_away_const(const void* string) +{ + return (void*)string; +} +#if defined(__clang__) || (defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 5)))) + #pragma GCC diagnostic pop +#endif + + +static cJSON_bool add_item_to_object(cJSON * const object, const char * const string, cJSON * const item, const internal_hooks * const hooks, const cJSON_bool constant_key) +{ + char *new_key = NULL; + int new_type = cJSON_Invalid; + + if ((object == NULL) || (string == NULL) || (item == NULL) || (object == item)) + { + return false; + } + + if (constant_key) + { + new_key = (char*)cast_away_const(string); + new_type = item->type | cJSON_StringIsConst; + } + else + { + new_key = (char*)cJSON_strdup((const unsigned char*)string, hooks); + if (new_key == NULL) + { + return false; + } + + new_type = item->type & ~cJSON_StringIsConst; + } + + if (!(item->type & cJSON_StringIsConst) && (item->string != NULL)) + { + hooks->deallocate(item->string); + } + + item->string = new_key; + item->type = new_type; + + return add_item_to_array(object, item); +} + +CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToObject(cJSON *object, const char *string, cJSON *item) +{ + return add_item_to_object(object, string, item, &global_hooks, false); +} + +/* Add an item to an object with constant string as key */ +CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToObjectCS(cJSON *object, const char *string, cJSON *item) +{ + return add_item_to_object(object, string, item, &global_hooks, true); +} + +CJSON_PUBLIC(cJSON_bool) cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item) +{ + if (array == NULL) + { + return false; + } + + return add_item_to_array(array, create_reference(item, &global_hooks)); +} + +CJSON_PUBLIC(cJSON_bool) cJSON_AddItemReferenceToObject(cJSON *object, const char *string, cJSON *item) +{ + if ((object == NULL) || (string == NULL)) + { + return false; + } + + return add_item_to_object(object, string, create_reference(item, &global_hooks), &global_hooks, false); +} + +CJSON_PUBLIC(cJSON*) cJSON_AddNullToObject(cJSON * const object, const char * const name) +{ + cJSON *null = cJSON_CreateNull(); + if (add_item_to_object(object, name, null, &global_hooks, false)) + { + return null; + } + + cJSON_Delete(null); + return NULL; +} + +CJSON_PUBLIC(cJSON*) cJSON_AddTrueToObject(cJSON * const object, const char * const name) +{ + cJSON *true_item = cJSON_CreateTrue(); + if (add_item_to_object(object, name, true_item, &global_hooks, false)) + { + return true_item; + } + + cJSON_Delete(true_item); + return NULL; +} + +CJSON_PUBLIC(cJSON*) cJSON_AddFalseToObject(cJSON * const object, const char * const name) +{ + cJSON *false_item = cJSON_CreateFalse(); + if (add_item_to_object(object, name, false_item, &global_hooks, false)) + { + return false_item; + } + + cJSON_Delete(false_item); + return NULL; +} + +CJSON_PUBLIC(cJSON*) cJSON_AddBoolToObject(cJSON * const object, const char * const name, const cJSON_bool boolean) +{ + cJSON *bool_item = cJSON_CreateBool(boolean); + if (add_item_to_object(object, name, bool_item, &global_hooks, false)) + { + return bool_item; + } + + cJSON_Delete(bool_item); + return NULL; +} + +CJSON_PUBLIC(cJSON*) cJSON_AddNumberToObject(cJSON * const object, const char * const name, const double number) +{ + cJSON *number_item = cJSON_CreateNumber(number); + if (add_item_to_object(object, name, number_item, &global_hooks, false)) + { + return number_item; + } + + cJSON_Delete(number_item); + return NULL; +} + +CJSON_PUBLIC(cJSON*) cJSON_AddStringToObject(cJSON * const object, const char * const name, const char * const string) +{ + cJSON *string_item = cJSON_CreateString(string); + if (add_item_to_object(object, name, string_item, &global_hooks, false)) + { + return string_item; + } + + cJSON_Delete(string_item); + return NULL; +} + +CJSON_PUBLIC(cJSON*) cJSON_AddRawToObject(cJSON * const object, const char * const name, const char * const raw) +{ + cJSON *raw_item = cJSON_CreateRaw(raw); + if (add_item_to_object(object, name, raw_item, &global_hooks, false)) + { + return raw_item; + } + + cJSON_Delete(raw_item); + return NULL; +} + +CJSON_PUBLIC(cJSON*) cJSON_AddObjectToObject(cJSON * const object, const char * const name) +{ + cJSON *object_item = cJSON_CreateObject(); + if (add_item_to_object(object, name, object_item, &global_hooks, false)) + { + return object_item; + } + + cJSON_Delete(object_item); + return NULL; +} + +CJSON_PUBLIC(cJSON*) cJSON_AddArrayToObject(cJSON * const object, const char * const name) +{ + cJSON *array = cJSON_CreateArray(); + if (add_item_to_object(object, name, array, &global_hooks, false)) + { + return array; + } + + cJSON_Delete(array); + return NULL; +} + +CJSON_PUBLIC(cJSON *) cJSON_DetachItemViaPointer(cJSON *parent, cJSON * const item) +{ + if ((parent == NULL) || (item == NULL) || (item != parent->child && item->prev == NULL)) + { + return NULL; + } + + if (item != parent->child) + { + /* not the first element */ + item->prev->next = item->next; + } + if (item->next != NULL) + { + /* not the last element */ + item->next->prev = item->prev; + } + + if (item == parent->child) + { + /* first element */ + parent->child = item->next; + } + else if (item->next == NULL) + { + /* last element */ + parent->child->prev = item->prev; + } + + /* make sure the detached item doesn't point anywhere anymore */ + item->prev = NULL; + item->next = NULL; + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromArray(cJSON *array, int which) +{ + if (which < 0) + { + return NULL; + } + + return cJSON_DetachItemViaPointer(array, get_array_item(array, (size_t)which)); +} + +CJSON_PUBLIC(void) cJSON_DeleteItemFromArray(cJSON *array, int which) +{ + cJSON_Delete(cJSON_DetachItemFromArray(array, which)); +} + +CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObject(cJSON *object, const char *string) +{ + cJSON *to_detach = cJSON_GetObjectItem(object, string); + + return cJSON_DetachItemViaPointer(object, to_detach); +} + +CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObjectCaseSensitive(cJSON *object, const char *string) +{ + cJSON *to_detach = cJSON_GetObjectItemCaseSensitive(object, string); + + return cJSON_DetachItemViaPointer(object, to_detach); +} + +CJSON_PUBLIC(void) cJSON_DeleteItemFromObject(cJSON *object, const char *string) +{ + cJSON_Delete(cJSON_DetachItemFromObject(object, string)); +} + +CJSON_PUBLIC(void) cJSON_DeleteItemFromObjectCaseSensitive(cJSON *object, const char *string) +{ + cJSON_Delete(cJSON_DetachItemFromObjectCaseSensitive(object, string)); +} + +/* Replace array/object items with new ones. */ +CJSON_PUBLIC(cJSON_bool) cJSON_InsertItemInArray(cJSON *array, int which, cJSON *newitem) +{ + cJSON *after_inserted = NULL; + + if (which < 0 || newitem == NULL) + { + return false; + } + + after_inserted = get_array_item(array, (size_t)which); + if (after_inserted == NULL) + { + return add_item_to_array(array, newitem); + } + + if (after_inserted != array->child && after_inserted->prev == NULL) { + /* return false if after_inserted is a corrupted array item */ + return false; + } + + newitem->next = after_inserted; + newitem->prev = after_inserted->prev; + after_inserted->prev = newitem; + if (after_inserted == array->child) + { + array->child = newitem; + } + else + { + newitem->prev->next = newitem; + } + return true; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemViaPointer(cJSON * const parent, cJSON * const item, cJSON * replacement) +{ + if ((parent == NULL) || (parent->child == NULL) || (replacement == NULL) || (item == NULL)) + { + return false; + } + + if (replacement == item) + { + return true; + } + + replacement->next = item->next; + replacement->prev = item->prev; + + if (replacement->next != NULL) + { + replacement->next->prev = replacement; + } + if (parent->child == item) + { + if (parent->child->prev == parent->child) + { + replacement->prev = replacement; + } + parent->child = replacement; + } + else + { /* + * To find the last item in array quickly, we use prev in array. + * We can't modify the last item's next pointer where this item was the parent's child + */ + if (replacement->prev != NULL) + { + replacement->prev->next = replacement; + } + if (replacement->next == NULL) + { + parent->child->prev = replacement; + } + } + + item->next = NULL; + item->prev = NULL; + cJSON_Delete(item); + + return true; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInArray(cJSON *array, int which, cJSON *newitem) +{ + if (which < 0) + { + return false; + } + + return cJSON_ReplaceItemViaPointer(array, get_array_item(array, (size_t)which), newitem); +} + +static cJSON_bool replace_item_in_object(cJSON *object, const char *string, cJSON *replacement, cJSON_bool case_sensitive) +{ + if ((replacement == NULL) || (string == NULL)) + { + return false; + } + + /* replace the name in the replacement */ + if (!(replacement->type & cJSON_StringIsConst) && (replacement->string != NULL)) + { + cJSON_free(replacement->string); + } + replacement->string = (char*)cJSON_strdup((const unsigned char*)string, &global_hooks); + if (replacement->string == NULL) + { + return false; + } + + replacement->type &= ~cJSON_StringIsConst; + + return cJSON_ReplaceItemViaPointer(object, get_object_item(object, string, case_sensitive), replacement); +} + +CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInObject(cJSON *object, const char *string, cJSON *newitem) +{ + return replace_item_in_object(object, string, newitem, false); +} + +CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInObjectCaseSensitive(cJSON *object, const char *string, cJSON *newitem) +{ + return replace_item_in_object(object, string, newitem, true); +} + +/* Create basic types: */ +CJSON_PUBLIC(cJSON *) cJSON_CreateNull(void) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if(item) + { + item->type = cJSON_NULL; + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateTrue(void) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if(item) + { + item->type = cJSON_True; + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateFalse(void) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if(item) + { + item->type = cJSON_False; + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateBool(cJSON_bool boolean) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if(item) + { + item->type = boolean ? cJSON_True : cJSON_False; + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateNumber(double num) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if(item) + { + item->type = cJSON_Number; + item->valuedouble = num; + + /* use saturation in case of overflow */ + if (num >= INT_MAX) + { + item->valueint = INT_MAX; + } + else if (num <= (double)INT_MIN) + { + item->valueint = INT_MIN; + } + else + { + item->valueint = (int)num; + } + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateString(const char *string) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if(item) + { + item->type = cJSON_String; + item->valuestring = (char*)cJSON_strdup((const unsigned char*)string, &global_hooks); + if(!item->valuestring) + { + cJSON_Delete(item); + return NULL; + } + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateStringReference(const char *string) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if (item != NULL) + { + item->type = cJSON_String | cJSON_IsReference; + item->valuestring = (char*)cast_away_const(string); + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateObjectReference(const cJSON *child) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if (item != NULL) { + item->type = cJSON_Object | cJSON_IsReference; + item->child = (cJSON*)cast_away_const(child); + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateArrayReference(const cJSON *child) { + cJSON *item = cJSON_New_Item(&global_hooks); + if (item != NULL) { + item->type = cJSON_Array | cJSON_IsReference; + item->child = (cJSON*)cast_away_const(child); + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateRaw(const char *raw) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if(item) + { + item->type = cJSON_Raw; + item->valuestring = (char*)cJSON_strdup((const unsigned char*)raw, &global_hooks); + if(!item->valuestring) + { + cJSON_Delete(item); + return NULL; + } + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateArray(void) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if(item) + { + item->type=cJSON_Array; + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateObject(void) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if (item) + { + item->type = cJSON_Object; + } + + return item; +} + +/* Create Arrays: */ +CJSON_PUBLIC(cJSON *) cJSON_CreateIntArray(const int *numbers, int count) +{ + size_t i = 0; + cJSON *n = NULL; + cJSON *p = NULL; + cJSON *a = NULL; + + if ((count < 0) || (numbers == NULL)) + { + return NULL; + } + + a = cJSON_CreateArray(); + + for(i = 0; a && (i < (size_t)count); i++) + { + n = cJSON_CreateNumber(numbers[i]); + if (!n) + { + cJSON_Delete(a); + return NULL; + } + if(!i) + { + a->child = n; + } + else + { + suffix_object(p, n); + } + p = n; + } + + if (a && a->child) { + a->child->prev = n; + } + + return a; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateFloatArray(const float *numbers, int count) +{ + size_t i = 0; + cJSON *n = NULL; + cJSON *p = NULL; + cJSON *a = NULL; + + if ((count < 0) || (numbers == NULL)) + { + return NULL; + } + + a = cJSON_CreateArray(); + + for(i = 0; a && (i < (size_t)count); i++) + { + n = cJSON_CreateNumber((double)numbers[i]); + if(!n) + { + cJSON_Delete(a); + return NULL; + } + if(!i) + { + a->child = n; + } + else + { + suffix_object(p, n); + } + p = n; + } + + if (a && a->child) { + a->child->prev = n; + } + + return a; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateDoubleArray(const double *numbers, int count) +{ + size_t i = 0; + cJSON *n = NULL; + cJSON *p = NULL; + cJSON *a = NULL; + + if ((count < 0) || (numbers == NULL)) + { + return NULL; + } + + a = cJSON_CreateArray(); + + for(i = 0; a && (i < (size_t)count); i++) + { + n = cJSON_CreateNumber(numbers[i]); + if(!n) + { + cJSON_Delete(a); + return NULL; + } + if(!i) + { + a->child = n; + } + else + { + suffix_object(p, n); + } + p = n; + } + + if (a && a->child) { + a->child->prev = n; + } + + return a; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateStringArray(const char *const *strings, int count) +{ + size_t i = 0; + cJSON *n = NULL; + cJSON *p = NULL; + cJSON *a = NULL; + + if ((count < 0) || (strings == NULL)) + { + return NULL; + } + + a = cJSON_CreateArray(); + + for (i = 0; a && (i < (size_t)count); i++) + { + n = cJSON_CreateString(strings[i]); + if(!n) + { + cJSON_Delete(a); + return NULL; + } + if(!i) + { + a->child = n; + } + else + { + suffix_object(p,n); + } + p = n; + } + + if (a && a->child) { + a->child->prev = n; + } + + return a; +} + +/* Duplication */ +cJSON * cJSON_Duplicate_rec(const cJSON *item, size_t depth, cJSON_bool recurse); + +CJSON_PUBLIC(cJSON *) cJSON_Duplicate(const cJSON *item, cJSON_bool recurse) +{ + return cJSON_Duplicate_rec(item, 0, recurse ); +} + +cJSON * cJSON_Duplicate_rec(const cJSON *item, size_t depth, cJSON_bool recurse) +{ + cJSON *newitem = NULL; + cJSON *child = NULL; + cJSON *next = NULL; + cJSON *newchild = NULL; + + /* Bail on bad ptr */ + if (!item) + { + goto fail; + } + /* Create new item */ + newitem = cJSON_New_Item(&global_hooks); + if (!newitem) + { + goto fail; + } + /* Copy over all vars */ + newitem->type = item->type & (~cJSON_IsReference); + newitem->valueint = item->valueint; + newitem->valuedouble = item->valuedouble; + if (item->valuestring) + { + newitem->valuestring = (char*)cJSON_strdup((unsigned char*)item->valuestring, &global_hooks); + if (!newitem->valuestring) + { + goto fail; + } + } + if (item->string) + { + newitem->string = (item->type&cJSON_StringIsConst) ? item->string : (char*)cJSON_strdup((unsigned char*)item->string, &global_hooks); + if (!newitem->string) + { + goto fail; + } + } + /* If non-recursive, then we're done! */ + if (!recurse) + { + return newitem; + } + /* Walk the ->next chain for the child. */ + child = item->child; + while (child != NULL) + { + if(depth >= CJSON_CIRCULAR_LIMIT) { + goto fail; + } + newchild = cJSON_Duplicate_rec(child, depth + 1, true); /* Duplicate (with recurse) each item in the ->next chain */ + if (!newchild) + { + goto fail; + } + if (next != NULL) + { + /* If newitem->child already set, then crosswire ->prev and ->next and move on */ + next->next = newchild; + newchild->prev = next; + next = newchild; + } + else + { + /* Set newitem->child and move to it */ + newitem->child = newchild; + next = newchild; + } + child = child->next; + } + if (newitem && newitem->child) + { + newitem->child->prev = newchild; + } + + return newitem; + +fail: + if (newitem != NULL) + { + cJSON_Delete(newitem); + } + + return NULL; +} + +static void skip_oneline_comment(char **input) +{ + *input += static_strlen("//"); + + for (; (*input)[0] != '\0'; ++(*input)) + { + if ((*input)[0] == '\n') { + *input += static_strlen("\n"); + return; + } + } +} + +static void skip_multiline_comment(char **input) +{ + *input += static_strlen("/*"); + + for (; (*input)[0] != '\0'; ++(*input)) + { + if (((*input)[0] == '*') && ((*input)[1] == '/')) + { + *input += static_strlen("*/"); + return; + } + } +} + +static void minify_string(char **input, char **output) { + (*output)[0] = (*input)[0]; + *input += static_strlen("\""); + *output += static_strlen("\""); + + + for (; (*input)[0] != '\0'; (void)++(*input), ++(*output)) { + (*output)[0] = (*input)[0]; + + if ((*input)[0] == '\"') { + (*output)[0] = '\"'; + *input += static_strlen("\""); + *output += static_strlen("\""); + return; + } else if (((*input)[0] == '\\') && ((*input)[1] == '\"')) { + (*output)[1] = (*input)[1]; + *input += static_strlen("\""); + *output += static_strlen("\""); + } + } +} + +CJSON_PUBLIC(void) cJSON_Minify(char *json) +{ + char *into = json; + + if (json == NULL) + { + return; + } + + while (json[0] != '\0') + { + switch (json[0]) + { + case ' ': + case '\t': + case '\r': + case '\n': + json++; + break; + + case '/': + if (json[1] == '/') + { + skip_oneline_comment(&json); + } + else if (json[1] == '*') + { + skip_multiline_comment(&json); + } else { + json++; + } + break; + + case '\"': + minify_string(&json, (char**)&into); + break; + + default: + into[0] = json[0]; + json++; + into++; + } + } + + /* and null-terminate. */ + *into = '\0'; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_IsInvalid(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xFF) == cJSON_Invalid; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_IsFalse(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xFF) == cJSON_False; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_IsTrue(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xff) == cJSON_True; +} + + +CJSON_PUBLIC(cJSON_bool) cJSON_IsBool(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & (cJSON_True | cJSON_False)) != 0; +} +CJSON_PUBLIC(cJSON_bool) cJSON_IsNull(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xFF) == cJSON_NULL; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_IsNumber(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xFF) == cJSON_Number; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_IsString(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xFF) == cJSON_String; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_IsArray(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xFF) == cJSON_Array; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_IsObject(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xFF) == cJSON_Object; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_IsRaw(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xFF) == cJSON_Raw; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_Compare(const cJSON * const a, const cJSON * const b, const cJSON_bool case_sensitive) +{ + if ((a == NULL) || (b == NULL) || ((a->type & 0xFF) != (b->type & 0xFF))) + { + return false; + } + + /* check if type is valid */ + switch (a->type & 0xFF) + { + case cJSON_False: + case cJSON_True: + case cJSON_NULL: + case cJSON_Number: + case cJSON_String: + case cJSON_Raw: + case cJSON_Array: + case cJSON_Object: + break; + + default: + return false; + } + + /* identical objects are equal */ + if (a == b) + { + return true; + } + + switch (a->type & 0xFF) + { + /* in these cases and equal type is enough */ + case cJSON_False: + case cJSON_True: + case cJSON_NULL: + return true; + + case cJSON_Number: + if (compare_double(a->valuedouble, b->valuedouble)) + { + return true; + } + return false; + + case cJSON_String: + case cJSON_Raw: + if ((a->valuestring == NULL) || (b->valuestring == NULL)) + { + return false; + } + if (strcmp(a->valuestring, b->valuestring) == 0) + { + return true; + } + + return false; + + case cJSON_Array: + { + cJSON *a_element = a->child; + cJSON *b_element = b->child; + + for (; (a_element != NULL) && (b_element != NULL);) + { + if (!cJSON_Compare(a_element, b_element, case_sensitive)) + { + return false; + } + + a_element = a_element->next; + b_element = b_element->next; + } + + /* one of the arrays is longer than the other */ + if (a_element != b_element) { + return false; + } + + return true; + } + + case cJSON_Object: + { + cJSON *a_element = NULL; + cJSON *b_element = NULL; + cJSON_ArrayForEach(a_element, a) + { + /* TODO This has O(n^2) runtime, which is horrible! */ + b_element = get_object_item(b, a_element->string, case_sensitive); + if (b_element == NULL) + { + return false; + } + + if (!cJSON_Compare(a_element, b_element, case_sensitive)) + { + return false; + } + } + + /* doing this twice, once on a and b to prevent true comparison if a subset of b + * TODO: Do this the proper way, this is just a fix for now */ + cJSON_ArrayForEach(b_element, b) + { + a_element = get_object_item(a, b_element->string, case_sensitive); + if (a_element == NULL) + { + return false; + } + + if (!cJSON_Compare(b_element, a_element, case_sensitive)) + { + return false; + } + } + + return true; + } + + default: + return false; + } +} + +CJSON_PUBLIC(void *) cJSON_malloc(size_t size) +{ + return global_hooks.allocate(size); +} + +CJSON_PUBLIC(void) cJSON_free(void *object) +{ + global_hooks.deallocate(object); + object = NULL; +} diff --git a/tests/data/c/json/cJSON.h b/tests/data/c/json/cJSON.h new file mode 100644 index 000000000..cab5feb42 --- /dev/null +++ b/tests/data/c/json/cJSON.h @@ -0,0 +1,306 @@ +/* + Copyright (c) 2009-2017 Dave Gamble and cJSON contributors + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in + all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + THE SOFTWARE. +*/ + +#ifndef cJSON__h +#define cJSON__h + +#ifdef __cplusplus +extern "C" +{ +#endif + +#if !defined(__WINDOWS__) && (defined(WIN32) || defined(WIN64) || defined(_MSC_VER) || defined(_WIN32)) +#define __WINDOWS__ +#endif + +#ifdef __WINDOWS__ + +/* When compiling for windows, we specify a specific calling convention to avoid issues where we are being called from a project with a different default calling convention. For windows you have 3 define options: + +CJSON_HIDE_SYMBOLS - Define this in the case where you don't want to ever dllexport symbols +CJSON_EXPORT_SYMBOLS - Define this on library build when you want to dllexport symbols (default) +CJSON_IMPORT_SYMBOLS - Define this if you want to dllimport symbol + +For *nix builds that support visibility attribute, you can define similar behavior by + +setting default visibility to hidden by adding +-fvisibility=hidden (for gcc) +or +-xldscope=hidden (for sun cc) +to CFLAGS + +then using the CJSON_API_VISIBILITY flag to "export" the same symbols the way CJSON_EXPORT_SYMBOLS does + +*/ + +#define CJSON_CDECL __cdecl +#define CJSON_STDCALL __stdcall + +/* export symbols by default, this is necessary for copy pasting the C and header file */ +#if !defined(CJSON_HIDE_SYMBOLS) && !defined(CJSON_IMPORT_SYMBOLS) && !defined(CJSON_EXPORT_SYMBOLS) +#define CJSON_EXPORT_SYMBOLS +#endif + +#if defined(CJSON_HIDE_SYMBOLS) +#define CJSON_PUBLIC(type) type CJSON_STDCALL +#elif defined(CJSON_EXPORT_SYMBOLS) +#define CJSON_PUBLIC(type) __declspec(dllexport) type CJSON_STDCALL +#elif defined(CJSON_IMPORT_SYMBOLS) +#define CJSON_PUBLIC(type) __declspec(dllimport) type CJSON_STDCALL +#endif +#else /* !__WINDOWS__ */ +#define CJSON_CDECL +#define CJSON_STDCALL + +#if (defined(__GNUC__) || defined(__SUNPRO_CC) || defined (__SUNPRO_C)) && defined(CJSON_API_VISIBILITY) +#define CJSON_PUBLIC(type) __attribute__((visibility("default"))) type +#else +#define CJSON_PUBLIC(type) type +#endif +#endif + +/* project version */ +#define CJSON_VERSION_MAJOR 1 +#define CJSON_VERSION_MINOR 7 +#define CJSON_VERSION_PATCH 19 + +#include + +/* cJSON Types: */ +#define cJSON_Invalid (0) +#define cJSON_False (1 << 0) +#define cJSON_True (1 << 1) +#define cJSON_NULL (1 << 2) +#define cJSON_Number (1 << 3) +#define cJSON_String (1 << 4) +#define cJSON_Array (1 << 5) +#define cJSON_Object (1 << 6) +#define cJSON_Raw (1 << 7) /* raw json */ + +#define cJSON_IsReference 256 +#define cJSON_StringIsConst 512 + +/* The cJSON structure: */ +typedef struct cJSON +{ + /* next/prev allow you to walk array/object chains. Alternatively, use GetArraySize/GetArrayItem/GetObjectItem */ + struct cJSON *next; + struct cJSON *prev; + /* An array or object item will have a child pointer pointing to a chain of the items in the array/object. */ + struct cJSON *child; + + /* The type of the item, as above. */ + int type; + + /* The item's string, if type==cJSON_String and type == cJSON_Raw */ + char *valuestring; + /* writing to valueint is DEPRECATED, use cJSON_SetNumberValue instead */ + int valueint; + /* The item's number, if type==cJSON_Number */ + double valuedouble; + + /* The item's name string, if this item is the child of, or is in the list of subitems of an object. */ + char *string; +} cJSON; + +typedef struct cJSON_Hooks +{ + /* malloc/free are CDECL on Windows regardless of the default calling convention of the compiler, so ensure the hooks allow passing those functions directly. */ + void *(CJSON_CDECL *malloc_fn)(size_t sz); + void (CJSON_CDECL *free_fn)(void *ptr); +} cJSON_Hooks; + +typedef int cJSON_bool; + +/* Limits how deeply nested arrays/objects can be before cJSON rejects to parse them. + * This is to prevent stack overflows. */ +#ifndef CJSON_NESTING_LIMIT +#define CJSON_NESTING_LIMIT 1000 +#endif + +/* Limits the length of circular references can be before cJSON rejects to parse them. + * This is to prevent stack overflows. */ +#ifndef CJSON_CIRCULAR_LIMIT +#define CJSON_CIRCULAR_LIMIT 10000 +#endif + +/* returns the version of cJSON as a string */ +CJSON_PUBLIC(const char*) cJSON_Version(void); + +/* Supply malloc, realloc and free functions to cJSON */ +CJSON_PUBLIC(void) cJSON_InitHooks(cJSON_Hooks* hooks); + +/* Memory Management: the caller is always responsible to free the results from all variants of cJSON_Parse (with cJSON_Delete) and cJSON_Print (with stdlib free, cJSON_Hooks.free_fn, or cJSON_free as appropriate). The exception is cJSON_PrintPreallocated, where the caller has full responsibility of the buffer. */ +/* Supply a block of JSON, and this returns a cJSON object you can interrogate. */ +CJSON_PUBLIC(cJSON *) cJSON_Parse(const char *value); +CJSON_PUBLIC(cJSON *) cJSON_ParseWithLength(const char *value, size_t buffer_length); +/* ParseWithOpts allows you to require (and check) that the JSON is null terminated, and to retrieve the pointer to the final byte parsed. */ +/* If you supply a ptr in return_parse_end and parsing fails, then return_parse_end will contain a pointer to the error so will match cJSON_GetErrorPtr(). */ +CJSON_PUBLIC(cJSON *) cJSON_ParseWithOpts(const char *value, const char **return_parse_end, cJSON_bool require_null_terminated); +CJSON_PUBLIC(cJSON *) cJSON_ParseWithLengthOpts(const char *value, size_t buffer_length, const char **return_parse_end, cJSON_bool require_null_terminated); + +/* Render a cJSON entity to text for transfer/storage. */ +CJSON_PUBLIC(char *) cJSON_Print(const cJSON *item); +/* Render a cJSON entity to text for transfer/storage without any formatting. */ +CJSON_PUBLIC(char *) cJSON_PrintUnformatted(const cJSON *item); +/* Render a cJSON entity to text using a buffered strategy. prebuffer is a guess at the final size. guessing well reduces reallocation. fmt=0 gives unformatted, =1 gives formatted */ +CJSON_PUBLIC(char *) cJSON_PrintBuffered(const cJSON *item, int prebuffer, cJSON_bool fmt); +/* Render a cJSON entity to text using a buffer already allocated in memory with given length. Returns 1 on success and 0 on failure. */ +/* NOTE: cJSON is not always 100% accurate in estimating how much memory it will use, so to be safe allocate 5 bytes more than you actually need */ +CJSON_PUBLIC(cJSON_bool) cJSON_PrintPreallocated(cJSON *item, char *buffer, const int length, const cJSON_bool format); +/* Delete a cJSON entity and all subentities. */ +CJSON_PUBLIC(void) cJSON_Delete(cJSON *item); + +/* Returns the number of items in an array (or object). */ +CJSON_PUBLIC(int) cJSON_GetArraySize(const cJSON *array); +/* Retrieve item number "index" from array "array". Returns NULL if unsuccessful. */ +CJSON_PUBLIC(cJSON *) cJSON_GetArrayItem(const cJSON *array, int index); +/* Get item "string" from object. Case insensitive. */ +CJSON_PUBLIC(cJSON *) cJSON_GetObjectItem(const cJSON * const object, const char * const string); +CJSON_PUBLIC(cJSON *) cJSON_GetObjectItemCaseSensitive(const cJSON * const object, const char * const string); +CJSON_PUBLIC(cJSON_bool) cJSON_HasObjectItem(const cJSON *object, const char *string); +/* For analysing failed parses. This returns a pointer to the parse error. You'll probably need to look a few chars back to make sense of it. Defined when cJSON_Parse() returns 0. 0 when cJSON_Parse() succeeds. */ +CJSON_PUBLIC(const char *) cJSON_GetErrorPtr(void); + +/* Check item type and return its value */ +CJSON_PUBLIC(char *) cJSON_GetStringValue(const cJSON * const item); +CJSON_PUBLIC(double) cJSON_GetNumberValue(const cJSON * const item); + +/* These functions check the type of an item */ +CJSON_PUBLIC(cJSON_bool) cJSON_IsInvalid(const cJSON * const item); +CJSON_PUBLIC(cJSON_bool) cJSON_IsFalse(const cJSON * const item); +CJSON_PUBLIC(cJSON_bool) cJSON_IsTrue(const cJSON * const item); +CJSON_PUBLIC(cJSON_bool) cJSON_IsBool(const cJSON * const item); +CJSON_PUBLIC(cJSON_bool) cJSON_IsNull(const cJSON * const item); +CJSON_PUBLIC(cJSON_bool) cJSON_IsNumber(const cJSON * const item); +CJSON_PUBLIC(cJSON_bool) cJSON_IsString(const cJSON * const item); +CJSON_PUBLIC(cJSON_bool) cJSON_IsArray(const cJSON * const item); +CJSON_PUBLIC(cJSON_bool) cJSON_IsObject(const cJSON * const item); +CJSON_PUBLIC(cJSON_bool) cJSON_IsRaw(const cJSON * const item); + +/* These calls create a cJSON item of the appropriate type. */ +CJSON_PUBLIC(cJSON *) cJSON_CreateNull(void); +CJSON_PUBLIC(cJSON *) cJSON_CreateTrue(void); +CJSON_PUBLIC(cJSON *) cJSON_CreateFalse(void); +CJSON_PUBLIC(cJSON *) cJSON_CreateBool(cJSON_bool boolean); +CJSON_PUBLIC(cJSON *) cJSON_CreateNumber(double num); +CJSON_PUBLIC(cJSON *) cJSON_CreateString(const char *string); +/* raw json */ +CJSON_PUBLIC(cJSON *) cJSON_CreateRaw(const char *raw); +CJSON_PUBLIC(cJSON *) cJSON_CreateArray(void); +CJSON_PUBLIC(cJSON *) cJSON_CreateObject(void); + +/* Create a string where valuestring references a string so + * it will not be freed by cJSON_Delete */ +CJSON_PUBLIC(cJSON *) cJSON_CreateStringReference(const char *string); +/* Create an object/array that only references it's elements so + * they will not be freed by cJSON_Delete */ +CJSON_PUBLIC(cJSON *) cJSON_CreateObjectReference(const cJSON *child); +CJSON_PUBLIC(cJSON *) cJSON_CreateArrayReference(const cJSON *child); + +/* These utilities create an Array of count items. + * The parameter count cannot be greater than the number of elements in the number array, otherwise array access will be out of bounds.*/ +CJSON_PUBLIC(cJSON *) cJSON_CreateIntArray(const int *numbers, int count); +CJSON_PUBLIC(cJSON *) cJSON_CreateFloatArray(const float *numbers, int count); +CJSON_PUBLIC(cJSON *) cJSON_CreateDoubleArray(const double *numbers, int count); +CJSON_PUBLIC(cJSON *) cJSON_CreateStringArray(const char *const *strings, int count); + +/* Append item to the specified array/object. */ +CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToArray(cJSON *array, cJSON *item); +CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToObject(cJSON *object, const char *string, cJSON *item); +/* Use this when string is definitely const (i.e. a literal, or as good as), and will definitely survive the cJSON object. + * WARNING: When this function was used, make sure to always check that (item->type & cJSON_StringIsConst) is zero before + * writing to `item->string` */ +CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToObjectCS(cJSON *object, const char *string, cJSON *item); +/* Append reference to item to the specified array/object. Use this when you want to add an existing cJSON to a new cJSON, but don't want to corrupt your existing cJSON. */ +CJSON_PUBLIC(cJSON_bool) cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item); +CJSON_PUBLIC(cJSON_bool) cJSON_AddItemReferenceToObject(cJSON *object, const char *string, cJSON *item); + +/* Remove/Detach items from Arrays/Objects. */ +CJSON_PUBLIC(cJSON *) cJSON_DetachItemViaPointer(cJSON *parent, cJSON * const item); +CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromArray(cJSON *array, int which); +CJSON_PUBLIC(void) cJSON_DeleteItemFromArray(cJSON *array, int which); +CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObject(cJSON *object, const char *string); +CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObjectCaseSensitive(cJSON *object, const char *string); +CJSON_PUBLIC(void) cJSON_DeleteItemFromObject(cJSON *object, const char *string); +CJSON_PUBLIC(void) cJSON_DeleteItemFromObjectCaseSensitive(cJSON *object, const char *string); + +/* Update array items. */ +CJSON_PUBLIC(cJSON_bool) cJSON_InsertItemInArray(cJSON *array, int which, cJSON *newitem); /* Shifts pre-existing items to the right. */ +CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemViaPointer(cJSON * const parent, cJSON * const item, cJSON * replacement); +CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInArray(cJSON *array, int which, cJSON *newitem); +CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInObject(cJSON *object,const char *string,cJSON *newitem); +CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInObjectCaseSensitive(cJSON *object,const char *string,cJSON *newitem); + +/* Duplicate a cJSON item */ +CJSON_PUBLIC(cJSON *) cJSON_Duplicate(const cJSON *item, cJSON_bool recurse); +/* Duplicate will create a new, identical cJSON item to the one you pass, in new memory that will + * need to be released. With recurse!=0, it will duplicate any children connected to the item. + * The item->next and ->prev pointers are always zero on return from Duplicate. */ +/* Recursively compare two cJSON items for equality. If either a or b is NULL or invalid, they will be considered unequal. + * case_sensitive determines if object keys are treated case sensitive (1) or case insensitive (0) */ +CJSON_PUBLIC(cJSON_bool) cJSON_Compare(const cJSON * const a, const cJSON * const b, const cJSON_bool case_sensitive); + +/* Minify a strings, remove blank characters(such as ' ', '\t', '\r', '\n') from strings. + * The input pointer json cannot point to a read-only address area, such as a string constant, + * but should point to a readable and writable address area. */ +CJSON_PUBLIC(void) cJSON_Minify(char *json); + +/* Helper functions for creating and adding items to an object at the same time. + * They return the added item or NULL on failure. */ +CJSON_PUBLIC(cJSON*) cJSON_AddNullToObject(cJSON * const object, const char * const name); +CJSON_PUBLIC(cJSON*) cJSON_AddTrueToObject(cJSON * const object, const char * const name); +CJSON_PUBLIC(cJSON*) cJSON_AddFalseToObject(cJSON * const object, const char * const name); +CJSON_PUBLIC(cJSON*) cJSON_AddBoolToObject(cJSON * const object, const char * const name, const cJSON_bool boolean); +CJSON_PUBLIC(cJSON*) cJSON_AddNumberToObject(cJSON * const object, const char * const name, const double number); +CJSON_PUBLIC(cJSON*) cJSON_AddStringToObject(cJSON * const object, const char * const name, const char * const string); +CJSON_PUBLIC(cJSON*) cJSON_AddRawToObject(cJSON * const object, const char * const name, const char * const raw); +CJSON_PUBLIC(cJSON*) cJSON_AddObjectToObject(cJSON * const object, const char * const name); +CJSON_PUBLIC(cJSON*) cJSON_AddArrayToObject(cJSON * const object, const char * const name); + +/* When assigning an integer value, it needs to be propagated to valuedouble too. */ +#define cJSON_SetIntValue(object, number) ((object) ? (object)->valueint = (object)->valuedouble = (number) : (number)) +/* helper for the cJSON_SetNumberValue macro */ +CJSON_PUBLIC(double) cJSON_SetNumberHelper(cJSON *object, double number); +#define cJSON_SetNumberValue(object, number) ((object != NULL) ? cJSON_SetNumberHelper(object, (double)number) : (number)) +/* Change the valuestring of a cJSON_String object, only takes effect when type of object is cJSON_String */ +CJSON_PUBLIC(char*) cJSON_SetValuestring(cJSON *object, const char *valuestring); + +/* If the object is not a boolean type this does nothing and returns cJSON_Invalid else it returns the new type*/ +#define cJSON_SetBoolValue(object, boolValue) ( \ + (object != NULL && ((object)->type & (cJSON_False|cJSON_True))) ? \ + (object)->type=((object)->type &(~(cJSON_False|cJSON_True)))|((boolValue)?cJSON_True:cJSON_False) : \ + cJSON_Invalid\ +) + +/* Macro for iterating over an array or object */ +#define cJSON_ArrayForEach(element, array) for(element = (array != NULL) ? (array)->child : NULL; element != NULL; element = element->next) + +/* malloc/free objects using the malloc/free functions that have been set with cJSON_InitHooks */ +CJSON_PUBLIC(void *) cJSON_malloc(size_t size); +CJSON_PUBLIC(void) cJSON_free(void *object); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/tests/data/c/json/jsmn.h b/tests/data/c/json/jsmn.h new file mode 100644 index 000000000..fcb5f8dad --- /dev/null +++ b/tests/data/c/json/jsmn.h @@ -0,0 +1,472 @@ +/* + * MIT License + * + * Copyright (c) 2010 Serge Zaitsev + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +#ifndef JSMN_H +#define JSMN_H + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef JSMN_STATIC +#define JSMN_API static +#else +#define JSMN_API extern +#endif + +/** + * JSON type identifier. Basic types are: + * o Object + * o Array + * o String + * o Other primitive: number, boolean (true/false) or null + */ +typedef enum { + JSMN_UNDEFINED = 0, + JSMN_OBJECT = 1 << 0, + JSMN_ARRAY = 1 << 1, + JSMN_STRING = 1 << 2, + JSMN_PRIMITIVE = 1 << 3 +} jsmntype_t; + +enum jsmnerr { + /* Not enough tokens were provided */ + JSMN_ERROR_NOMEM = -1, + /* Invalid character inside JSON string */ + JSMN_ERROR_INVAL = -2, + /* The string is not a full JSON packet, more bytes expected */ + JSMN_ERROR_PART = -3 +}; + +/** + * JSON token description. + * type type (object, array, string etc.) + * start start position in JSON data string + * end end position in JSON data string + */ +typedef struct jsmntok { + jsmntype_t type; + int start; + int end; + int size; +#ifdef JSMN_PARENT_LINKS + int parent; +#endif +} jsmntok_t; + +/** + * JSON parser. Contains an array of token blocks available. Also stores + * the string being parsed now and current position in that string. + */ +typedef struct jsmn_parser { + unsigned int pos; /* offset in the JSON string */ + unsigned int toknext; /* next token to allocate */ + int toksuper; /* superior token node, e.g. parent object or array */ +} jsmn_parser; + +/** + * Create JSON parser over an array of tokens + */ +JSMN_API void jsmn_init(jsmn_parser *parser); + +/** + * Run JSON parser. It parses a JSON data string into and array of tokens, each + * describing + * a single JSON object. + */ +JSMN_API int jsmn_parse(jsmn_parser *parser, const char *js, const size_t len, + jsmntok_t *tokens, const unsigned int num_tokens); + +#ifndef JSMN_HEADER +/** + * Allocates a fresh unused token from the token pool. + */ +static jsmntok_t *jsmn_alloc_token(jsmn_parser *parser, jsmntok_t *tokens, + const size_t num_tokens) { + jsmntok_t *tok; + if (parser->toknext >= num_tokens) { + return NULL; + } + tok = &tokens[parser->toknext++]; + tok->start = tok->end = -1; + tok->size = 0; +#ifdef JSMN_PARENT_LINKS + tok->parent = -1; +#endif + return tok; +} + +/** + * Fills token type and boundaries. + */ +static void jsmn_fill_token(jsmntok_t *token, const jsmntype_t type, + const int start, const int end) { + token->type = type; + token->start = start; + token->end = end; + token->size = 0; +} + +/** + * Fills next available token with JSON primitive. + */ +static int jsmn_parse_primitive(jsmn_parser *parser, const char *js, + const size_t len, jsmntok_t *tokens, + const size_t num_tokens) { + jsmntok_t *token; + int start; + + start = parser->pos; + + for (; parser->pos < len && js[parser->pos] != '\0'; parser->pos++) { + switch (js[parser->pos]) { +#ifndef JSMN_STRICT + /* In strict mode primitive must be followed by "," or "}" or "]" */ + case ':': +#endif + case '\t': + case '\r': + case '\n': + case ' ': + case ',': + case ']': + case '}': + goto found; + default: + /* to quiet a warning from gcc*/ + break; + } + if (js[parser->pos] < 32 || js[parser->pos] >= 127) { + parser->pos = start; + return JSMN_ERROR_INVAL; + } + } +#ifdef JSMN_STRICT + /* In strict mode primitive must be followed by a comma/object/array */ + parser->pos = start; + return JSMN_ERROR_PART; +#endif + +found: + if (tokens == NULL) { + parser->pos--; + return 0; + } + token = jsmn_alloc_token(parser, tokens, num_tokens); + if (token == NULL) { + parser->pos = start; + return JSMN_ERROR_NOMEM; + } + jsmn_fill_token(token, JSMN_PRIMITIVE, start, parser->pos); +#ifdef JSMN_PARENT_LINKS + token->parent = parser->toksuper; +#endif + parser->pos--; + return 0; +} + +/** + * Fills next token with JSON string. + */ +static int jsmn_parse_string(jsmn_parser *parser, const char *js, + const size_t len, jsmntok_t *tokens, + const size_t num_tokens) { + jsmntok_t *token; + + int start = parser->pos; + + /* Skip starting quote */ + parser->pos++; + + for (; parser->pos < len && js[parser->pos] != '\0'; parser->pos++) { + char c = js[parser->pos]; + + /* Quote: end of string */ + if (c == '\"') { + if (tokens == NULL) { + return 0; + } + token = jsmn_alloc_token(parser, tokens, num_tokens); + if (token == NULL) { + parser->pos = start; + return JSMN_ERROR_NOMEM; + } + jsmn_fill_token(token, JSMN_STRING, start + 1, parser->pos); +#ifdef JSMN_PARENT_LINKS + token->parent = parser->toksuper; +#endif + return 0; + } + + /* Backslash: Quoted symbol expected */ + if (c == '\\' && parser->pos + 1 < len) { + int i; + parser->pos++; + switch (js[parser->pos]) { + /* Allowed escaped symbols */ + case '\"': + case '/': + case '\\': + case 'b': + case 'f': + case 'r': + case 'n': + case 't': + break; + /* Allows escaped symbol \uXXXX */ + case 'u': + parser->pos++; + for (i = 0; i < 4 && parser->pos < len && js[parser->pos] != '\0'; + i++) { + /* If it isn't a hex character we have an error */ + if (!((js[parser->pos] >= 48 && js[parser->pos] <= 57) || /* 0-9 */ + (js[parser->pos] >= 65 && js[parser->pos] <= 70) || /* A-F */ + (js[parser->pos] >= 97 && js[parser->pos] <= 102))) { /* a-f */ + parser->pos = start; + return JSMN_ERROR_INVAL; + } + parser->pos++; + } + parser->pos--; + break; + /* Unexpected symbol */ + default: + parser->pos = start; + return JSMN_ERROR_INVAL; + } + } + } + parser->pos = start; + return JSMN_ERROR_PART; +} + +/** + * Parse JSON string and fill tokens. + */ +JSMN_API int jsmn_parse(jsmn_parser *parser, const char *js, const size_t len, + jsmntok_t *tokens, const unsigned int num_tokens) { + int r; + int i; + jsmntok_t *token; + int count = parser->toknext; + + for (; parser->pos < len && js[parser->pos] != '\0'; parser->pos++) { + char c; + jsmntype_t type; + + c = js[parser->pos]; + switch (c) { + case '{': + case '[': + count++; + if (tokens == NULL) { + break; + } + token = jsmn_alloc_token(parser, tokens, num_tokens); + if (token == NULL) { + return JSMN_ERROR_NOMEM; + } + if (parser->toksuper != -1) { + jsmntok_t *t = &tokens[parser->toksuper]; +#ifdef JSMN_STRICT + /* In strict mode an object or array can't become a key */ + if (t->type == JSMN_OBJECT) { + return JSMN_ERROR_INVAL; + } +#endif + t->size++; +#ifdef JSMN_PARENT_LINKS + token->parent = parser->toksuper; +#endif + } + token->type = (c == '{' ? JSMN_OBJECT : JSMN_ARRAY); + token->start = parser->pos; + parser->toksuper = parser->toknext - 1; + break; + case '}': + case ']': + if (tokens == NULL) { + break; + } + type = (c == '}' ? JSMN_OBJECT : JSMN_ARRAY); +#ifdef JSMN_PARENT_LINKS + if (parser->toknext < 1) { + return JSMN_ERROR_INVAL; + } + token = &tokens[parser->toknext - 1]; + for (;;) { + if (token->start != -1 && token->end == -1) { + if (token->type != type) { + return JSMN_ERROR_INVAL; + } + token->end = parser->pos + 1; + parser->toksuper = token->parent; + break; + } + if (token->parent == -1) { + if (token->type != type || parser->toksuper == -1) { + return JSMN_ERROR_INVAL; + } + break; + } + token = &tokens[token->parent]; + } +#else + for (i = parser->toknext - 1; i >= 0; i--) { + token = &tokens[i]; + if (token->start != -1 && token->end == -1) { + if (token->type != type) { + return JSMN_ERROR_INVAL; + } + parser->toksuper = -1; + token->end = parser->pos + 1; + break; + } + } + /* Error if unmatched closing bracket */ + if (i == -1) { + return JSMN_ERROR_INVAL; + } + for (; i >= 0; i--) { + token = &tokens[i]; + if (token->start != -1 && token->end == -1) { + parser->toksuper = i; + break; + } + } +#endif + break; + case '\"': + r = jsmn_parse_string(parser, js, len, tokens, num_tokens); + if (r < 0) { + return r; + } + count++; + if (parser->toksuper != -1 && tokens != NULL) { + tokens[parser->toksuper].size++; + } + break; + case '\t': + case '\r': + case '\n': + case ' ': + break; + case ':': + parser->toksuper = parser->toknext - 1; + break; + case ',': + if (tokens != NULL && parser->toksuper != -1 && + tokens[parser->toksuper].type != JSMN_ARRAY && + tokens[parser->toksuper].type != JSMN_OBJECT) { +#ifdef JSMN_PARENT_LINKS + parser->toksuper = tokens[parser->toksuper].parent; +#else + for (i = parser->toknext - 1; i >= 0; i--) { + if (tokens[i].type == JSMN_ARRAY || tokens[i].type == JSMN_OBJECT) { + if (tokens[i].start != -1 && tokens[i].end == -1) { + parser->toksuper = i; + break; + } + } + } +#endif + } + break; +#ifdef JSMN_STRICT + /* In strict mode primitives are: numbers and booleans */ + case '-': + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + case 't': + case 'f': + case 'n': + /* And they must not be keys of the object */ + if (tokens != NULL && parser->toksuper != -1) { + const jsmntok_t *t = &tokens[parser->toksuper]; + if (t->type == JSMN_OBJECT || + (t->type == JSMN_STRING && t->size != 0)) { + return JSMN_ERROR_INVAL; + } + } +#else + /* In non-strict mode every unquoted value is a primitive */ + default: +#endif + r = jsmn_parse_primitive(parser, js, len, tokens, num_tokens); + if (r < 0) { + return r; + } + count++; + if (parser->toksuper != -1 && tokens != NULL) { + tokens[parser->toksuper].size++; + } + break; + +#ifdef JSMN_STRICT + /* Unexpected char in strict mode */ + default: + return JSMN_ERROR_INVAL; +#endif + } + } + + if (tokens != NULL) { + for (i = parser->toknext - 1; i >= 0; i--) { + /* Unmatched opened object or array */ + if (tokens[i].start != -1 && tokens[i].end == -1) { + return JSMN_ERROR_PART; + } + } + } + + return count; +} + +/** + * Creates a new parser based over a given buffer with an array of tokens + * available. + */ +JSMN_API void jsmn_init(jsmn_parser *parser) { + parser->pos = 0; + parser->toknext = 0; + parser->toksuper = -1; +} + +#endif /* JSMN_HEADER */ + +#ifdef __cplusplus +} +#endif + +#endif /* JSMN_H */ + diff --git a/tests/data/c/linmath/linmath.h b/tests/data/c/linmath/linmath.h new file mode 100644 index 000000000..643a942b6 --- /dev/null +++ b/tests/data/c/linmath/linmath.h @@ -0,0 +1,606 @@ +#ifndef LINMATH_H +#define LINMATH_H + +#include +#include +#include + +#ifdef LINMATH_NO_INLINE +#define LINMATH_H_FUNC static +#else +#define LINMATH_H_FUNC static inline +#endif + +#define LINMATH_H_DEFINE_VEC(n) \ +typedef float vec##n[n]; \ +LINMATH_H_FUNC void vec##n##_add(vec##n r, vec##n const a, vec##n const b) \ +{ \ + int i; \ + for(i=0; ib[i] ? a[i] : b[i]; \ +} \ +LINMATH_H_FUNC void vec##n##_dup(vec##n r, vec##n const src) \ +{ \ + int i; \ + for(i=0; i 1e-4) { + vec3_norm(u, u); + mat4x4 T; + mat4x4_from_vec3_mul_outer(T, u, u); + + mat4x4 S = { + { 0, u[2], -u[1], 0}, + {-u[2], 0, u[0], 0}, + { u[1], -u[0], 0, 0}, + { 0, 0, 0, 0} + }; + mat4x4_scale(S, S, s); + + mat4x4 C; + mat4x4_identity(C); + mat4x4_sub(C, C, T); + + mat4x4_scale(C, C, c); + + mat4x4_add(T, T, C); + mat4x4_add(T, T, S); + + T[3][3] = 1.f; + mat4x4_mul(R, M, T); + } else { + mat4x4_dup(R, M); + } +} +LINMATH_H_FUNC void mat4x4_rotate_X(mat4x4 Q, mat4x4 const M, float angle) +{ + float s = sinf(angle); + float c = cosf(angle); + mat4x4 R = { + {1.f, 0.f, 0.f, 0.f}, + {0.f, c, s, 0.f}, + {0.f, -s, c, 0.f}, + {0.f, 0.f, 0.f, 1.f} + }; + mat4x4_mul(Q, M, R); +} +LINMATH_H_FUNC void mat4x4_rotate_Y(mat4x4 Q, mat4x4 const M, float angle) +{ + float s = sinf(angle); + float c = cosf(angle); + mat4x4 R = { + { c, 0.f, -s, 0.f}, + { 0.f, 1.f, 0.f, 0.f}, + { s, 0.f, c, 0.f}, + { 0.f, 0.f, 0.f, 1.f} + }; + mat4x4_mul(Q, M, R); +} +LINMATH_H_FUNC void mat4x4_rotate_Z(mat4x4 Q, mat4x4 const M, float angle) +{ + float s = sinf(angle); + float c = cosf(angle); + mat4x4 R = { + { c, s, 0.f, 0.f}, + { -s, c, 0.f, 0.f}, + { 0.f, 0.f, 1.f, 0.f}, + { 0.f, 0.f, 0.f, 1.f} + }; + mat4x4_mul(Q, M, R); +} +LINMATH_H_FUNC void mat4x4_invert(mat4x4 T, mat4x4 const M) +{ + float s[6]; + float c[6]; + s[0] = M[0][0]*M[1][1] - M[1][0]*M[0][1]; + s[1] = M[0][0]*M[1][2] - M[1][0]*M[0][2]; + s[2] = M[0][0]*M[1][3] - M[1][0]*M[0][3]; + s[3] = M[0][1]*M[1][2] - M[1][1]*M[0][2]; + s[4] = M[0][1]*M[1][3] - M[1][1]*M[0][3]; + s[5] = M[0][2]*M[1][3] - M[1][2]*M[0][3]; + + c[0] = M[2][0]*M[3][1] - M[3][0]*M[2][1]; + c[1] = M[2][0]*M[3][2] - M[3][0]*M[2][2]; + c[2] = M[2][0]*M[3][3] - M[3][0]*M[2][3]; + c[3] = M[2][1]*M[3][2] - M[3][1]*M[2][2]; + c[4] = M[2][1]*M[3][3] - M[3][1]*M[2][3]; + c[5] = M[2][2]*M[3][3] - M[3][2]*M[2][3]; + + /* Assumes it is invertible */ + float idet = 1.0f/( s[0]*c[5]-s[1]*c[4]+s[2]*c[3]+s[3]*c[2]-s[4]*c[1]+s[5]*c[0] ); + + T[0][0] = ( M[1][1] * c[5] - M[1][2] * c[4] + M[1][3] * c[3]) * idet; + T[0][1] = (-M[0][1] * c[5] + M[0][2] * c[4] - M[0][3] * c[3]) * idet; + T[0][2] = ( M[3][1] * s[5] - M[3][2] * s[4] + M[3][3] * s[3]) * idet; + T[0][3] = (-M[2][1] * s[5] + M[2][2] * s[4] - M[2][3] * s[3]) * idet; + + T[1][0] = (-M[1][0] * c[5] + M[1][2] * c[2] - M[1][3] * c[1]) * idet; + T[1][1] = ( M[0][0] * c[5] - M[0][2] * c[2] + M[0][3] * c[1]) * idet; + T[1][2] = (-M[3][0] * s[5] + M[3][2] * s[2] - M[3][3] * s[1]) * idet; + T[1][3] = ( M[2][0] * s[5] - M[2][2] * s[2] + M[2][3] * s[1]) * idet; + + T[2][0] = ( M[1][0] * c[4] - M[1][1] * c[2] + M[1][3] * c[0]) * idet; + T[2][1] = (-M[0][0] * c[4] + M[0][1] * c[2] - M[0][3] * c[0]) * idet; + T[2][2] = ( M[3][0] * s[4] - M[3][1] * s[2] + M[3][3] * s[0]) * idet; + T[2][3] = (-M[2][0] * s[4] + M[2][1] * s[2] - M[2][3] * s[0]) * idet; + + T[3][0] = (-M[1][0] * c[3] + M[1][1] * c[1] - M[1][2] * c[0]) * idet; + T[3][1] = ( M[0][0] * c[3] - M[0][1] * c[1] + M[0][2] * c[0]) * idet; + T[3][2] = (-M[3][0] * s[3] + M[3][1] * s[1] - M[3][2] * s[0]) * idet; + T[3][3] = ( M[2][0] * s[3] - M[2][1] * s[1] + M[2][2] * s[0]) * idet; +} +LINMATH_H_FUNC void mat4x4_orthonormalize(mat4x4 R, mat4x4 const M) +{ + mat4x4_dup(R, M); + float s = 1.f; + vec3 h; + + vec3_norm(R[2], R[2]); + + s = vec3_mul_inner(R[1], R[2]); + vec3_scale(h, R[2], s); + vec3_sub(R[1], R[1], h); + vec3_norm(R[1], R[1]); + + s = vec3_mul_inner(R[0], R[2]); + vec3_scale(h, R[2], s); + vec3_sub(R[0], R[0], h); + + s = vec3_mul_inner(R[0], R[1]); + vec3_scale(h, R[1], s); + vec3_sub(R[0], R[0], h); + vec3_norm(R[0], R[0]); +} + +LINMATH_H_FUNC void mat4x4_frustum(mat4x4 M, float l, float r, float b, float t, float n, float f) +{ + M[0][0] = 2.f*n/(r-l); + M[0][1] = M[0][2] = M[0][3] = 0.f; + + M[1][1] = 2.f*n/(t-b); + M[1][0] = M[1][2] = M[1][3] = 0.f; + + M[2][0] = (r+l)/(r-l); + M[2][1] = (t+b)/(t-b); + M[2][2] = -(f+n)/(f-n); + M[2][3] = -1.f; + + M[3][2] = -2.f*(f*n)/(f-n); + M[3][0] = M[3][1] = M[3][3] = 0.f; +} +LINMATH_H_FUNC void mat4x4_ortho(mat4x4 M, float l, float r, float b, float t, float n, float f) +{ + M[0][0] = 2.f/(r-l); + M[0][1] = M[0][2] = M[0][3] = 0.f; + + M[1][1] = 2.f/(t-b); + M[1][0] = M[1][2] = M[1][3] = 0.f; + + M[2][2] = -2.f/(f-n); + M[2][0] = M[2][1] = M[2][3] = 0.f; + + M[3][0] = -(r+l)/(r-l); + M[3][1] = -(t+b)/(t-b); + M[3][2] = -(f+n)/(f-n); + M[3][3] = 1.f; +} +LINMATH_H_FUNC void mat4x4_perspective(mat4x4 m, float y_fov, float aspect, float n, float f) +{ + /* NOTE: Degrees are an unhandy unit to work with. + * linmath.h uses radians for everything! */ + float const a = 1.f / tanf(y_fov / 2.f); + + m[0][0] = a / aspect; + m[0][1] = 0.f; + m[0][2] = 0.f; + m[0][3] = 0.f; + + m[1][0] = 0.f; + m[1][1] = a; + m[1][2] = 0.f; + m[1][3] = 0.f; + + m[2][0] = 0.f; + m[2][1] = 0.f; + m[2][2] = -((f + n) / (f - n)); + m[2][3] = -1.f; + + m[3][0] = 0.f; + m[3][1] = 0.f; + m[3][2] = -((2.f * f * n) / (f - n)); + m[3][3] = 0.f; +} +LINMATH_H_FUNC void mat4x4_look_at(mat4x4 m, vec3 const eye, vec3 const center, vec3 const up) +{ + /* Adapted from Android's OpenGL Matrix.java. */ + /* See the OpenGL GLUT documentation for gluLookAt for a description */ + /* of the algorithm. We implement it in a straightforward way: */ + + /* TODO: The negation of of can be spared by swapping the order of + * operands in the following cross products in the right way. */ + vec3 f; + vec3_sub(f, center, eye); + vec3_norm(f, f); + + vec3 s; + vec3_mul_cross(s, f, up); + vec3_norm(s, s); + + vec3 t; + vec3_mul_cross(t, s, f); + + m[0][0] = s[0]; + m[0][1] = t[0]; + m[0][2] = -f[0]; + m[0][3] = 0.f; + + m[1][0] = s[1]; + m[1][1] = t[1]; + m[1][2] = -f[1]; + m[1][3] = 0.f; + + m[2][0] = s[2]; + m[2][1] = t[2]; + m[2][2] = -f[2]; + m[2][3] = 0.f; + + m[3][0] = 0.f; + m[3][1] = 0.f; + m[3][2] = 0.f; + m[3][3] = 1.f; + + mat4x4_translate_in_place(m, -eye[0], -eye[1], -eye[2]); +} + +typedef float quat[4]; +#define quat_add vec4_add +#define quat_sub vec4_sub +#define quat_norm vec4_norm +#define quat_scale vec4_scale +#define quat_mul_inner vec4_mul_inner + +LINMATH_H_FUNC void quat_identity(quat q) +{ + q[0] = q[1] = q[2] = 0.f; + q[3] = 1.f; +} +LINMATH_H_FUNC void quat_mul(quat r, quat const p, quat const q) +{ + vec3 w, tmp; + + vec3_mul_cross(tmp, p, q); + vec3_scale(w, p, q[3]); + vec3_add(tmp, tmp, w); + vec3_scale(w, q, p[3]); + vec3_add(tmp, tmp, w); + + vec3_dup(r, tmp); + r[3] = p[3]*q[3] - vec3_mul_inner(p, q); +} +LINMATH_H_FUNC void quat_conj(quat r, quat const q) +{ + int i; + for(i=0; i<3; ++i) + r[i] = -q[i]; + r[3] = q[3]; +} +LINMATH_H_FUNC void quat_rotate(quat r, float angle, vec3 const axis) { + vec3 axis_norm; + vec3_norm(axis_norm, axis); + float s = sinf(angle / 2); + float c = cosf(angle / 2); + vec3_scale(r, axis_norm, s); + r[3] = c; +} +LINMATH_H_FUNC void quat_mul_vec3(vec3 r, quat const q, vec3 const v) +{ +/* + * Method by Fabian 'ryg' Giessen (of Farbrausch) +t = 2 * cross(q.xyz, v) +v' = v + q.w * t + cross(q.xyz, t) + */ + vec3 t; + vec3 q_xyz = {q[0], q[1], q[2]}; + vec3 u = {q[0], q[1], q[2]}; + + vec3_mul_cross(t, q_xyz, v); + vec3_scale(t, t, 2); + + vec3_mul_cross(u, q_xyz, t); + vec3_scale(t, t, q[3]); + + vec3_add(r, v, t); + vec3_add(r, r, u); +} +LINMATH_H_FUNC void mat4x4_from_quat(mat4x4 M, quat const q) +{ + float a = q[3]; + float b = q[0]; + float c = q[1]; + float d = q[2]; + float a2 = a*a; + float b2 = b*b; + float c2 = c*c; + float d2 = d*d; + + M[0][0] = a2 + b2 - c2 - d2; + M[0][1] = 2.f*(b*c + a*d); + M[0][2] = 2.f*(b*d - a*c); + M[0][3] = 0.f; + + M[1][0] = 2*(b*c - a*d); + M[1][1] = a2 - b2 + c2 - d2; + M[1][2] = 2.f*(c*d + a*b); + M[1][3] = 0.f; + + M[2][0] = 2.f*(b*d + a*c); + M[2][1] = 2.f*(c*d - a*b); + M[2][2] = a2 - b2 - c2 + d2; + M[2][3] = 0.f; + + M[3][0] = M[3][1] = M[3][2] = 0.f; + M[3][3] = 1.f; +} + +LINMATH_H_FUNC void mat4x4o_mul_quat(mat4x4 R, mat4x4 const M, quat const q) +{ +/* XXX: The way this is written only works for orthogonal matrices. */ +/* TODO: Take care of non-orthogonal case. */ + quat_mul_vec3(R[0], q, M[0]); + quat_mul_vec3(R[1], q, M[1]); + quat_mul_vec3(R[2], q, M[2]); + + R[3][0] = R[3][1] = R[3][2] = 0.f; + R[0][3] = M[0][3]; + R[1][3] = M[1][3]; + R[2][3] = M[2][3]; + R[3][3] = M[3][3]; // typically 1.0, but here we make it general +} +LINMATH_H_FUNC void quat_from_mat4x4(quat q, mat4x4 const M) +{ + float r=0.f; + int i; + + int perm[] = { 0, 1, 2, 0, 1 }; + int *p = perm; + + for(i = 0; i<3; i++) { + float m = M[i][i]; + if( m < r ) + continue; + m = r; + p = &perm[i]; + } + + r = sqrtf(1.f + M[p[0]][p[0]] - M[p[1]][p[1]] - M[p[2]][p[2]] ); + + if(r < 1e-6) { + q[0] = 1.f; + q[1] = q[2] = q[3] = 0.f; + return; + } + + q[0] = r/2.f; + q[1] = (M[p[0]][p[1]] - M[p[1]][p[0]])/(2.f*r); + q[2] = (M[p[2]][p[0]] - M[p[0]][p[2]])/(2.f*r); + q[3] = (M[p[2]][p[1]] - M[p[1]][p[2]])/(2.f*r); +} + +LINMATH_H_FUNC void mat4x4_arcball(mat4x4 R, mat4x4 const M, vec2 const _a, vec2 const _b, float s) +{ + vec2 a; memcpy(a, _a, sizeof(a)); + vec2 b; memcpy(b, _b, sizeof(b)); + + float z_a = 0.; + float z_b = 0.; + + if(vec2_len(a) < 1.) { + z_a = sqrtf(1. - vec2_mul_inner(a, a)); + } else { + vec2_norm(a, a); + } + + if(vec2_len(b) < 1.) { + z_b = sqrtf(1. - vec2_mul_inner(b, b)); + } else { + vec2_norm(b, b); + } + + vec3 a_ = {a[0], a[1], z_a}; + vec3 b_ = {b[0], b[1], z_b}; + + vec3 c_; + vec3_mul_cross(c_, a_, b_); + + float const angle = acos(vec3_mul_inner(a_, b_)) * s; + mat4x4_rotate(R, M, c_[0], c_[1], c_[2], angle); +} +#endif + diff --git a/tests/data/c/nanosvg/nanosvg.h b/tests/data/c/nanosvg/nanosvg.h new file mode 100644 index 000000000..2147e9f0a --- /dev/null +++ b/tests/data/c/nanosvg/nanosvg.h @@ -0,0 +1,3278 @@ +/* + * Copyright (c) 2013-14 Mikko Mononen memon@inside.org + * + * This software is provided 'as-is', without any express or implied + * warranty. In no event will the authors be held liable for any damages + * arising from the use of this software. + * + * Permission is granted to anyone to use this software for any purpose, + * including commercial applications, and to alter it and redistribute it + * freely, subject to the following restrictions: + * + * 1. The origin of this software must not be misrepresented; you must not + * claim that you wrote the original software. If you use this software + * in a product, an acknowledgment in the product documentation would be + * appreciated but is not required. + * 2. Altered source versions must be plainly marked as such, and must not be + * misrepresented as being the original software. + * 3. This notice may not be removed or altered from any source distribution. + * + * The SVG parser is based on Anti-Grain Geometry 2.4 SVG example + * Copyright (C) 2002-2004 Maxim Shemanarev (McSeem) (http://www.antigrain.com/) + * + * Arc calculation code based on canvg (https://code.google.com/p/canvg/) + * + * Bounding box calculation based on http://blog.hackers-cafe.net/2009/06/how-to-calculate-bezier-curves-bounding.html + * + */ + +#ifndef NANOSVG_H +#define NANOSVG_H + +#ifndef NANOSVG_CPLUSPLUS +#ifdef __cplusplus +extern "C" { +#endif +#endif + +// NanoSVG is a simple stupid single-header-file SVG parse. The output of the parser is a list of cubic bezier shapes. +// +// The library suits well for anything from rendering scalable icons in your editor application to prototyping a game. +// +// NanoSVG supports a wide range of SVG features, but something may be missing, feel free to create a pull request! +// +// The shapes in the SVG images are transformed by the viewBox and converted to specified units. +// That is, you should get the same looking data as your designed in your favorite app. +// +// NanoSVG can return the paths in few different units. For example if you want to render an image, you may choose +// to get the paths in pixels, or if you are feeding the data into a CNC-cutter, you may want to use millimeters. +// +// The units passed to NanoSVG should be one of: 'px', 'pt', 'pc' 'mm', 'cm', or 'in'. +// DPI (dots-per-inch) controls how the unit conversion is done. +// +// If you don't know or care about the units stuff, "px" and 96 should get you going. + + +/* Example Usage: + // Load SVG + NSVGimage* image; + image = nsvgParseFromFile("test.svg", "px", 96); + printf("size: %f x %f\n", image->width, image->height); + // Use... + for (NSVGshape *shape = image->shapes; shape != NULL; shape = shape->next) { + for (NSVGpath *path = shape->paths; path != NULL; path = path->next) { + for (int i = 0; i < path->npts-1; i += 3) { + float* p = &path->pts[i*2]; + drawCubicBez(p[0],p[1], p[2],p[3], p[4],p[5], p[6],p[7]); + } + } + } + // Delete + nsvgDelete(image); +*/ + +enum NSVGpaintType { + NSVG_PAINT_UNDEF = -1, + NSVG_PAINT_NONE = 0, + NSVG_PAINT_COLOR = 1, + NSVG_PAINT_LINEAR_GRADIENT = 2, + NSVG_PAINT_RADIAL_GRADIENT = 3 +}; + +enum NSVGspreadType { + NSVG_SPREAD_PAD = 0, + NSVG_SPREAD_REFLECT = 1, + NSVG_SPREAD_REPEAT = 2 +}; + +enum NSVGlineJoin { + NSVG_JOIN_MITER = 0, + NSVG_JOIN_ROUND = 1, + NSVG_JOIN_BEVEL = 2 +}; + +enum NSVGlineCap { + NSVG_CAP_BUTT = 0, + NSVG_CAP_ROUND = 1, + NSVG_CAP_SQUARE = 2 +}; + +enum NSVGfillRule { + NSVG_FILLRULE_NONZERO = 0, + NSVG_FILLRULE_EVENODD = 1 +}; + +enum NSVGflags { + NSVG_FLAGS_VISIBLE = 0x01 +}; + +enum NSVGpaintOrder { + NSVG_PAINT_FILL = 0x00, + NSVG_PAINT_MARKERS = 0x01, + NSVG_PAINT_STROKE = 0x02, +}; + +typedef struct NSVGgradientStop { + unsigned int color; + float offset; +} NSVGgradientStop; + +typedef struct NSVGgradient { + float xform[6]; + char spread; + float fx, fy; + int nstops; + NSVGgradientStop stops[1]; +} NSVGgradient; + +typedef struct NSVGpaint { + signed char type; + union { + unsigned int color; + NSVGgradient* gradient; + }; +} NSVGpaint; + +typedef struct NSVGpath +{ + float* pts; // Cubic bezier points: x0,y0, [cpx1,cpx1,cpx2,cpy2,x1,y1], ... + int npts; // Total number of bezier points. + char closed; // Flag indicating if shapes should be treated as closed. + float bounds[4]; // Tight bounding box of the shape [minx,miny,maxx,maxy]. + struct NSVGpath* next; // Pointer to next path, or NULL if last element. +} NSVGpath; + +typedef struct NSVGshape +{ + char id[64]; // Optional 'id' attr of the shape or its group + NSVGpaint fill; // Fill paint + NSVGpaint stroke; // Stroke paint + float opacity; // Opacity of the shape. + float strokeWidth; // Stroke width (scaled). + float strokeDashOffset; // Stroke dash offset (scaled). + float strokeDashArray[8]; // Stroke dash array (scaled). + char strokeDashCount; // Number of dash values in dash array. + char strokeLineJoin; // Stroke join type. + char strokeLineCap; // Stroke cap type. + float miterLimit; // Miter limit + char fillRule; // Fill rule, see NSVGfillRule. + unsigned char paintOrder; // Encoded paint order (3×2-bit fields) see NSVGpaintOrder + unsigned char flags; // Logical or of NSVG_FLAGS_* flags + float bounds[4]; // Tight bounding box of the shape [minx,miny,maxx,maxy]. + char fillGradient[64]; // Optional 'id' of fill gradient + char strokeGradient[64]; // Optional 'id' of stroke gradient + float xform[6]; // Root transformation for fill/stroke gradient + NSVGpath* paths; // Linked list of paths in the image. + struct NSVGshape* next; // Pointer to next shape, or NULL if last element. +} NSVGshape; + +typedef struct NSVGimage +{ + float width; // Width of the image. + float height; // Height of the image. + NSVGshape* shapes; // Linked list of shapes in the image. +} NSVGimage; + +// Parses SVG file from a file, returns SVG image as paths. +NSVGimage* nsvgParseFromFile(const char* filename, const char* units, float dpi); + +// Parses SVG file from a null terminated string, returns SVG image as paths. +// Important note: changes the string. +NSVGimage* nsvgParse(char* input, const char* units, float dpi); + +// Duplicates a path. +NSVGpath* nsvgDuplicatePath(NSVGpath* p); + +// Deletes an image. +void nsvgDelete(NSVGimage* image); + +#ifndef NANOSVG_CPLUSPLUS +#ifdef __cplusplus +} +#endif +#endif + +#ifdef NANOSVG_IMPLEMENTATION + +#include +#include +#include +#include + +#define NSVG_PI (3.14159265358979323846264338327f) +#define NSVG_KAPPA90 (0.5522847493f) // Length proportional to radius of a cubic bezier handle for 90deg arcs. + +#define NSVG_ALIGN_MIN 0 +#define NSVG_ALIGN_MID 1 +#define NSVG_ALIGN_MAX 2 +#define NSVG_ALIGN_NONE 0 +#define NSVG_ALIGN_MEET 1 +#define NSVG_ALIGN_SLICE 2 + +#define NSVG_NOTUSED(v) do { (void)(1 ? (void)0 : ( (void)(v) ) ); } while(0) +#define NSVG_RGB(r, g, b) (((unsigned int)r) | ((unsigned int)g << 8) | ((unsigned int)b << 16)) + +#ifdef _MSC_VER + #pragma warning (disable: 4996) // Switch off security warnings + #pragma warning (disable: 4100) // Switch off unreferenced formal parameter warnings + #ifdef __cplusplus + #define NSVG_INLINE inline + #else + #define NSVG_INLINE + #endif +#else + #define NSVG_INLINE inline +#endif + + +static int nsvg__isspace(char c) +{ + return strchr(" \t\n\v\f\r", c) != 0; +} + +static int nsvg__isdigit(char c) +{ + return c >= '0' && c <= '9'; +} + +static NSVG_INLINE float nsvg__minf(float a, float b) { return a < b ? a : b; } +static NSVG_INLINE float nsvg__maxf(float a, float b) { return a > b ? a : b; } + + +// Simple XML parser + +#define NSVG_XML_TAG 1 +#define NSVG_XML_CONTENT 2 +#define NSVG_XML_MAX_ATTRIBS 256 + +static void nsvg__parseContent(char* s, + void (*contentCb)(void* ud, const char* s), + void* ud) +{ + // Trim start white spaces + while (*s && nsvg__isspace(*s)) s++; + if (!*s) return; + + if (contentCb) + (*contentCb)(ud, s); +} + +static void nsvg__parseElement(char* s, + void (*startelCb)(void* ud, const char* el, const char** attr), + void (*endelCb)(void* ud, const char* el), + void* ud) +{ + const char* attr[NSVG_XML_MAX_ATTRIBS]; + int nattr = 0; + char* name; + int start = 0; + int end = 0; + char quote; + + // Skip white space after the '<' + while (*s && nsvg__isspace(*s)) s++; + + // Check if the tag is end tag + if (*s == '/') { + s++; + end = 1; + } else { + start = 1; + } + + // Skip comments, data and preprocessor stuff. + if (!*s || *s == '?' || *s == '!') + return; + + // Get tag name + name = s; + while (*s && !nsvg__isspace(*s)) s++; + if (*s) { *s++ = '\0'; } + + // Get attribs + while (!end && *s && nattr < NSVG_XML_MAX_ATTRIBS-3) { + char* name = NULL; + char* value = NULL; + + // Skip white space before the attrib name + while (*s && nsvg__isspace(*s)) s++; + if (!*s) break; + if (*s == '/') { + end = 1; + break; + } + name = s; + // Find end of the attrib name. + while (*s && !nsvg__isspace(*s) && *s != '=') s++; + if (*s) { *s++ = '\0'; } + // Skip until the beginning of the value. + while (*s && *s != '\"' && *s != '\'') s++; + if (!*s) break; + quote = *s; + s++; + // Store value and find the end of it. + value = s; + while (*s && *s != quote) s++; + if (*s) { *s++ = '\0'; } + + // Store only well formed attributes + if (name && value) { + attr[nattr++] = name; + attr[nattr++] = value; + } + } + + // List terminator + attr[nattr++] = 0; + attr[nattr++] = 0; + + // Call callbacks. + if (start && startelCb) + (*startelCb)(ud, name, attr); + if (end && endelCb) + (*endelCb)(ud, name); +} + +int nsvg__parseXML(char* input, + void (*startelCb)(void* ud, const char* el, const char** attr), + void (*endelCb)(void* ud, const char* el), + void (*contentCb)(void* ud, const char* s), + void* ud) +{ + char* s = input; + char* mark = s; + int state = NSVG_XML_CONTENT; + while (*s) { + if (*s == '<' && state == NSVG_XML_CONTENT) { + // Start of a tag + *s++ = '\0'; + nsvg__parseContent(mark, contentCb, ud); + mark = s; + state = NSVG_XML_TAG; + } else if (*s == '>' && state == NSVG_XML_TAG) { + // Start of a content or new tag. + *s++ = '\0'; + nsvg__parseElement(mark, startelCb, endelCb, ud); + mark = s; + state = NSVG_XML_CONTENT; + } else { + s++; + } + } + + return 1; +} + + +/* Simple SVG parser. */ + +#define NSVG_MAX_ATTR 128 + +enum NSVGgradientUnits { + NSVG_USER_SPACE = 0, + NSVG_OBJECT_SPACE = 1 +}; + +#define NSVG_MAX_DASHES 8 +#define NSVG_MAX_CLASSES 32 + +enum NSVGunits { + NSVG_UNITS_USER, + NSVG_UNITS_PX, + NSVG_UNITS_PT, + NSVG_UNITS_PC, + NSVG_UNITS_MM, + NSVG_UNITS_CM, + NSVG_UNITS_IN, + NSVG_UNITS_PERCENT, + NSVG_UNITS_EM, + NSVG_UNITS_EX +}; + +typedef struct NSVGcoordinate { + float value; + int units; +} NSVGcoordinate; + +typedef struct NSVGlinearData { + NSVGcoordinate x1, y1, x2, y2; +} NSVGlinearData; + +typedef struct NSVGradialData { + NSVGcoordinate cx, cy, r, fx, fy; +} NSVGradialData; + +typedef struct NSVGgradientData +{ + char id[64]; + char ref[64]; + signed char type; + union { + NSVGlinearData linear; + NSVGradialData radial; + }; + char spread; + char units; + float xform[6]; + int nstops; + NSVGgradientStop* stops; + struct NSVGgradientData* next; +} NSVGgradientData; + +typedef struct NSVGattrib +{ + char id[64]; + float xform[6]; + unsigned int fillColor; + unsigned int strokeColor; + float opacity; + float fillOpacity; + float strokeOpacity; + char fillGradient[64]; + char strokeGradient[64]; + float strokeWidth; + float strokeDashOffset; + float strokeDashArray[NSVG_MAX_DASHES]; + int strokeDashCount; + char strokeLineJoin; + char strokeLineCap; + float miterLimit; + char fillRule; + float fontSize; + unsigned int stopColor; + float stopOpacity; + float stopOffset; + char hasFill; + char hasStroke; + char visible; + unsigned char paintOrder; +} NSVGattrib; + +typedef struct NSVGstyleDeclaration +{ + char* className; + char* propertiesText; + struct NSVGstyleDeclaration* next; +} NSVGstyleDeclaration; + +typedef struct NSVGparser +{ + NSVGattrib attr[NSVG_MAX_ATTR]; + int attrHead; + float* pts; + int npts; + int cpts; + NSVGpath* plist; + NSVGimage* image; + NSVGstyleDeclaration* styles; + NSVGgradientData* gradients; + NSVGshape* shapesTail; + float viewMinx, viewMiny, viewWidth, viewHeight; + int alignX, alignY, alignType; + float dpi; + char pathFlag; + char defsFlag; + char styleFlag; +} NSVGparser; + +static void nsvg__xformIdentity(float* t) +{ + t[0] = 1.0f; t[1] = 0.0f; + t[2] = 0.0f; t[3] = 1.0f; + t[4] = 0.0f; t[5] = 0.0f; +} + +static void nsvg__xformSetTranslation(float* t, float tx, float ty) +{ + t[0] = 1.0f; t[1] = 0.0f; + t[2] = 0.0f; t[3] = 1.0f; + t[4] = tx; t[5] = ty; +} + +static void nsvg__xformSetScale(float* t, float sx, float sy) +{ + t[0] = sx; t[1] = 0.0f; + t[2] = 0.0f; t[3] = sy; + t[4] = 0.0f; t[5] = 0.0f; +} + +static void nsvg__xformSetSkewX(float* t, float a) +{ + t[0] = 1.0f; t[1] = 0.0f; + t[2] = tanf(a); t[3] = 1.0f; + t[4] = 0.0f; t[5] = 0.0f; +} + +static void nsvg__xformSetSkewY(float* t, float a) +{ + t[0] = 1.0f; t[1] = tanf(a); + t[2] = 0.0f; t[3] = 1.0f; + t[4] = 0.0f; t[5] = 0.0f; +} + +static void nsvg__xformSetRotation(float* t, float a) +{ + float cs = cosf(a), sn = sinf(a); + t[0] = cs; t[1] = sn; + t[2] = -sn; t[3] = cs; + t[4] = 0.0f; t[5] = 0.0f; +} + +static void nsvg__xformMultiply(float* t, float* s) +{ + float t0 = t[0] * s[0] + t[1] * s[2]; + float t2 = t[2] * s[0] + t[3] * s[2]; + float t4 = t[4] * s[0] + t[5] * s[2] + s[4]; + t[1] = t[0] * s[1] + t[1] * s[3]; + t[3] = t[2] * s[1] + t[3] * s[3]; + t[5] = t[4] * s[1] + t[5] * s[3] + s[5]; + t[0] = t0; + t[2] = t2; + t[4] = t4; +} + +static void nsvg__xformInverse(float* inv, float* t) +{ + double invdet, det = (double)t[0] * t[3] - (double)t[2] * t[1]; + if (det > -1e-6 && det < 1e-6) { + nsvg__xformIdentity(t); + return; + } + invdet = 1.0 / det; + inv[0] = (float)(t[3] * invdet); + inv[2] = (float)(-t[2] * invdet); + inv[4] = (float)(((double)t[2] * t[5] - (double)t[3] * t[4]) * invdet); + inv[1] = (float)(-t[1] * invdet); + inv[3] = (float)(t[0] * invdet); + inv[5] = (float)(((double)t[1] * t[4] - (double)t[0] * t[5]) * invdet); +} + +static void nsvg__xformPremultiply(float* t, float* s) +{ + float s2[6]; + memcpy(s2, s, sizeof(float)*6); + nsvg__xformMultiply(s2, t); + memcpy(t, s2, sizeof(float)*6); +} + +static void nsvg__xformPoint(float* dx, float* dy, float x, float y, float* t) +{ + *dx = x*t[0] + y*t[2] + t[4]; + *dy = x*t[1] + y*t[3] + t[5]; +} + +static void nsvg__xformVec(float* dx, float* dy, float x, float y, float* t) +{ + *dx = x*t[0] + y*t[2]; + *dy = x*t[1] + y*t[3]; +} + +#define NSVG_EPSILON (1e-12) + +static int nsvg__ptInBounds(float* pt, float* bounds) +{ + return pt[0] >= bounds[0] && pt[0] <= bounds[2] && pt[1] >= bounds[1] && pt[1] <= bounds[3]; +} + + +static double nsvg__evalBezier(double t, double p0, double p1, double p2, double p3) +{ + double it = 1.0-t; + return it*it*it*p0 + 3.0*it*it*t*p1 + 3.0*it*t*t*p2 + t*t*t*p3; +} + +static void nsvg__curveBounds(float* bounds, float* curve) +{ + int i, j, count; + double roots[2], a, b, c, b2ac, t, v; + float* v0 = &curve[0]; + float* v1 = &curve[2]; + float* v2 = &curve[4]; + float* v3 = &curve[6]; + + // Start the bounding box by end points + bounds[0] = nsvg__minf(v0[0], v3[0]); + bounds[1] = nsvg__minf(v0[1], v3[1]); + bounds[2] = nsvg__maxf(v0[0], v3[0]); + bounds[3] = nsvg__maxf(v0[1], v3[1]); + + // Bezier curve fits inside the convex hull of it's control points. + // If control points are inside the bounds, we're done. + if (nsvg__ptInBounds(v1, bounds) && nsvg__ptInBounds(v2, bounds)) + return; + + // Add bezier curve inflection points in X and Y. + for (i = 0; i < 2; i++) { + a = -3.0 * v0[i] + 9.0 * v1[i] - 9.0 * v2[i] + 3.0 * v3[i]; + b = 6.0 * v0[i] - 12.0 * v1[i] + 6.0 * v2[i]; + c = 3.0 * v1[i] - 3.0 * v0[i]; + count = 0; + if (fabs(a) < NSVG_EPSILON) { + if (fabs(b) > NSVG_EPSILON) { + t = -c / b; + if (t > NSVG_EPSILON && t < 1.0-NSVG_EPSILON) + roots[count++] = t; + } + } else { + b2ac = b*b - 4.0*c*a; + if (b2ac > NSVG_EPSILON) { + t = (-b + sqrt(b2ac)) / (2.0 * a); + if (t > NSVG_EPSILON && t < 1.0-NSVG_EPSILON) + roots[count++] = t; + t = (-b - sqrt(b2ac)) / (2.0 * a); + if (t > NSVG_EPSILON && t < 1.0-NSVG_EPSILON) + roots[count++] = t; + } + } + for (j = 0; j < count; j++) { + v = nsvg__evalBezier(roots[j], v0[i], v1[i], v2[i], v3[i]); + bounds[0+i] = nsvg__minf(bounds[0+i], (float)v); + bounds[2+i] = nsvg__maxf(bounds[2+i], (float)v); + } + } +} + +static unsigned char nsvg__encodePaintOrder(enum NSVGpaintOrder a, enum NSVGpaintOrder b, enum NSVGpaintOrder c) { + return (a & 0x03) | ((b & 0x03) << 2) | ((c & 0x03) << 4); +} + +static NSVGparser* nsvg__createParser(void) +{ + NSVGparser* p; + p = (NSVGparser*)malloc(sizeof(NSVGparser)); + if (p == NULL) goto error; + memset(p, 0, sizeof(NSVGparser)); + + p->image = (NSVGimage*)malloc(sizeof(NSVGimage)); + if (p->image == NULL) goto error; + memset(p->image, 0, sizeof(NSVGimage)); + + // Init style + nsvg__xformIdentity(p->attr[0].xform); + memset(p->attr[0].id, 0, sizeof p->attr[0].id); + p->attr[0].fillColor = NSVG_RGB(0,0,0); + p->attr[0].strokeColor = NSVG_RGB(0,0,0); + p->attr[0].opacity = 1; + p->attr[0].fillOpacity = 1; + p->attr[0].strokeOpacity = 1; + p->attr[0].stopOpacity = 1; + p->attr[0].strokeWidth = 1; + p->attr[0].strokeLineJoin = NSVG_JOIN_MITER; + p->attr[0].strokeLineCap = NSVG_CAP_BUTT; + p->attr[0].miterLimit = 4; + p->attr[0].fillRule = NSVG_FILLRULE_NONZERO; + p->attr[0].hasFill = 1; + p->attr[0].visible = 1; + p->attr[0].paintOrder = nsvg__encodePaintOrder(NSVG_PAINT_FILL, NSVG_PAINT_STROKE, NSVG_PAINT_MARKERS); + + return p; + +error: + if (p) { + if (p->image) free(p->image); + free(p); + } + return NULL; +} +static void nsvg__deleteStyles(NSVGstyleDeclaration* style) { + while (style) { + NSVGstyleDeclaration* next = style->next; + free(style->className); + free(style->propertiesText); + free(style); + style = next; + } +} + +static void nsvg__deletePaths(NSVGpath* path) +{ + while (path) { + NSVGpath *next = path->next; + if (path->pts != NULL) + free(path->pts); + free(path); + path = next; + } +} + +static void nsvg__deletePaint(NSVGpaint* paint) +{ + if (paint->type == NSVG_PAINT_LINEAR_GRADIENT || paint->type == NSVG_PAINT_RADIAL_GRADIENT) + free(paint->gradient); +} + +static void nsvg__deleteGradientData(NSVGgradientData* grad) +{ + NSVGgradientData* next; + while (grad != NULL) { + next = grad->next; + free(grad->stops); + free(grad); + grad = next; + } +} + +static void nsvg__deleteParser(NSVGparser* p) +{ + if (p != NULL) { + nsvg__deleteStyles(p->styles); + nsvg__deletePaths(p->plist); + nsvg__deleteGradientData(p->gradients); + nsvgDelete(p->image); + free(p->pts); + free(p); + } +} + +static void nsvg__resetPath(NSVGparser* p) +{ + p->npts = 0; +} + +static void nsvg__addPoint(NSVGparser* p, float x, float y) +{ + if (p->npts+1 > p->cpts) { + p->cpts = p->cpts ? p->cpts*2 : 8; + p->pts = (float*)realloc(p->pts, p->cpts*2*sizeof(float)); + if (!p->pts) return; + } + p->pts[p->npts*2+0] = x; + p->pts[p->npts*2+1] = y; + p->npts++; +} + +static void nsvg__moveTo(NSVGparser* p, float x, float y) +{ + if (p->npts > 0) { + p->pts[(p->npts-1)*2+0] = x; + p->pts[(p->npts-1)*2+1] = y; + } else { + nsvg__addPoint(p, x, y); + } +} + +static void nsvg__lineTo(NSVGparser* p, float x, float y) +{ + float px,py, dx,dy; + if (p->npts > 0) { + px = p->pts[(p->npts-1)*2+0]; + py = p->pts[(p->npts-1)*2+1]; + dx = x - px; + dy = y - py; + nsvg__addPoint(p, px + dx/3.0f, py + dy/3.0f); + nsvg__addPoint(p, x - dx/3.0f, y - dy/3.0f); + nsvg__addPoint(p, x, y); + } +} + +static void nsvg__cubicBezTo(NSVGparser* p, float cpx1, float cpy1, float cpx2, float cpy2, float x, float y) +{ + if (p->npts > 0) { + nsvg__addPoint(p, cpx1, cpy1); + nsvg__addPoint(p, cpx2, cpy2); + nsvg__addPoint(p, x, y); + } +} + +static NSVGattrib* nsvg__getAttr(NSVGparser* p) +{ + return &p->attr[p->attrHead]; +} + +static void nsvg__pushAttr(NSVGparser* p) +{ + if (p->attrHead < NSVG_MAX_ATTR-1) { + p->attrHead++; + memcpy(&p->attr[p->attrHead], &p->attr[p->attrHead-1], sizeof(NSVGattrib)); + } +} + +static void nsvg__popAttr(NSVGparser* p) +{ + if (p->attrHead > 0) + p->attrHead--; +} + +static float nsvg__actualOrigX(NSVGparser* p) +{ + return p->viewMinx; +} + +static float nsvg__actualOrigY(NSVGparser* p) +{ + return p->viewMiny; +} + +static float nsvg__actualWidth(NSVGparser* p) +{ + return p->viewWidth; +} + +static float nsvg__actualHeight(NSVGparser* p) +{ + return p->viewHeight; +} + +static float nsvg__actualLength(NSVGparser* p) +{ + float w = nsvg__actualWidth(p), h = nsvg__actualHeight(p); + return sqrtf(w*w + h*h) / sqrtf(2.0f); +} + +static float nsvg__convertToPixels(NSVGparser* p, NSVGcoordinate c, float orig, float length) +{ + NSVGattrib* attr = nsvg__getAttr(p); + switch (c.units) { + case NSVG_UNITS_USER: return c.value; + case NSVG_UNITS_PX: return c.value; + case NSVG_UNITS_PT: return c.value / 72.0f * p->dpi; + case NSVG_UNITS_PC: return c.value / 6.0f * p->dpi; + case NSVG_UNITS_MM: return c.value / 25.4f * p->dpi; + case NSVG_UNITS_CM: return c.value / 2.54f * p->dpi; + case NSVG_UNITS_IN: return c.value * p->dpi; + case NSVG_UNITS_EM: return c.value * attr->fontSize; + case NSVG_UNITS_EX: return c.value * attr->fontSize * 0.52f; // x-height of Helvetica. + case NSVG_UNITS_PERCENT: return orig + c.value / 100.0f * length; + default: return c.value; + } + return c.value; +} + +static NSVGgradientData* nsvg__findGradientData(NSVGparser* p, const char* id) +{ + NSVGgradientData* grad = p->gradients; + if (id == NULL || *id == '\0') + return NULL; + while (grad != NULL) { + if (strcmp(grad->id, id) == 0) + return grad; + grad = grad->next; + } + return NULL; +} + +static NSVGgradient* nsvg__createGradient(NSVGparser* p, const char* id, const float* localBounds, float *xform, signed char* paintType) +{ + NSVGgradientData* data = NULL; + NSVGgradientData* ref = NULL; + NSVGgradientStop* stops = NULL; + NSVGgradient* grad; + float ox, oy, sw, sh, sl; + int nstops = 0; + int refIter; + + data = nsvg__findGradientData(p, id); + if (data == NULL) return NULL; + + // TODO: use ref to fill in all unset values too. + ref = data; + refIter = 0; + while (ref != NULL) { + NSVGgradientData* nextRef = NULL; + if (stops == NULL && ref->stops != NULL) { + stops = ref->stops; + nstops = ref->nstops; + break; + } + nextRef = nsvg__findGradientData(p, ref->ref); + if (nextRef == ref) break; // prevent infite loops on malformed data + ref = nextRef; + refIter++; + if (refIter > 32) break; // prevent infite loops on malformed data + } + if (stops == NULL) return NULL; + + grad = (NSVGgradient*)malloc(sizeof(NSVGgradient) + sizeof(NSVGgradientStop)*(nstops-1)); + if (grad == NULL) return NULL; + + // The shape width and height. + if (data->units == NSVG_OBJECT_SPACE) { + ox = localBounds[0]; + oy = localBounds[1]; + sw = localBounds[2] - localBounds[0]; + sh = localBounds[3] - localBounds[1]; + } else { + ox = nsvg__actualOrigX(p); + oy = nsvg__actualOrigY(p); + sw = nsvg__actualWidth(p); + sh = nsvg__actualHeight(p); + } + sl = sqrtf(sw*sw + sh*sh) / sqrtf(2.0f); + + if (data->type == NSVG_PAINT_LINEAR_GRADIENT) { + float x1, y1, x2, y2, dx, dy; + x1 = nsvg__convertToPixels(p, data->linear.x1, ox, sw); + y1 = nsvg__convertToPixels(p, data->linear.y1, oy, sh); + x2 = nsvg__convertToPixels(p, data->linear.x2, ox, sw); + y2 = nsvg__convertToPixels(p, data->linear.y2, oy, sh); + // Calculate transform aligned to the line + dx = x2 - x1; + dy = y2 - y1; + grad->xform[0] = dy; grad->xform[1] = -dx; + grad->xform[2] = dx; grad->xform[3] = dy; + grad->xform[4] = x1; grad->xform[5] = y1; + } else { + float cx, cy, fx, fy, r; + cx = nsvg__convertToPixels(p, data->radial.cx, ox, sw); + cy = nsvg__convertToPixels(p, data->radial.cy, oy, sh); + fx = nsvg__convertToPixels(p, data->radial.fx, ox, sw); + fy = nsvg__convertToPixels(p, data->radial.fy, oy, sh); + r = nsvg__convertToPixels(p, data->radial.r, 0, sl); + // Calculate transform aligned to the circle + grad->xform[0] = r; grad->xform[1] = 0; + grad->xform[2] = 0; grad->xform[3] = r; + grad->xform[4] = cx; grad->xform[5] = cy; + grad->fx = fx / r; + grad->fy = fy / r; + } + + nsvg__xformMultiply(grad->xform, data->xform); + nsvg__xformMultiply(grad->xform, xform); + + grad->spread = data->spread; + memcpy(grad->stops, stops, nstops*sizeof(NSVGgradientStop)); + grad->nstops = nstops; + + *paintType = data->type; + + return grad; +} + +static float nsvg__getAverageScale(float* t) +{ + float sx = sqrtf(t[0]*t[0] + t[2]*t[2]); + float sy = sqrtf(t[1]*t[1] + t[3]*t[3]); + return (sx + sy) * 0.5f; +} + +static void nsvg__getLocalBounds(float* bounds, NSVGshape *shape, float* xform) +{ + NSVGpath* path; + float curve[4*2], curveBounds[4]; + int i, first = 1; + for (path = shape->paths; path != NULL; path = path->next) { + nsvg__xformPoint(&curve[0], &curve[1], path->pts[0], path->pts[1], xform); + for (i = 0; i < path->npts-1; i += 3) { + nsvg__xformPoint(&curve[2], &curve[3], path->pts[(i+1)*2], path->pts[(i+1)*2+1], xform); + nsvg__xformPoint(&curve[4], &curve[5], path->pts[(i+2)*2], path->pts[(i+2)*2+1], xform); + nsvg__xformPoint(&curve[6], &curve[7], path->pts[(i+3)*2], path->pts[(i+3)*2+1], xform); + nsvg__curveBounds(curveBounds, curve); + if (first) { + bounds[0] = curveBounds[0]; + bounds[1] = curveBounds[1]; + bounds[2] = curveBounds[2]; + bounds[3] = curveBounds[3]; + first = 0; + } else { + bounds[0] = nsvg__minf(bounds[0], curveBounds[0]); + bounds[1] = nsvg__minf(bounds[1], curveBounds[1]); + bounds[2] = nsvg__maxf(bounds[2], curveBounds[2]); + bounds[3] = nsvg__maxf(bounds[3], curveBounds[3]); + } + curve[0] = curve[6]; + curve[1] = curve[7]; + } + } +} + +static void nsvg__addShape(NSVGparser* p) +{ + NSVGattrib* attr = nsvg__getAttr(p); + float scale = 1.0f; + NSVGshape* shape; + NSVGpath* path; + int i; + + if (p->plist == NULL) + return; + + shape = (NSVGshape*)malloc(sizeof(NSVGshape)); + if (shape == NULL) goto error; + memset(shape, 0, sizeof(NSVGshape)); + + memcpy(shape->id, attr->id, sizeof shape->id); + memcpy(shape->fillGradient, attr->fillGradient, sizeof shape->fillGradient); + memcpy(shape->strokeGradient, attr->strokeGradient, sizeof shape->strokeGradient); + memcpy(shape->xform, attr->xform, sizeof shape->xform); + scale = nsvg__getAverageScale(attr->xform); + shape->strokeWidth = attr->strokeWidth * scale; + shape->strokeDashOffset = attr->strokeDashOffset * scale; + shape->strokeDashCount = (char)attr->strokeDashCount; + for (i = 0; i < attr->strokeDashCount; i++) + shape->strokeDashArray[i] = attr->strokeDashArray[i] * scale; + shape->strokeLineJoin = attr->strokeLineJoin; + shape->strokeLineCap = attr->strokeLineCap; + shape->miterLimit = attr->miterLimit; + shape->fillRule = attr->fillRule; + shape->opacity = attr->opacity; + shape->paintOrder = attr->paintOrder; + + shape->paths = p->plist; + p->plist = NULL; + + // Calculate shape bounds + shape->bounds[0] = shape->paths->bounds[0]; + shape->bounds[1] = shape->paths->bounds[1]; + shape->bounds[2] = shape->paths->bounds[2]; + shape->bounds[3] = shape->paths->bounds[3]; + for (path = shape->paths->next; path != NULL; path = path->next) { + shape->bounds[0] = nsvg__minf(shape->bounds[0], path->bounds[0]); + shape->bounds[1] = nsvg__minf(shape->bounds[1], path->bounds[1]); + shape->bounds[2] = nsvg__maxf(shape->bounds[2], path->bounds[2]); + shape->bounds[3] = nsvg__maxf(shape->bounds[3], path->bounds[3]); + } + + // Set fill + if (attr->hasFill == 0) { + shape->fill.type = NSVG_PAINT_NONE; + } else if (attr->hasFill == 1) { + shape->fill.type = NSVG_PAINT_COLOR; + shape->fill.color = attr->fillColor; + shape->fill.color |= (unsigned int)(attr->fillOpacity*255) << 24; + } else if (attr->hasFill == 2) { + shape->fill.type = NSVG_PAINT_UNDEF; + } + + // Set stroke + if (attr->hasStroke == 0) { + shape->stroke.type = NSVG_PAINT_NONE; + } else if (attr->hasStroke == 1) { + shape->stroke.type = NSVG_PAINT_COLOR; + shape->stroke.color = attr->strokeColor; + shape->stroke.color |= (unsigned int)(attr->strokeOpacity*255) << 24; + } else if (attr->hasStroke == 2) { + shape->stroke.type = NSVG_PAINT_UNDEF; + } + + // Set flags + shape->flags = (attr->visible ? NSVG_FLAGS_VISIBLE : 0x00); + + // Add to tail + if (p->image->shapes == NULL) + p->image->shapes = shape; + else + p->shapesTail->next = shape; + p->shapesTail = shape; + + return; + +error: + if (shape) free(shape); +} + +static void nsvg__addPath(NSVGparser* p, char closed) +{ + NSVGattrib* attr = nsvg__getAttr(p); + NSVGpath* path = NULL; + float bounds[4]; + float* curve; + int i; + + if (p->npts < 4) + return; + + if (closed) + nsvg__lineTo(p, p->pts[0], p->pts[1]); + + // Expect 1 + N*3 points (N = number of cubic bezier segments). + if ((p->npts % 3) != 1) + return; + + path = (NSVGpath*)malloc(sizeof(NSVGpath)); + if (path == NULL) goto error; + memset(path, 0, sizeof(NSVGpath)); + + path->pts = (float*)malloc(p->npts*2*sizeof(float)); + if (path->pts == NULL) goto error; + path->closed = closed; + path->npts = p->npts; + + // Transform path. + for (i = 0; i < p->npts; ++i) + nsvg__xformPoint(&path->pts[i*2], &path->pts[i*2+1], p->pts[i*2], p->pts[i*2+1], attr->xform); + + // Find bounds + for (i = 0; i < path->npts-1; i += 3) { + curve = &path->pts[i*2]; + nsvg__curveBounds(bounds, curve); + if (i == 0) { + path->bounds[0] = bounds[0]; + path->bounds[1] = bounds[1]; + path->bounds[2] = bounds[2]; + path->bounds[3] = bounds[3]; + } else { + path->bounds[0] = nsvg__minf(path->bounds[0], bounds[0]); + path->bounds[1] = nsvg__minf(path->bounds[1], bounds[1]); + path->bounds[2] = nsvg__maxf(path->bounds[2], bounds[2]); + path->bounds[3] = nsvg__maxf(path->bounds[3], bounds[3]); + } + } + + path->next = p->plist; + p->plist = path; + + return; + +error: + if (path != NULL) { + if (path->pts != NULL) free(path->pts); + free(path); + } +} + +// We roll our own string to float because the std library one uses locale and messes things up. +static double nsvg__atof(const char* s) +{ + char* cur = (char*)s; + char* end = NULL; + double res = 0.0, sign = 1.0; + long long intPart = 0, fracPart = 0; + char hasIntPart = 0, hasFracPart = 0; + + // Parse optional sign + if (*cur == '+') { + cur++; + } else if (*cur == '-') { + sign = -1; + cur++; + } + + // Parse integer part + if (nsvg__isdigit(*cur)) { + // Parse digit sequence + intPart = strtoll(cur, &end, 10); + if (cur != end) { + res = (double)intPart; + hasIntPart = 1; + cur = end; + } + } + + // Parse fractional part. + if (*cur == '.') { + cur++; // Skip '.' + if (nsvg__isdigit(*cur)) { + // Parse digit sequence + fracPart = strtoll(cur, &end, 10); + if (cur != end) { + res += (double)fracPart / pow(10.0, (double)(end - cur)); + hasFracPart = 1; + cur = end; + } + } + } + + // A valid number should have integer or fractional part. + if (!hasIntPart && !hasFracPart) + return 0.0; + + // Parse optional exponent + if (*cur == 'e' || *cur == 'E') { + long expPart = 0; + cur++; // skip 'E' + expPart = strtol(cur, &end, 10); // Parse digit sequence with sign + if (cur != end) { + res *= pow(10.0, (double)expPart); + } + } + + return res * sign; +} + + +static const char* nsvg__parseNumber(const char* s, char* it, const int size) +{ + const int last = size-1; + int i = 0; + + // sign + if (*s == '-' || *s == '+') { + if (i < last) it[i++] = *s; + s++; + } + // integer part + while (*s && nsvg__isdigit(*s)) { + if (i < last) it[i++] = *s; + s++; + } + if (*s == '.') { + // decimal point + if (i < last) it[i++] = *s; + s++; + // fraction part + while (*s && nsvg__isdigit(*s)) { + if (i < last) it[i++] = *s; + s++; + } + } + // exponent + if ((*s == 'e' || *s == 'E') && (s[1] != 'm' && s[1] != 'x')) { + if (i < last) it[i++] = *s; + s++; + if (*s == '-' || *s == '+') { + if (i < last) it[i++] = *s; + s++; + } + while (*s && nsvg__isdigit(*s)) { + if (i < last) it[i++] = *s; + s++; + } + } + it[i] = '\0'; + + return s; +} + +static const char* nsvg__getNextPathItemWhenArcFlag(const char* s, char* it) +{ + it[0] = '\0'; + while (*s && (nsvg__isspace(*s) || *s == ',')) s++; + if (!*s) return s; + if (*s == '0' || *s == '1') { + it[0] = *s++; + it[1] = '\0'; + return s; + } + return s; +} + +static const char* nsvg__getNextPathItem(const char* s, char* it) +{ + it[0] = '\0'; + // Skip white spaces and commas + while (*s && (nsvg__isspace(*s) || *s == ',')) s++; + if (!*s) return s; + if (*s == '-' || *s == '+' || *s == '.' || nsvg__isdigit(*s)) { + s = nsvg__parseNumber(s, it, 64); + } else { + // Parse command + it[0] = *s++; + it[1] = '\0'; + return s; + } + + return s; +} + +static unsigned int nsvg__parseColorHex(const char* str) +{ + unsigned int r=0, g=0, b=0; + if (sscanf(str, "#%2x%2x%2x", &r, &g, &b) == 3 ) // 2 digit hex + return NSVG_RGB(r, g, b); + if (sscanf(str, "#%1x%1x%1x", &r, &g, &b) == 3 ) // 1 digit hex, e.g. #abc -> 0xccbbaa + return NSVG_RGB(r*17, g*17, b*17); // same effect as (r<<4|r), (g<<4|g), .. + return NSVG_RGB(128, 128, 128); +} + +// Parse rgb color. The pointer 'str' must point at "rgb(" (4+ characters). +// This function returns gray (rgb(128, 128, 128) == '#808080') on parse errors +// for backwards compatibility. Note: other image viewers return black instead. + +static unsigned int nsvg__parseColorRGB(const char* str) +{ + int i; + unsigned int rgbi[3]; + float rgbf[3]; + // try decimal integers first + if (sscanf(str, "rgb(%u, %u, %u)", &rgbi[0], &rgbi[1], &rgbi[2]) != 3) { + // integers failed, try percent values (float, locale independent) + const char delimiter[3] = {',', ',', ')'}; + str += 4; // skip "rgb(" + for (i = 0; i < 3; i++) { + while (*str && (nsvg__isspace(*str))) str++; // skip leading spaces + if (*str == '+') str++; // skip '+' (don't allow '-') + if (!*str) break; + rgbf[i] = nsvg__atof(str); + + // Note 1: it would be great if nsvg__atof() returned how many + // bytes it consumed but it doesn't. We need to skip the number, + // the '%' character, spaces, and the delimiter ',' or ')'. + + // Note 2: The following code does not allow values like "33.%", + // i.e. a decimal point w/o fractional part, but this is consistent + // with other image viewers, e.g. firefox, chrome, eog, gimp. + + while (*str && nsvg__isdigit(*str)) str++; // skip integer part + if (*str == '.') { + str++; + if (!nsvg__isdigit(*str)) break; // error: no digit after '.' + while (*str && nsvg__isdigit(*str)) str++; // skip fractional part + } + if (*str == '%') str++; else break; + while (*str && nsvg__isspace(*str)) str++; + if (*str == delimiter[i]) str++; + else break; + } + if (i == 3) { + rgbi[0] = roundf(rgbf[0] * 2.55f); + rgbi[1] = roundf(rgbf[1] * 2.55f); + rgbi[2] = roundf(rgbf[2] * 2.55f); + } else { + rgbi[0] = rgbi[1] = rgbi[2] = 128; + } + } + // clip values as the CSS spec requires + for (i = 0; i < 3; i++) { + if (rgbi[i] > 255) rgbi[i] = 255; + } + return NSVG_RGB(rgbi[0], rgbi[1], rgbi[2]); +} + +typedef struct NSVGNamedColor { + const char* name; + unsigned int color; +} NSVGNamedColor; + +NSVGNamedColor nsvg__colors[] = { + + { "red", NSVG_RGB(255, 0, 0) }, + { "green", NSVG_RGB( 0, 128, 0) }, + { "blue", NSVG_RGB( 0, 0, 255) }, + { "yellow", NSVG_RGB(255, 255, 0) }, + { "cyan", NSVG_RGB( 0, 255, 255) }, + { "magenta", NSVG_RGB(255, 0, 255) }, + { "black", NSVG_RGB( 0, 0, 0) }, + { "grey", NSVG_RGB(128, 128, 128) }, + { "gray", NSVG_RGB(128, 128, 128) }, + { "white", NSVG_RGB(255, 255, 255) }, + +#ifdef NANOSVG_ALL_COLOR_KEYWORDS + { "aliceblue", NSVG_RGB(240, 248, 255) }, + { "antiquewhite", NSVG_RGB(250, 235, 215) }, + { "aqua", NSVG_RGB( 0, 255, 255) }, + { "aquamarine", NSVG_RGB(127, 255, 212) }, + { "azure", NSVG_RGB(240, 255, 255) }, + { "beige", NSVG_RGB(245, 245, 220) }, + { "bisque", NSVG_RGB(255, 228, 196) }, + { "blanchedalmond", NSVG_RGB(255, 235, 205) }, + { "blueviolet", NSVG_RGB(138, 43, 226) }, + { "brown", NSVG_RGB(165, 42, 42) }, + { "burlywood", NSVG_RGB(222, 184, 135) }, + { "cadetblue", NSVG_RGB( 95, 158, 160) }, + { "chartreuse", NSVG_RGB(127, 255, 0) }, + { "chocolate", NSVG_RGB(210, 105, 30) }, + { "coral", NSVG_RGB(255, 127, 80) }, + { "cornflowerblue", NSVG_RGB(100, 149, 237) }, + { "cornsilk", NSVG_RGB(255, 248, 220) }, + { "crimson", NSVG_RGB(220, 20, 60) }, + { "darkblue", NSVG_RGB( 0, 0, 139) }, + { "darkcyan", NSVG_RGB( 0, 139, 139) }, + { "darkgoldenrod", NSVG_RGB(184, 134, 11) }, + { "darkgray", NSVG_RGB(169, 169, 169) }, + { "darkgreen", NSVG_RGB( 0, 100, 0) }, + { "darkgrey", NSVG_RGB(169, 169, 169) }, + { "darkkhaki", NSVG_RGB(189, 183, 107) }, + { "darkmagenta", NSVG_RGB(139, 0, 139) }, + { "darkolivegreen", NSVG_RGB( 85, 107, 47) }, + { "darkorange", NSVG_RGB(255, 140, 0) }, + { "darkorchid", NSVG_RGB(153, 50, 204) }, + { "darkred", NSVG_RGB(139, 0, 0) }, + { "darksalmon", NSVG_RGB(233, 150, 122) }, + { "darkseagreen", NSVG_RGB(143, 188, 143) }, + { "darkslateblue", NSVG_RGB( 72, 61, 139) }, + { "darkslategray", NSVG_RGB( 47, 79, 79) }, + { "darkslategrey", NSVG_RGB( 47, 79, 79) }, + { "darkturquoise", NSVG_RGB( 0, 206, 209) }, + { "darkviolet", NSVG_RGB(148, 0, 211) }, + { "deeppink", NSVG_RGB(255, 20, 147) }, + { "deepskyblue", NSVG_RGB( 0, 191, 255) }, + { "dimgray", NSVG_RGB(105, 105, 105) }, + { "dimgrey", NSVG_RGB(105, 105, 105) }, + { "dodgerblue", NSVG_RGB( 30, 144, 255) }, + { "firebrick", NSVG_RGB(178, 34, 34) }, + { "floralwhite", NSVG_RGB(255, 250, 240) }, + { "forestgreen", NSVG_RGB( 34, 139, 34) }, + { "fuchsia", NSVG_RGB(255, 0, 255) }, + { "gainsboro", NSVG_RGB(220, 220, 220) }, + { "ghostwhite", NSVG_RGB(248, 248, 255) }, + { "gold", NSVG_RGB(255, 215, 0) }, + { "goldenrod", NSVG_RGB(218, 165, 32) }, + { "greenyellow", NSVG_RGB(173, 255, 47) }, + { "honeydew", NSVG_RGB(240, 255, 240) }, + { "hotpink", NSVG_RGB(255, 105, 180) }, + { "indianred", NSVG_RGB(205, 92, 92) }, + { "indigo", NSVG_RGB( 75, 0, 130) }, + { "ivory", NSVG_RGB(255, 255, 240) }, + { "khaki", NSVG_RGB(240, 230, 140) }, + { "lavender", NSVG_RGB(230, 230, 250) }, + { "lavenderblush", NSVG_RGB(255, 240, 245) }, + { "lawngreen", NSVG_RGB(124, 252, 0) }, + { "lemonchiffon", NSVG_RGB(255, 250, 205) }, + { "lightblue", NSVG_RGB(173, 216, 230) }, + { "lightcoral", NSVG_RGB(240, 128, 128) }, + { "lightcyan", NSVG_RGB(224, 255, 255) }, + { "lightgoldenrodyellow", NSVG_RGB(250, 250, 210) }, + { "lightgray", NSVG_RGB(211, 211, 211) }, + { "lightgreen", NSVG_RGB(144, 238, 144) }, + { "lightgrey", NSVG_RGB(211, 211, 211) }, + { "lightpink", NSVG_RGB(255, 182, 193) }, + { "lightsalmon", NSVG_RGB(255, 160, 122) }, + { "lightseagreen", NSVG_RGB( 32, 178, 170) }, + { "lightskyblue", NSVG_RGB(135, 206, 250) }, + { "lightslategray", NSVG_RGB(119, 136, 153) }, + { "lightslategrey", NSVG_RGB(119, 136, 153) }, + { "lightsteelblue", NSVG_RGB(176, 196, 222) }, + { "lightyellow", NSVG_RGB(255, 255, 224) }, + { "lime", NSVG_RGB( 0, 255, 0) }, + { "limegreen", NSVG_RGB( 50, 205, 50) }, + { "linen", NSVG_RGB(250, 240, 230) }, + { "maroon", NSVG_RGB(128, 0, 0) }, + { "mediumaquamarine", NSVG_RGB(102, 205, 170) }, + { "mediumblue", NSVG_RGB( 0, 0, 205) }, + { "mediumorchid", NSVG_RGB(186, 85, 211) }, + { "mediumpurple", NSVG_RGB(147, 112, 219) }, + { "mediumseagreen", NSVG_RGB( 60, 179, 113) }, + { "mediumslateblue", NSVG_RGB(123, 104, 238) }, + { "mediumspringgreen", NSVG_RGB( 0, 250, 154) }, + { "mediumturquoise", NSVG_RGB( 72, 209, 204) }, + { "mediumvioletred", NSVG_RGB(199, 21, 133) }, + { "midnightblue", NSVG_RGB( 25, 25, 112) }, + { "mintcream", NSVG_RGB(245, 255, 250) }, + { "mistyrose", NSVG_RGB(255, 228, 225) }, + { "moccasin", NSVG_RGB(255, 228, 181) }, + { "navajowhite", NSVG_RGB(255, 222, 173) }, + { "navy", NSVG_RGB( 0, 0, 128) }, + { "oldlace", NSVG_RGB(253, 245, 230) }, + { "olive", NSVG_RGB(128, 128, 0) }, + { "olivedrab", NSVG_RGB(107, 142, 35) }, + { "orange", NSVG_RGB(255, 165, 0) }, + { "orangered", NSVG_RGB(255, 69, 0) }, + { "orchid", NSVG_RGB(218, 112, 214) }, + { "palegoldenrod", NSVG_RGB(238, 232, 170) }, + { "palegreen", NSVG_RGB(152, 251, 152) }, + { "paleturquoise", NSVG_RGB(175, 238, 238) }, + { "palevioletred", NSVG_RGB(219, 112, 147) }, + { "papayawhip", NSVG_RGB(255, 239, 213) }, + { "peachpuff", NSVG_RGB(255, 218, 185) }, + { "peru", NSVG_RGB(205, 133, 63) }, + { "pink", NSVG_RGB(255, 192, 203) }, + { "plum", NSVG_RGB(221, 160, 221) }, + { "powderblue", NSVG_RGB(176, 224, 230) }, + { "purple", NSVG_RGB(128, 0, 128) }, + { "rosybrown", NSVG_RGB(188, 143, 143) }, + { "royalblue", NSVG_RGB( 65, 105, 225) }, + { "saddlebrown", NSVG_RGB(139, 69, 19) }, + { "salmon", NSVG_RGB(250, 128, 114) }, + { "sandybrown", NSVG_RGB(244, 164, 96) }, + { "seagreen", NSVG_RGB( 46, 139, 87) }, + { "seashell", NSVG_RGB(255, 245, 238) }, + { "sienna", NSVG_RGB(160, 82, 45) }, + { "silver", NSVG_RGB(192, 192, 192) }, + { "skyblue", NSVG_RGB(135, 206, 235) }, + { "slateblue", NSVG_RGB(106, 90, 205) }, + { "slategray", NSVG_RGB(112, 128, 144) }, + { "slategrey", NSVG_RGB(112, 128, 144) }, + { "snow", NSVG_RGB(255, 250, 250) }, + { "springgreen", NSVG_RGB( 0, 255, 127) }, + { "steelblue", NSVG_RGB( 70, 130, 180) }, + { "tan", NSVG_RGB(210, 180, 140) }, + { "teal", NSVG_RGB( 0, 128, 128) }, + { "thistle", NSVG_RGB(216, 191, 216) }, + { "tomato", NSVG_RGB(255, 99, 71) }, + { "turquoise", NSVG_RGB( 64, 224, 208) }, + { "violet", NSVG_RGB(238, 130, 238) }, + { "wheat", NSVG_RGB(245, 222, 179) }, + { "whitesmoke", NSVG_RGB(245, 245, 245) }, + { "yellowgreen", NSVG_RGB(154, 205, 50) }, +#endif +}; + +static unsigned int nsvg__parseColorName(const char* str) +{ + int i, ncolors = sizeof(nsvg__colors) / sizeof(NSVGNamedColor); + + for (i = 0; i < ncolors; i++) { + if (strcmp(nsvg__colors[i].name, str) == 0) { + return nsvg__colors[i].color; + } + } + + return NSVG_RGB(128, 128, 128); +} + +static unsigned int nsvg__parseColor(const char* str) +{ + size_t len = 0; + while(*str == ' ') ++str; + len = strlen(str); + if (len >= 1 && *str == '#') + return nsvg__parseColorHex(str); + else if (len >= 4 && str[0] == 'r' && str[1] == 'g' && str[2] == 'b' && str[3] == '(') + return nsvg__parseColorRGB(str); + return nsvg__parseColorName(str); +} + +static float nsvg__parseOpacity(const char* str) +{ + float val = nsvg__atof(str); + if (val < 0.0f) val = 0.0f; + if (val > 1.0f) val = 1.0f; + return val; +} + +static float nsvg__parseMiterLimit(const char* str) +{ + float val = nsvg__atof(str); + if (val < 0.0f) val = 0.0f; + return val; +} + +static int nsvg__parseUnits(const char* units) +{ + if (units[0] == 'p' && units[1] == 'x') + return NSVG_UNITS_PX; + else if (units[0] == 'p' && units[1] == 't') + return NSVG_UNITS_PT; + else if (units[0] == 'p' && units[1] == 'c') + return NSVG_UNITS_PC; + else if (units[0] == 'm' && units[1] == 'm') + return NSVG_UNITS_MM; + else if (units[0] == 'c' && units[1] == 'm') + return NSVG_UNITS_CM; + else if (units[0] == 'i' && units[1] == 'n') + return NSVG_UNITS_IN; + else if (units[0] == '%') + return NSVG_UNITS_PERCENT; + else if (units[0] == 'e' && units[1] == 'm') + return NSVG_UNITS_EM; + else if (units[0] == 'e' && units[1] == 'x') + return NSVG_UNITS_EX; + return NSVG_UNITS_USER; +} + +static int nsvg__isCoordinate(const char* s) +{ + // optional sign + if (*s == '-' || *s == '+') + s++; + // must have at least one digit, or start by a dot + return (nsvg__isdigit(*s) || *s == '.'); +} + +static NSVGcoordinate nsvg__parseCoordinateRaw(const char* str) +{ + NSVGcoordinate coord = {0, NSVG_UNITS_USER}; + char buf[64]; + coord.units = nsvg__parseUnits(nsvg__parseNumber(str, buf, 64)); + coord.value = nsvg__atof(buf); + return coord; +} + +static NSVGcoordinate nsvg__coord(float v, int units) +{ + NSVGcoordinate coord = {v, units}; + return coord; +} + +static float nsvg__parseCoordinate(NSVGparser* p, const char* str, float orig, float length) +{ + NSVGcoordinate coord = nsvg__parseCoordinateRaw(str); + return nsvg__convertToPixels(p, coord, orig, length); +} + +static int nsvg__parseTransformArgs(const char* str, float* args, int maxNa, int* na) +{ + const char* end; + const char* ptr; + char it[64]; + + *na = 0; + ptr = str; + while (*ptr && *ptr != '(') ++ptr; + if (*ptr == 0) + return 1; + end = ptr; + while (*end && *end != ')') ++end; + if (*end == 0) + return 1; + + while (ptr < end) { + if (*ptr == '-' || *ptr == '+' || *ptr == '.' || nsvg__isdigit(*ptr)) { + if (*na >= maxNa) return 0; + ptr = nsvg__parseNumber(ptr, it, 64); + args[(*na)++] = (float)nsvg__atof(it); + } else { + ++ptr; + } + } + return (int)(end - str); +} + + +static int nsvg__parseMatrix(float* xform, const char* str) +{ + float t[6]; + int na = 0; + int len = nsvg__parseTransformArgs(str, t, 6, &na); + if (na != 6) return len; + memcpy(xform, t, sizeof(float)*6); + return len; +} + +static int nsvg__parseTranslate(float* xform, const char* str) +{ + float args[2]; + float t[6]; + int na = 0; + int len = nsvg__parseTransformArgs(str, args, 2, &na); + if (na == 1) args[1] = 0.0; + + nsvg__xformSetTranslation(t, args[0], args[1]); + memcpy(xform, t, sizeof(float)*6); + return len; +} + +static int nsvg__parseScale(float* xform, const char* str) +{ + float args[2]; + int na = 0; + float t[6]; + int len = nsvg__parseTransformArgs(str, args, 2, &na); + if (na == 1) args[1] = args[0]; + nsvg__xformSetScale(t, args[0], args[1]); + memcpy(xform, t, sizeof(float)*6); + return len; +} + +static int nsvg__parseSkewX(float* xform, const char* str) +{ + float args[1]; + int na = 0; + float t[6]; + int len = nsvg__parseTransformArgs(str, args, 1, &na); + nsvg__xformSetSkewX(t, args[0]/180.0f*NSVG_PI); + memcpy(xform, t, sizeof(float)*6); + return len; +} + +static int nsvg__parseSkewY(float* xform, const char* str) +{ + float args[1]; + int na = 0; + float t[6]; + int len = nsvg__parseTransformArgs(str, args, 1, &na); + nsvg__xformSetSkewY(t, args[0]/180.0f*NSVG_PI); + memcpy(xform, t, sizeof(float)*6); + return len; +} + +static int nsvg__parseRotate(float* xform, const char* str) +{ + float args[3]; + int na = 0; + float m[6]; + float t[6]; + int len = nsvg__parseTransformArgs(str, args, 3, &na); + if (na == 1) + args[1] = args[2] = 0.0f; + nsvg__xformIdentity(m); + + if (na > 1) { + nsvg__xformSetTranslation(t, -args[1], -args[2]); + nsvg__xformMultiply(m, t); + } + + nsvg__xformSetRotation(t, args[0]/180.0f*NSVG_PI); + nsvg__xformMultiply(m, t); + + if (na > 1) { + nsvg__xformSetTranslation(t, args[1], args[2]); + nsvg__xformMultiply(m, t); + } + + memcpy(xform, m, sizeof(float)*6); + + return len; +} + +static void nsvg__parseTransform(float* xform, const char* str) +{ + float t[6]; + int len; + nsvg__xformIdentity(xform); + while (*str) + { + if (strncmp(str, "matrix", 6) == 0) + len = nsvg__parseMatrix(t, str); + else if (strncmp(str, "translate", 9) == 0) + len = nsvg__parseTranslate(t, str); + else if (strncmp(str, "scale", 5) == 0) + len = nsvg__parseScale(t, str); + else if (strncmp(str, "rotate", 6) == 0) + len = nsvg__parseRotate(t, str); + else if (strncmp(str, "skewX", 5) == 0) + len = nsvg__parseSkewX(t, str); + else if (strncmp(str, "skewY", 5) == 0) + len = nsvg__parseSkewY(t, str); + else{ + ++str; + continue; + } + if (len != 0) { + str += len; + } else { + ++str; + continue; + } + + nsvg__xformPremultiply(xform, t); + } +} + +static void nsvg__parseUrl(char* id, const char* str) +{ + int i = 0; + str += 4; // "url("; + if (*str && *str == '#') + str++; + while (i < 63 && *str && *str != ')') { + id[i] = *str++; + i++; + } + id[i] = '\0'; +} + +static char nsvg__parseLineCap(const char* str) +{ + if (strcmp(str, "butt") == 0) + return NSVG_CAP_BUTT; + else if (strcmp(str, "round") == 0) + return NSVG_CAP_ROUND; + else if (strcmp(str, "square") == 0) + return NSVG_CAP_SQUARE; + // TODO: handle inherit. + return NSVG_CAP_BUTT; +} + +static char nsvg__parseLineJoin(const char* str) +{ + if (strcmp(str, "miter") == 0) + return NSVG_JOIN_MITER; + else if (strcmp(str, "round") == 0) + return NSVG_JOIN_ROUND; + else if (strcmp(str, "bevel") == 0) + return NSVG_JOIN_BEVEL; + // TODO: handle inherit. + return NSVG_JOIN_MITER; +} + +static char nsvg__parseFillRule(const char* str) +{ + if (strcmp(str, "nonzero") == 0) + return NSVG_FILLRULE_NONZERO; + else if (strcmp(str, "evenodd") == 0) + return NSVG_FILLRULE_EVENODD; + // TODO: handle inherit. + return NSVG_FILLRULE_NONZERO; +} + +static unsigned char nsvg__parsePaintOrder(const char* str) +{ + if (strcmp(str, "normal") == 0 || strcmp(str, "fill stroke markers") == 0) + return nsvg__encodePaintOrder(NSVG_PAINT_FILL, NSVG_PAINT_STROKE, NSVG_PAINT_MARKERS); + else if (strcmp(str, "fill markers stroke") == 0) + return nsvg__encodePaintOrder(NSVG_PAINT_FILL, NSVG_PAINT_MARKERS, NSVG_PAINT_STROKE); + else if (strcmp(str, "markers fill stroke") == 0) + return nsvg__encodePaintOrder(NSVG_PAINT_MARKERS, NSVG_PAINT_FILL, NSVG_PAINT_STROKE); + else if (strcmp(str, "markers stroke fill") == 0) + return nsvg__encodePaintOrder(NSVG_PAINT_MARKERS, NSVG_PAINT_STROKE, NSVG_PAINT_FILL); + else if (strcmp(str, "stroke fill markers") == 0) + return nsvg__encodePaintOrder(NSVG_PAINT_STROKE, NSVG_PAINT_FILL, NSVG_PAINT_MARKERS); + else if (strcmp(str, "stroke markers fill") == 0) + return nsvg__encodePaintOrder(NSVG_PAINT_STROKE, NSVG_PAINT_MARKERS, NSVG_PAINT_FILL); + // TODO: handle inherit. + return nsvg__encodePaintOrder(NSVG_PAINT_FILL, NSVG_PAINT_STROKE, NSVG_PAINT_MARKERS); +} + +static const char* nsvg__getNextDashItem(const char* s, char* it) +{ + int n = 0; + it[0] = '\0'; + // Skip white spaces and commas + while (*s && (nsvg__isspace(*s) || *s == ',')) s++; + // Advance until whitespace, comma or end. + while (*s && (!nsvg__isspace(*s) && *s != ',')) { + if (n < 63) + it[n++] = *s; + s++; + } + it[n++] = '\0'; + return s; +} + +static int nsvg__parseStrokeDashArray(NSVGparser* p, const char* str, float* strokeDashArray) +{ + char item[64]; + int count = 0, i; + float sum = 0.0f; + + // Handle "none" + if (str[0] == 'n') + return 0; + + // Parse dashes + while (*str) { + str = nsvg__getNextDashItem(str, item); + if (!*item) break; + if (count < NSVG_MAX_DASHES) + strokeDashArray[count++] = fabsf(nsvg__parseCoordinate(p, item, 0.0f, nsvg__actualLength(p))); + } + + for (i = 0; i < count; i++) + sum += strokeDashArray[i]; + if (sum <= 1e-6f) + count = 0; + + return count; +} + +static void nsvg__parseStyle(NSVGparser* p, const char* str); + +// Apply any matching class styles for a "class" attribute value. We support only simple class +// selectors. The class attribute may contain multiple space-separated class names. +static void nsvg__applyClassStyles(NSVGparser* p, const char* value) +{ + const char* cur = value; + while (*cur) { + const char* classStart; + size_t classLen; + NSVGstyleDeclaration* style; + + while (*cur && nsvg__isspace(*cur)) + cur++; + if (!*cur) + break; + + classStart = cur; + while (*cur && !nsvg__isspace(*cur)) + cur++; + classLen = (size_t)(cur - classStart); + + for (style = p->styles; style != NULL; style = style->next) { + if (strncmp(style->className, classStart, classLen) == 0 && style->className[classLen] == '\0') { + nsvg__parseStyle(p, style->propertiesText); + } + } + } +} + +static int nsvg__parseAttr(NSVGparser* p, const char* name, const char* value) +{ + float xform[6]; + NSVGattrib* attr = nsvg__getAttr(p); + if (!attr) return 0; + + if (strcmp(name, "style") == 0) { + nsvg__parseStyle(p, value); + } else if (strcmp(name, "display") == 0) { + if (strcmp(value, "none") == 0) + attr->visible = 0; + // Don't reset ->visible on display:inline, one display:none hides the whole subtree + + } else if (strcmp(name, "fill") == 0) { + if (strcmp(value, "none") == 0) { + attr->hasFill = 0; + } else if (strncmp(value, "url(", 4) == 0) { + attr->hasFill = 2; + nsvg__parseUrl(attr->fillGradient, value); + } else { + attr->hasFill = 1; + attr->fillColor = nsvg__parseColor(value); + } + } else if (strcmp(name, "opacity") == 0) { + attr->opacity = nsvg__parseOpacity(value); + } else if (strcmp(name, "fill-opacity") == 0) { + attr->fillOpacity = nsvg__parseOpacity(value); + } else if (strcmp(name, "stroke") == 0) { + if (strcmp(value, "none") == 0) { + attr->hasStroke = 0; + } else if (strncmp(value, "url(", 4) == 0) { + attr->hasStroke = 2; + nsvg__parseUrl(attr->strokeGradient, value); + } else { + attr->hasStroke = 1; + attr->strokeColor = nsvg__parseColor(value); + } + } else if (strcmp(name, "stroke-width") == 0) { + attr->strokeWidth = nsvg__parseCoordinate(p, value, 0.0f, nsvg__actualLength(p)); + } else if (strcmp(name, "stroke-dasharray") == 0) { + attr->strokeDashCount = nsvg__parseStrokeDashArray(p, value, attr->strokeDashArray); + } else if (strcmp(name, "stroke-dashoffset") == 0) { + attr->strokeDashOffset = nsvg__parseCoordinate(p, value, 0.0f, nsvg__actualLength(p)); + } else if (strcmp(name, "stroke-opacity") == 0) { + attr->strokeOpacity = nsvg__parseOpacity(value); + } else if (strcmp(name, "stroke-linecap") == 0) { + attr->strokeLineCap = nsvg__parseLineCap(value); + } else if (strcmp(name, "stroke-linejoin") == 0) { + attr->strokeLineJoin = nsvg__parseLineJoin(value); + } else if (strcmp(name, "stroke-miterlimit") == 0) { + attr->miterLimit = nsvg__parseMiterLimit(value); + } else if (strcmp(name, "fill-rule") == 0) { + attr->fillRule = nsvg__parseFillRule(value); + } else if (strcmp(name, "font-size") == 0) { + attr->fontSize = nsvg__parseCoordinate(p, value, 0.0f, nsvg__actualLength(p)); + } else if (strcmp(name, "transform") == 0) { + nsvg__parseTransform(xform, value); + nsvg__xformPremultiply(attr->xform, xform); + } else if (strcmp(name, "stop-color") == 0) { + attr->stopColor = nsvg__parseColor(value); + } else if (strcmp(name, "stop-opacity") == 0) { + attr->stopOpacity = nsvg__parseOpacity(value); + } else if (strcmp(name, "offset") == 0) { + attr->stopOffset = nsvg__parseCoordinate(p, value, 0.0f, 1.0f); + } else if (strcmp(name, "paint-order") == 0) { + attr->paintOrder = nsvg__parsePaintOrder(value); + } else if (strcmp(name, "id") == 0) { + strncpy(attr->id, value, 63); + attr->id[63] = '\0'; + } else if (strcmp(name, "class") == 0) { + nsvg__applyClassStyles(p, value); + } + else { + return 0; + } + return 1; +} + +static int nsvg__parseNameValue(NSVGparser* p, const char* start, const char* end) +{ + const char* str; + const char* val; + char name[512]; + char value[512]; + int n; + + str = start; + while (str < end && *str != ':') ++str; + + val = str; + + // Right Trim + while (str > start && (*str == ':' || nsvg__isspace(*str))) --str; + ++str; + + n = (int)(str - start); + if (n > 511) n = 511; + if (n) memcpy(name, start, n); + name[n] = 0; + + while (val < end && (*val == ':' || nsvg__isspace(*val))) ++val; + + n = (int)(end - val); + if (n > 511) n = 511; + if (n) memcpy(value, val, n); + value[n] = 0; + + return nsvg__parseAttr(p, name, value); +} + +static void nsvg__parseStyle(NSVGparser* p, const char* str) +{ + const char* start; + const char* end; + + while (*str) { + // Left Trim + while(*str && nsvg__isspace(*str)) ++str; + start = str; + while(*str && *str != ';') ++str; + end = str; + + // Right Trim + while (end > start && (*end == ';' || nsvg__isspace(*end))) --end; + ++end; + + nsvg__parseNameValue(p, start, end); + if (*str) ++str; + } +} + +static void nsvg__parseAttribs(NSVGparser* p, const char** attr) +{ + int i; + for (i = 0; attr[i]; i += 2) + { + if (strcmp(attr[i], "style") == 0) + nsvg__parseStyle(p, attr[i + 1]); + else + nsvg__parseAttr(p, attr[i], attr[i + 1]); + } +} + +static int nsvg__getArgsPerElement(char cmd) +{ + switch (cmd) { + case 'v': + case 'V': + case 'h': + case 'H': + return 1; + case 'm': + case 'M': + case 'l': + case 'L': + case 't': + case 'T': + return 2; + case 'q': + case 'Q': + case 's': + case 'S': + return 4; + case 'c': + case 'C': + return 6; + case 'a': + case 'A': + return 7; + case 'z': + case 'Z': + return 0; + } + return -1; +} + +static void nsvg__pathMoveTo(NSVGparser* p, float* cpx, float* cpy, float* args, int rel) +{ + if (rel) { + *cpx += args[0]; + *cpy += args[1]; + } else { + *cpx = args[0]; + *cpy = args[1]; + } + nsvg__moveTo(p, *cpx, *cpy); +} + +static void nsvg__pathLineTo(NSVGparser* p, float* cpx, float* cpy, float* args, int rel) +{ + if (rel) { + *cpx += args[0]; + *cpy += args[1]; + } else { + *cpx = args[0]; + *cpy = args[1]; + } + nsvg__lineTo(p, *cpx, *cpy); +} + +static void nsvg__pathHLineTo(NSVGparser* p, float* cpx, float* cpy, float* args, int rel) +{ + if (rel) + *cpx += args[0]; + else + *cpx = args[0]; + nsvg__lineTo(p, *cpx, *cpy); +} + +static void nsvg__pathVLineTo(NSVGparser* p, float* cpx, float* cpy, float* args, int rel) +{ + if (rel) + *cpy += args[0]; + else + *cpy = args[0]; + nsvg__lineTo(p, *cpx, *cpy); +} + +static void nsvg__pathCubicBezTo(NSVGparser* p, float* cpx, float* cpy, + float* cpx2, float* cpy2, float* args, int rel) +{ + float x2, y2, cx1, cy1, cx2, cy2; + + if (rel) { + cx1 = *cpx + args[0]; + cy1 = *cpy + args[1]; + cx2 = *cpx + args[2]; + cy2 = *cpy + args[3]; + x2 = *cpx + args[4]; + y2 = *cpy + args[5]; + } else { + cx1 = args[0]; + cy1 = args[1]; + cx2 = args[2]; + cy2 = args[3]; + x2 = args[4]; + y2 = args[5]; + } + + nsvg__cubicBezTo(p, cx1,cy1, cx2,cy2, x2,y2); + + *cpx2 = cx2; + *cpy2 = cy2; + *cpx = x2; + *cpy = y2; +} + +static void nsvg__pathCubicBezShortTo(NSVGparser* p, float* cpx, float* cpy, + float* cpx2, float* cpy2, float* args, int rel) +{ + float x1, y1, x2, y2, cx1, cy1, cx2, cy2; + + x1 = *cpx; + y1 = *cpy; + if (rel) { + cx2 = *cpx + args[0]; + cy2 = *cpy + args[1]; + x2 = *cpx + args[2]; + y2 = *cpy + args[3]; + } else { + cx2 = args[0]; + cy2 = args[1]; + x2 = args[2]; + y2 = args[3]; + } + + cx1 = 2*x1 - *cpx2; + cy1 = 2*y1 - *cpy2; + + nsvg__cubicBezTo(p, cx1,cy1, cx2,cy2, x2,y2); + + *cpx2 = cx2; + *cpy2 = cy2; + *cpx = x2; + *cpy = y2; +} + +static void nsvg__pathQuadBezTo(NSVGparser* p, float* cpx, float* cpy, + float* cpx2, float* cpy2, float* args, int rel) +{ + float x1, y1, x2, y2, cx, cy; + float cx1, cy1, cx2, cy2; + + x1 = *cpx; + y1 = *cpy; + if (rel) { + cx = *cpx + args[0]; + cy = *cpy + args[1]; + x2 = *cpx + args[2]; + y2 = *cpy + args[3]; + } else { + cx = args[0]; + cy = args[1]; + x2 = args[2]; + y2 = args[3]; + } + + // Convert to cubic bezier + cx1 = x1 + 2.0f/3.0f*(cx - x1); + cy1 = y1 + 2.0f/3.0f*(cy - y1); + cx2 = x2 + 2.0f/3.0f*(cx - x2); + cy2 = y2 + 2.0f/3.0f*(cy - y2); + + nsvg__cubicBezTo(p, cx1,cy1, cx2,cy2, x2,y2); + + *cpx2 = cx; + *cpy2 = cy; + *cpx = x2; + *cpy = y2; +} + +static void nsvg__pathQuadBezShortTo(NSVGparser* p, float* cpx, float* cpy, + float* cpx2, float* cpy2, float* args, int rel) +{ + float x1, y1, x2, y2, cx, cy; + float cx1, cy1, cx2, cy2; + + x1 = *cpx; + y1 = *cpy; + if (rel) { + x2 = *cpx + args[0]; + y2 = *cpy + args[1]; + } else { + x2 = args[0]; + y2 = args[1]; + } + + cx = 2*x1 - *cpx2; + cy = 2*y1 - *cpy2; + + // Convert to cubix bezier + cx1 = x1 + 2.0f/3.0f*(cx - x1); + cy1 = y1 + 2.0f/3.0f*(cy - y1); + cx2 = x2 + 2.0f/3.0f*(cx - x2); + cy2 = y2 + 2.0f/3.0f*(cy - y2); + + nsvg__cubicBezTo(p, cx1,cy1, cx2,cy2, x2,y2); + + *cpx2 = cx; + *cpy2 = cy; + *cpx = x2; + *cpy = y2; +} + +static float nsvg__sqr(float x) { return x*x; } +static float nsvg__vmag(float x, float y) { return sqrtf(x*x + y*y); } + +static float nsvg__vecrat(float ux, float uy, float vx, float vy) +{ + return (ux*vx + uy*vy) / (nsvg__vmag(ux,uy) * nsvg__vmag(vx,vy)); +} + +static float nsvg__vecang(float ux, float uy, float vx, float vy) +{ + float r = nsvg__vecrat(ux,uy, vx,vy); + if (r < -1.0f) r = -1.0f; + if (r > 1.0f) r = 1.0f; + return ((ux*vy < uy*vx) ? -1.0f : 1.0f) * acosf(r); +} + +static void nsvg__pathArcTo(NSVGparser* p, float* cpx, float* cpy, float* args, int rel) +{ + // Ported from canvg (https://code.google.com/p/canvg/) + float rx, ry, rotx; + float x1, y1, x2, y2, cx, cy, dx, dy, d; + float x1p, y1p, cxp, cyp, s, sa, sb; + float ux, uy, vx, vy, a1, da; + float x, y, tanx, tany, a, px = 0, py = 0, ptanx = 0, ptany = 0, t[6]; + float sinrx, cosrx; + int fa, fs; + int i, ndivs; + float hda, kappa; + + rx = fabsf(args[0]); // y radius + ry = fabsf(args[1]); // x radius + rotx = args[2] / 180.0f * NSVG_PI; // x rotation angle + fa = fabsf(args[3]) > 1e-6 ? 1 : 0; // Large arc + fs = fabsf(args[4]) > 1e-6 ? 1 : 0; // Sweep direction + x1 = *cpx; // start point + y1 = *cpy; + if (rel) { // end point + x2 = *cpx + args[5]; + y2 = *cpy + args[6]; + } else { + x2 = args[5]; + y2 = args[6]; + } + + dx = x1 - x2; + dy = y1 - y2; + d = sqrtf(dx*dx + dy*dy); + if (d < 1e-6f || rx < 1e-6f || ry < 1e-6f) { + // The arc degenerates to a line + nsvg__lineTo(p, x2, y2); + *cpx = x2; + *cpy = y2; + return; + } + + sinrx = sinf(rotx); + cosrx = cosf(rotx); + + // Convert to center point parameterization. + // http://www.w3.org/TR/SVG11/implnote.html#ArcImplementationNotes + // 1) Compute x1', y1' + x1p = cosrx * dx / 2.0f + sinrx * dy / 2.0f; + y1p = -sinrx * dx / 2.0f + cosrx * dy / 2.0f; + d = nsvg__sqr(x1p)/nsvg__sqr(rx) + nsvg__sqr(y1p)/nsvg__sqr(ry); + if (d > 1) { + d = sqrtf(d); + rx *= d; + ry *= d; + } + // 2) Compute cx', cy' + s = 0.0f; + sa = nsvg__sqr(rx)*nsvg__sqr(ry) - nsvg__sqr(rx)*nsvg__sqr(y1p) - nsvg__sqr(ry)*nsvg__sqr(x1p); + sb = nsvg__sqr(rx)*nsvg__sqr(y1p) + nsvg__sqr(ry)*nsvg__sqr(x1p); + if (sa < 0.0f) sa = 0.0f; + if (sb > 0.0f) + s = sqrtf(sa / sb); + if (fa == fs) + s = -s; + cxp = s * rx * y1p / ry; + cyp = s * -ry * x1p / rx; + + // 3) Compute cx,cy from cx',cy' + cx = (x1 + x2)/2.0f + cosrx*cxp - sinrx*cyp; + cy = (y1 + y2)/2.0f + sinrx*cxp + cosrx*cyp; + + // 4) Calculate theta1, and delta theta. + ux = (x1p - cxp) / rx; + uy = (y1p - cyp) / ry; + vx = (-x1p - cxp) / rx; + vy = (-y1p - cyp) / ry; + a1 = nsvg__vecang(1.0f,0.0f, ux,uy); // Initial angle + da = nsvg__vecang(ux,uy, vx,vy); // Delta angle + +// if (vecrat(ux,uy,vx,vy) <= -1.0f) da = NSVG_PI; +// if (vecrat(ux,uy,vx,vy) >= 1.0f) da = 0; + + if (fs == 0 && da > 0) + da -= 2 * NSVG_PI; + else if (fs == 1 && da < 0) + da += 2 * NSVG_PI; + + // Approximate the arc using cubic spline segments. + t[0] = cosrx; t[1] = sinrx; + t[2] = -sinrx; t[3] = cosrx; + t[4] = cx; t[5] = cy; + + // Split arc into max 90 degree segments. + // The loop assumes an iteration per end point (including start and end), this +1. + ndivs = (int)(fabsf(da) / (NSVG_PI*0.5f) + 1.0f); + hda = (da / (float)ndivs) / 2.0f; + // Fix for ticket #179: division by 0: avoid cotangens around 0 (infinite) + if ((hda < 1e-3f) && (hda > -1e-3f)) + hda *= 0.5f; + else + hda = (1.0f - cosf(hda)) / sinf(hda); + kappa = fabsf(4.0f / 3.0f * hda); + if (da < 0.0f) + kappa = -kappa; + + for (i = 0; i <= ndivs; i++) { + a = a1 + da * ((float)i/(float)ndivs); + dx = cosf(a); + dy = sinf(a); + nsvg__xformPoint(&x, &y, dx*rx, dy*ry, t); // position + nsvg__xformVec(&tanx, &tany, -dy*rx * kappa, dx*ry * kappa, t); // tangent + if (i > 0) + nsvg__cubicBezTo(p, px+ptanx,py+ptany, x-tanx, y-tany, x, y); + px = x; + py = y; + ptanx = tanx; + ptany = tany; + } + + *cpx = x2; + *cpy = y2; +} + +static void nsvg__parsePath(NSVGparser* p, const char** attr) +{ + const char* s = NULL; + char cmd = '\0'; + float args[10]; + int nargs; + int rargs = 0; + char initPoint; + float cpx, cpy, cpx2, cpy2; + const char* tmp[4]; + char closedFlag; + int i; + char item[64]; + + for (i = 0; attr[i]; i += 2) { + if (strcmp(attr[i], "d") == 0) { + s = attr[i + 1]; + } else { + tmp[0] = attr[i]; + tmp[1] = attr[i + 1]; + tmp[2] = 0; + tmp[3] = 0; + nsvg__parseAttribs(p, tmp); + } + } + + if (s) { + nsvg__resetPath(p); + cpx = 0; cpy = 0; + cpx2 = 0; cpy2 = 0; + initPoint = 0; + closedFlag = 0; + nargs = 0; + + while (*s) { + item[0] = '\0'; + if ((cmd == 'A' || cmd == 'a') && (nargs == 3 || nargs == 4)) + s = nsvg__getNextPathItemWhenArcFlag(s, item); + if (!*item) + s = nsvg__getNextPathItem(s, item); + if (!*item) break; + if (cmd != '\0' && nsvg__isCoordinate(item)) { + if (nargs < 10) + args[nargs++] = (float)nsvg__atof(item); + if (nargs >= rargs) { + switch (cmd) { + case 'm': + case 'M': + nsvg__pathMoveTo(p, &cpx, &cpy, args, cmd == 'm' ? 1 : 0); + // Moveto can be followed by multiple coordinate pairs, + // which should be treated as linetos. + cmd = (cmd == 'm') ? 'l' : 'L'; + rargs = nsvg__getArgsPerElement(cmd); + cpx2 = cpx; cpy2 = cpy; + initPoint = 1; + break; + case 'l': + case 'L': + nsvg__pathLineTo(p, &cpx, &cpy, args, cmd == 'l' ? 1 : 0); + cpx2 = cpx; cpy2 = cpy; + break; + case 'H': + case 'h': + nsvg__pathHLineTo(p, &cpx, &cpy, args, cmd == 'h' ? 1 : 0); + cpx2 = cpx; cpy2 = cpy; + break; + case 'V': + case 'v': + nsvg__pathVLineTo(p, &cpx, &cpy, args, cmd == 'v' ? 1 : 0); + cpx2 = cpx; cpy2 = cpy; + break; + case 'C': + case 'c': + nsvg__pathCubicBezTo(p, &cpx, &cpy, &cpx2, &cpy2, args, cmd == 'c' ? 1 : 0); + break; + case 'S': + case 's': + nsvg__pathCubicBezShortTo(p, &cpx, &cpy, &cpx2, &cpy2, args, cmd == 's' ? 1 : 0); + break; + case 'Q': + case 'q': + nsvg__pathQuadBezTo(p, &cpx, &cpy, &cpx2, &cpy2, args, cmd == 'q' ? 1 : 0); + break; + case 'T': + case 't': + nsvg__pathQuadBezShortTo(p, &cpx, &cpy, &cpx2, &cpy2, args, cmd == 't' ? 1 : 0); + break; + case 'A': + case 'a': + nsvg__pathArcTo(p, &cpx, &cpy, args, cmd == 'a' ? 1 : 0); + cpx2 = cpx; cpy2 = cpy; + break; + default: + if (nargs >= 2) { + cpx = args[nargs-2]; + cpy = args[nargs-1]; + cpx2 = cpx; cpy2 = cpy; + } + break; + } + nargs = 0; + } + } else { + cmd = item[0]; + if (cmd == 'M' || cmd == 'm') { + // Commit path. + if (p->npts > 0) + nsvg__addPath(p, closedFlag); + // Start new subpath. + nsvg__resetPath(p); + closedFlag = 0; + nargs = 0; + } else if (initPoint == 0) { + // Do not allow other commands until initial point has been set (moveTo called once). + cmd = '\0'; + } + if (cmd == 'Z' || cmd == 'z') { + closedFlag = 1; + // Commit path. + if (p->npts > 0) { + // Move current point to first point + cpx = p->pts[0]; + cpy = p->pts[1]; + cpx2 = cpx; cpy2 = cpy; + nsvg__addPath(p, closedFlag); + } + // Start new subpath. + nsvg__resetPath(p); + nsvg__moveTo(p, cpx, cpy); + closedFlag = 0; + nargs = 0; + } + rargs = nsvg__getArgsPerElement(cmd); + if (rargs == -1) { + // Command not recognized + cmd = '\0'; + rargs = 0; + } + } + } + // Commit path. + if (p->npts) + nsvg__addPath(p, closedFlag); + } + + nsvg__addShape(p); +} + +static void nsvg__parseRect(NSVGparser* p, const char** attr) +{ + float x = 0.0f; + float y = 0.0f; + float w = 0.0f; + float h = 0.0f; + float rx = -1.0f; // marks not set + float ry = -1.0f; + int i; + + for (i = 0; attr[i]; i += 2) { + if (!nsvg__parseAttr(p, attr[i], attr[i + 1])) { + if (strcmp(attr[i], "x") == 0) x = nsvg__parseCoordinate(p, attr[i+1], nsvg__actualOrigX(p), nsvg__actualWidth(p)); + if (strcmp(attr[i], "y") == 0) y = nsvg__parseCoordinate(p, attr[i+1], nsvg__actualOrigY(p), nsvg__actualHeight(p)); + if (strcmp(attr[i], "width") == 0) w = nsvg__parseCoordinate(p, attr[i+1], 0.0f, nsvg__actualWidth(p)); + if (strcmp(attr[i], "height") == 0) h = nsvg__parseCoordinate(p, attr[i+1], 0.0f, nsvg__actualHeight(p)); + if (strcmp(attr[i], "rx") == 0) rx = fabsf(nsvg__parseCoordinate(p, attr[i+1], 0.0f, nsvg__actualWidth(p))); + if (strcmp(attr[i], "ry") == 0) ry = fabsf(nsvg__parseCoordinate(p, attr[i+1], 0.0f, nsvg__actualHeight(p))); + } + } + + if (rx < 0.0f && ry > 0.0f) rx = ry; + if (ry < 0.0f && rx > 0.0f) ry = rx; + if (rx < 0.0f) rx = 0.0f; + if (ry < 0.0f) ry = 0.0f; + if (rx > w/2.0f) rx = w/2.0f; + if (ry > h/2.0f) ry = h/2.0f; + + if (w != 0.0f && h != 0.0f) { + nsvg__resetPath(p); + + if (rx < 0.00001f || ry < 0.0001f) { + nsvg__moveTo(p, x, y); + nsvg__lineTo(p, x+w, y); + nsvg__lineTo(p, x+w, y+h); + nsvg__lineTo(p, x, y+h); + } else { + // Rounded rectangle + nsvg__moveTo(p, x+rx, y); + nsvg__lineTo(p, x+w-rx, y); + nsvg__cubicBezTo(p, x+w-rx*(1-NSVG_KAPPA90), y, x+w, y+ry*(1-NSVG_KAPPA90), x+w, y+ry); + nsvg__lineTo(p, x+w, y+h-ry); + nsvg__cubicBezTo(p, x+w, y+h-ry*(1-NSVG_KAPPA90), x+w-rx*(1-NSVG_KAPPA90), y+h, x+w-rx, y+h); + nsvg__lineTo(p, x+rx, y+h); + nsvg__cubicBezTo(p, x+rx*(1-NSVG_KAPPA90), y+h, x, y+h-ry*(1-NSVG_KAPPA90), x, y+h-ry); + nsvg__lineTo(p, x, y+ry); + nsvg__cubicBezTo(p, x, y+ry*(1-NSVG_KAPPA90), x+rx*(1-NSVG_KAPPA90), y, x+rx, y); + } + + nsvg__addPath(p, 1); + + nsvg__addShape(p); + } +} + +static void nsvg__parseCircle(NSVGparser* p, const char** attr) +{ + float cx = 0.0f; + float cy = 0.0f; + float r = 0.0f; + int i; + + for (i = 0; attr[i]; i += 2) { + if (!nsvg__parseAttr(p, attr[i], attr[i + 1])) { + if (strcmp(attr[i], "cx") == 0) cx = nsvg__parseCoordinate(p, attr[i+1], nsvg__actualOrigX(p), nsvg__actualWidth(p)); + if (strcmp(attr[i], "cy") == 0) cy = nsvg__parseCoordinate(p, attr[i+1], nsvg__actualOrigY(p), nsvg__actualHeight(p)); + if (strcmp(attr[i], "r") == 0) r = fabsf(nsvg__parseCoordinate(p, attr[i+1], 0.0f, nsvg__actualLength(p))); + } + } + + if (r > 0.0f) { + nsvg__resetPath(p); + + nsvg__moveTo(p, cx+r, cy); + nsvg__cubicBezTo(p, cx+r, cy+r*NSVG_KAPPA90, cx+r*NSVG_KAPPA90, cy+r, cx, cy+r); + nsvg__cubicBezTo(p, cx-r*NSVG_KAPPA90, cy+r, cx-r, cy+r*NSVG_KAPPA90, cx-r, cy); + nsvg__cubicBezTo(p, cx-r, cy-r*NSVG_KAPPA90, cx-r*NSVG_KAPPA90, cy-r, cx, cy-r); + nsvg__cubicBezTo(p, cx+r*NSVG_KAPPA90, cy-r, cx+r, cy-r*NSVG_KAPPA90, cx+r, cy); + + nsvg__addPath(p, 1); + + nsvg__addShape(p); + } +} + +static void nsvg__parseEllipse(NSVGparser* p, const char** attr) +{ + float cx = 0.0f; + float cy = 0.0f; + float rx = 0.0f; + float ry = 0.0f; + int i; + + for (i = 0; attr[i]; i += 2) { + if (!nsvg__parseAttr(p, attr[i], attr[i + 1])) { + if (strcmp(attr[i], "cx") == 0) cx = nsvg__parseCoordinate(p, attr[i+1], nsvg__actualOrigX(p), nsvg__actualWidth(p)); + if (strcmp(attr[i], "cy") == 0) cy = nsvg__parseCoordinate(p, attr[i+1], nsvg__actualOrigY(p), nsvg__actualHeight(p)); + if (strcmp(attr[i], "rx") == 0) rx = fabsf(nsvg__parseCoordinate(p, attr[i+1], 0.0f, nsvg__actualWidth(p))); + if (strcmp(attr[i], "ry") == 0) ry = fabsf(nsvg__parseCoordinate(p, attr[i+1], 0.0f, nsvg__actualHeight(p))); + } + } + + if (rx > 0.0f && ry > 0.0f) { + + nsvg__resetPath(p); + + nsvg__moveTo(p, cx+rx, cy); + nsvg__cubicBezTo(p, cx+rx, cy+ry*NSVG_KAPPA90, cx+rx*NSVG_KAPPA90, cy+ry, cx, cy+ry); + nsvg__cubicBezTo(p, cx-rx*NSVG_KAPPA90, cy+ry, cx-rx, cy+ry*NSVG_KAPPA90, cx-rx, cy); + nsvg__cubicBezTo(p, cx-rx, cy-ry*NSVG_KAPPA90, cx-rx*NSVG_KAPPA90, cy-ry, cx, cy-ry); + nsvg__cubicBezTo(p, cx+rx*NSVG_KAPPA90, cy-ry, cx+rx, cy-ry*NSVG_KAPPA90, cx+rx, cy); + + nsvg__addPath(p, 1); + + nsvg__addShape(p); + } +} + +static void nsvg__parseLine(NSVGparser* p, const char** attr) +{ + float x1 = 0.0; + float y1 = 0.0; + float x2 = 0.0; + float y2 = 0.0; + int i; + + for (i = 0; attr[i]; i += 2) { + if (!nsvg__parseAttr(p, attr[i], attr[i + 1])) { + if (strcmp(attr[i], "x1") == 0) x1 = nsvg__parseCoordinate(p, attr[i + 1], nsvg__actualOrigX(p), nsvg__actualWidth(p)); + if (strcmp(attr[i], "y1") == 0) y1 = nsvg__parseCoordinate(p, attr[i + 1], nsvg__actualOrigY(p), nsvg__actualHeight(p)); + if (strcmp(attr[i], "x2") == 0) x2 = nsvg__parseCoordinate(p, attr[i + 1], nsvg__actualOrigX(p), nsvg__actualWidth(p)); + if (strcmp(attr[i], "y2") == 0) y2 = nsvg__parseCoordinate(p, attr[i + 1], nsvg__actualOrigY(p), nsvg__actualHeight(p)); + } + } + + nsvg__resetPath(p); + + nsvg__moveTo(p, x1, y1); + nsvg__lineTo(p, x2, y2); + + nsvg__addPath(p, 0); + + nsvg__addShape(p); +} + +static void nsvg__parsePoly(NSVGparser* p, const char** attr, int closeFlag) +{ + int i; + const char* s; + float args[2]; + int nargs, npts = 0; + char item[64]; + + nsvg__resetPath(p); + + for (i = 0; attr[i]; i += 2) { + if (!nsvg__parseAttr(p, attr[i], attr[i + 1])) { + if (strcmp(attr[i], "points") == 0) { + s = attr[i + 1]; + nargs = 0; + while (*s) { + s = nsvg__getNextPathItem(s, item); + args[nargs++] = (float)nsvg__atof(item); + if (nargs >= 2) { + if (npts == 0) + nsvg__moveTo(p, args[0], args[1]); + else + nsvg__lineTo(p, args[0], args[1]); + nargs = 0; + npts++; + } + } + } + } + } + + nsvg__addPath(p, (char)closeFlag); + + nsvg__addShape(p); +} + +static void nsvg__parseSVG(NSVGparser* p, const char** attr) +{ + int i; + for (i = 0; attr[i]; i += 2) { + if (!nsvg__parseAttr(p, attr[i], attr[i + 1])) { + if (strcmp(attr[i], "width") == 0) { + p->image->width = nsvg__parseCoordinate(p, attr[i + 1], 0.0f, 0.0f); + } else if (strcmp(attr[i], "height") == 0) { + p->image->height = nsvg__parseCoordinate(p, attr[i + 1], 0.0f, 0.0f); + } else if (strcmp(attr[i], "viewBox") == 0) { + const char *s = attr[i + 1]; + char buf[64]; + s = nsvg__parseNumber(s, buf, 64); + p->viewMinx = nsvg__atof(buf); + while (*s && (nsvg__isspace(*s) || *s == '%' || *s == ',')) s++; + if (!*s) return; + s = nsvg__parseNumber(s, buf, 64); + p->viewMiny = nsvg__atof(buf); + while (*s && (nsvg__isspace(*s) || *s == '%' || *s == ',')) s++; + if (!*s) return; + s = nsvg__parseNumber(s, buf, 64); + p->viewWidth = nsvg__atof(buf); + while (*s && (nsvg__isspace(*s) || *s == '%' || *s == ',')) s++; + if (!*s) return; + s = nsvg__parseNumber(s, buf, 64); + p->viewHeight = nsvg__atof(buf); + } else if (strcmp(attr[i], "preserveAspectRatio") == 0) { + if (strstr(attr[i + 1], "none") != 0) { + // No uniform scaling + p->alignType = NSVG_ALIGN_NONE; + } else { + // Parse X align + if (strstr(attr[i + 1], "xMin") != 0) + p->alignX = NSVG_ALIGN_MIN; + else if (strstr(attr[i + 1], "xMid") != 0) + p->alignX = NSVG_ALIGN_MID; + else if (strstr(attr[i + 1], "xMax") != 0) + p->alignX = NSVG_ALIGN_MAX; + // Parse X align + if (strstr(attr[i + 1], "yMin") != 0) + p->alignY = NSVG_ALIGN_MIN; + else if (strstr(attr[i + 1], "yMid") != 0) + p->alignY = NSVG_ALIGN_MID; + else if (strstr(attr[i + 1], "yMax") != 0) + p->alignY = NSVG_ALIGN_MAX; + // Parse meet/slice + p->alignType = NSVG_ALIGN_MEET; + if (strstr(attr[i + 1], "slice") != 0) + p->alignType = NSVG_ALIGN_SLICE; + } + } + } + } +} + +static void nsvg__parseGradient(NSVGparser* p, const char** attr, signed char type) +{ + int i; + NSVGgradientData* grad = (NSVGgradientData*)malloc(sizeof(NSVGgradientData)); + if (grad == NULL) return; + memset(grad, 0, sizeof(NSVGgradientData)); + grad->units = NSVG_OBJECT_SPACE; + grad->type = type; + if (grad->type == NSVG_PAINT_LINEAR_GRADIENT) { + grad->linear.x1 = nsvg__coord(0.0f, NSVG_UNITS_PERCENT); + grad->linear.y1 = nsvg__coord(0.0f, NSVG_UNITS_PERCENT); + grad->linear.x2 = nsvg__coord(100.0f, NSVG_UNITS_PERCENT); + grad->linear.y2 = nsvg__coord(0.0f, NSVG_UNITS_PERCENT); + } else if (grad->type == NSVG_PAINT_RADIAL_GRADIENT) { + grad->radial.cx = nsvg__coord(50.0f, NSVG_UNITS_PERCENT); + grad->radial.cy = nsvg__coord(50.0f, NSVG_UNITS_PERCENT); + grad->radial.r = nsvg__coord(50.0f, NSVG_UNITS_PERCENT); + } + + nsvg__xformIdentity(grad->xform); + + for (i = 0; attr[i]; i += 2) { + if (strcmp(attr[i], "id") == 0) { + strncpy(grad->id, attr[i+1], 63); + grad->id[63] = '\0'; + } else if (!nsvg__parseAttr(p, attr[i], attr[i + 1])) { + if (strcmp(attr[i], "gradientUnits") == 0) { + if (strcmp(attr[i+1], "objectBoundingBox") == 0) + grad->units = NSVG_OBJECT_SPACE; + else + grad->units = NSVG_USER_SPACE; + } else if (strcmp(attr[i], "gradientTransform") == 0) { + nsvg__parseTransform(grad->xform, attr[i + 1]); + } else if (strcmp(attr[i], "cx") == 0) { + grad->radial.cx = nsvg__parseCoordinateRaw(attr[i + 1]); + } else if (strcmp(attr[i], "cy") == 0) { + grad->radial.cy = nsvg__parseCoordinateRaw(attr[i + 1]); + } else if (strcmp(attr[i], "r") == 0) { + grad->radial.r = nsvg__parseCoordinateRaw(attr[i + 1]); + } else if (strcmp(attr[i], "fx") == 0) { + grad->radial.fx = nsvg__parseCoordinateRaw(attr[i + 1]); + } else if (strcmp(attr[i], "fy") == 0) { + grad->radial.fy = nsvg__parseCoordinateRaw(attr[i + 1]); + } else if (strcmp(attr[i], "x1") == 0) { + grad->linear.x1 = nsvg__parseCoordinateRaw(attr[i + 1]); + } else if (strcmp(attr[i], "y1") == 0) { + grad->linear.y1 = nsvg__parseCoordinateRaw(attr[i + 1]); + } else if (strcmp(attr[i], "x2") == 0) { + grad->linear.x2 = nsvg__parseCoordinateRaw(attr[i + 1]); + } else if (strcmp(attr[i], "y2") == 0) { + grad->linear.y2 = nsvg__parseCoordinateRaw(attr[i + 1]); + } else if (strcmp(attr[i], "spreadMethod") == 0) { + if (strcmp(attr[i+1], "pad") == 0) + grad->spread = NSVG_SPREAD_PAD; + else if (strcmp(attr[i+1], "reflect") == 0) + grad->spread = NSVG_SPREAD_REFLECT; + else if (strcmp(attr[i+1], "repeat") == 0) + grad->spread = NSVG_SPREAD_REPEAT; + } else if (strcmp(attr[i], "xlink:href") == 0) { + const char *href = attr[i+1]; + strncpy(grad->ref, href+1, 62); + grad->ref[62] = '\0'; + } + } + } + + grad->next = p->gradients; + p->gradients = grad; +} + +static void nsvg__parseGradientStop(NSVGparser* p, const char** attr) +{ + NSVGattrib* curAttr = nsvg__getAttr(p); + NSVGgradientData* grad; + NSVGgradientStop* stop; + int i, idx; + + curAttr->stopOffset = 0; + curAttr->stopColor = 0; + curAttr->stopOpacity = 1.0f; + + for (i = 0; attr[i]; i += 2) { + nsvg__parseAttr(p, attr[i], attr[i + 1]); + } + + // Add stop to the last gradient. + grad = p->gradients; + if (grad == NULL) return; + + grad->nstops++; + grad->stops = (NSVGgradientStop*)realloc(grad->stops, sizeof(NSVGgradientStop)*grad->nstops); + if (grad->stops == NULL) return; + + // Insert + idx = grad->nstops-1; + for (i = 0; i < grad->nstops-1; i++) { + if (curAttr->stopOffset < grad->stops[i].offset) { + idx = i; + break; + } + } + if (idx != grad->nstops-1) { + for (i = grad->nstops-1; i > idx; i--) + grad->stops[i] = grad->stops[i-1]; + } + + stop = &grad->stops[idx]; + stop->color = curAttr->stopColor; + stop->color |= (unsigned int)(curAttr->stopOpacity*255) << 24; + stop->offset = curAttr->stopOffset; +} + +static void nsvg__startElement(void* ud, const char* el, const char** attr) +{ + NSVGparser* p = (NSVGparser*)ud; + + if (p->defsFlag) { + // Skip everything but gradients and styles in defs + if (strcmp(el, "linearGradient") == 0) { + nsvg__parseGradient(p, attr, NSVG_PAINT_LINEAR_GRADIENT); + } else if (strcmp(el, "radialGradient") == 0) { + nsvg__parseGradient(p, attr, NSVG_PAINT_RADIAL_GRADIENT); + } else if (strcmp(el, "stop") == 0) { + nsvg__parseGradientStop(p, attr); + } else if (strcmp(el, "style") == 0) { + p->styleFlag = 1; + } + return; + } + + if (strcmp(el, "g") == 0) { + nsvg__pushAttr(p); + nsvg__parseAttribs(p, attr); + } else if (strcmp(el, "path") == 0) { + if (p->pathFlag) // Do not allow nested paths. + return; + nsvg__pushAttr(p); + nsvg__parsePath(p, attr); + nsvg__popAttr(p); + } else if (strcmp(el, "rect") == 0) { + nsvg__pushAttr(p); + nsvg__parseRect(p, attr); + nsvg__popAttr(p); + } else if (strcmp(el, "circle") == 0) { + nsvg__pushAttr(p); + nsvg__parseCircle(p, attr); + nsvg__popAttr(p); + } else if (strcmp(el, "ellipse") == 0) { + nsvg__pushAttr(p); + nsvg__parseEllipse(p, attr); + nsvg__popAttr(p); + } else if (strcmp(el, "line") == 0) { + nsvg__pushAttr(p); + nsvg__parseLine(p, attr); + nsvg__popAttr(p); + } else if (strcmp(el, "polyline") == 0) { + nsvg__pushAttr(p); + nsvg__parsePoly(p, attr, 0); + nsvg__popAttr(p); + } else if (strcmp(el, "polygon") == 0) { + nsvg__pushAttr(p); + nsvg__parsePoly(p, attr, 1); + nsvg__popAttr(p); + } else if (strcmp(el, "linearGradient") == 0) { + nsvg__parseGradient(p, attr, NSVG_PAINT_LINEAR_GRADIENT); + } else if (strcmp(el, "radialGradient") == 0) { + nsvg__parseGradient(p, attr, NSVG_PAINT_RADIAL_GRADIENT); + } else if (strcmp(el, "stop") == 0) { + nsvg__parseGradientStop(p, attr); + } else if (strcmp(el, "defs") == 0) { + p->defsFlag = 1; + } else if (strcmp(el, "svg") == 0) { + nsvg__parseSVG(p, attr); + } else if (strcmp(el, "style") == 0) { + p->styleFlag = 1; + } +} + +static void nsvg__endElement(void* ud, const char* el) +{ + NSVGparser* p = (NSVGparser*)ud; + + if (strcmp(el, "g") == 0) { + nsvg__popAttr(p); + } else if (strcmp(el, "path") == 0) { + p->pathFlag = 0; + } else if (strcmp(el, "defs") == 0) { + p->defsFlag = 0; + } else if (strcmp(el, "style") == 0) { + p->styleFlag = 0; + } +} + +static char *nsvg__strndup(const char *s, size_t n) +{ + char *result = (char *)malloc(n + 1); + if (result == NULL) + return NULL; + + memcpy(result, s, n); + result[n] = '\0'; + return result; +} + +static void nsvg__content(void* ud, const char* s) +{ + NSVGparser* p = (NSVGparser*)ud; + if (!p->styleFlag) + return; + + // Parse all the styles inside the style block. Each style's content will be later processed using nsvg__parseStyle(). + // Note: We only support selector lists of simple class selectors (e.g. ".foo, .bar { ... }"). + while (*s) { + NSVGstyleDeclaration* styles[NSVG_MAX_CLASSES]; + int nstyles = 0; + const char* propsStart; + const char* propsEnd; + int i; + + // 1) Parse the selector list up to '{'. For each simple class selector ('.name'), + // allocate a new NSVGstyleDeclaration into the local staging array. Styles are + // only committed to p->styles in step 3 below, once their propertiesText has + // also been allocated successfully. + while (*s && *s != '{') { + const char* selStart; + const char* selEnd; + NSVGstyleDeclaration* style; + + while (*s && (nsvg__isspace(*s) || *s == ',')) + s++; + if (!*s || *s == '{') + break; + + selStart = s; + while (*s && !nsvg__isspace(*s) && *s != ',' && *s != '{') + s++; + selEnd = s; + + if (*selStart != '.' || nstyles >= NSVG_MAX_CLASSES) + continue; // unsupported selector, or staging array full + selStart++; // strip leading '.' + + style = (NSVGstyleDeclaration*)malloc(sizeof(NSVGstyleDeclaration)); + if (style == NULL) + continue; + style->className = nsvg__strndup(selStart, (size_t)(selEnd - selStart)); + if (style->className == NULL) { + free(style); + continue; + } + style->propertiesText = NULL; + style->next = NULL; + styles[nstyles++] = style; + } + if (!*s) { + // No '{' found - discard pending styles and stop. + for (i = 0; i < nstyles; i++) { + free(styles[i]->className); + free(styles[i]); + } + break; + } + s++; // advance past '{' + + // 2) Find the end of the properties block (up to '}'). + propsStart = s; + while (*s && *s != '}') + s++; + propsEnd = s; + + // 3) Allocate propertiesText for each pending style. Commit successful ones to + // p->styles (head-insertion); free any whose allocation fails. + for (i = 0; i < nstyles; i++) { + styles[i]->propertiesText = nsvg__strndup(propsStart, (size_t)(propsEnd - propsStart)); + if (styles[i]->propertiesText == NULL) { + free(styles[i]->className); + free(styles[i]); + } else { + styles[i]->next = p->styles; + p->styles = styles[i]; + } + } + + if (*s) + s++; // advance past '}' + } +} + +static void nsvg__imageBounds(NSVGparser* p, float* bounds) +{ + NSVGshape* shape; + shape = p->image->shapes; + if (shape == NULL) { + bounds[0] = bounds[1] = bounds[2] = bounds[3] = 0.0; + return; + } + bounds[0] = shape->bounds[0]; + bounds[1] = shape->bounds[1]; + bounds[2] = shape->bounds[2]; + bounds[3] = shape->bounds[3]; + for (shape = shape->next; shape != NULL; shape = shape->next) { + bounds[0] = nsvg__minf(bounds[0], shape->bounds[0]); + bounds[1] = nsvg__minf(bounds[1], shape->bounds[1]); + bounds[2] = nsvg__maxf(bounds[2], shape->bounds[2]); + bounds[3] = nsvg__maxf(bounds[3], shape->bounds[3]); + } +} + +static float nsvg__viewAlign(float content, float container, int type) +{ + if (type == NSVG_ALIGN_MIN) + return 0; + else if (type == NSVG_ALIGN_MAX) + return container - content; + // mid + return (container - content) * 0.5f; +} + +static void nsvg__scaleGradient(NSVGgradient* grad, float tx, float ty, float sx, float sy) +{ + float t[6]; + nsvg__xformSetTranslation(t, tx, ty); + nsvg__xformMultiply (grad->xform, t); + + nsvg__xformSetScale(t, sx, sy); + nsvg__xformMultiply (grad->xform, t); +} + +static void nsvg__scaleToViewbox(NSVGparser* p, const char* units) +{ + NSVGshape* shape; + NSVGpath* path; + float tx, ty, sx, sy, us, bounds[4], t[6], avgs; + int i; + float* pt; + + // Guess image size if not set completely. + nsvg__imageBounds(p, bounds); + + if (p->viewWidth == 0) { + if (p->image->width > 0) { + p->viewWidth = p->image->width; + } else { + p->viewMinx = bounds[0]; + p->viewWidth = bounds[2] - bounds[0]; + } + } + if (p->viewHeight == 0) { + if (p->image->height > 0) { + p->viewHeight = p->image->height; + } else { + p->viewMiny = bounds[1]; + p->viewHeight = bounds[3] - bounds[1]; + } + } + if (p->image->width == 0) + p->image->width = p->viewWidth; + if (p->image->height == 0) + p->image->height = p->viewHeight; + + tx = -p->viewMinx; + ty = -p->viewMiny; + sx = p->viewWidth > 0 ? p->image->width / p->viewWidth : 0; + sy = p->viewHeight > 0 ? p->image->height / p->viewHeight : 0; + // Unit scaling + us = 1.0f / nsvg__convertToPixels(p, nsvg__coord(1.0f, nsvg__parseUnits(units)), 0.0f, 1.0f); + + // Fix aspect ratio + if (p->alignType == NSVG_ALIGN_MEET) { + // fit whole image into viewbox + sx = sy = nsvg__minf(sx, sy); + tx += nsvg__viewAlign(p->viewWidth*sx, p->image->width, p->alignX) / sx; + ty += nsvg__viewAlign(p->viewHeight*sy, p->image->height, p->alignY) / sy; + } else if (p->alignType == NSVG_ALIGN_SLICE) { + // fill whole viewbox with image + sx = sy = nsvg__maxf(sx, sy); + tx += nsvg__viewAlign(p->viewWidth*sx, p->image->width, p->alignX) / sx; + ty += nsvg__viewAlign(p->viewHeight*sy, p->image->height, p->alignY) / sy; + } + + // Transform + sx *= us; + sy *= us; + avgs = (sx+sy) / 2.0f; + for (shape = p->image->shapes; shape != NULL; shape = shape->next) { + shape->bounds[0] = (shape->bounds[0] + tx) * sx; + shape->bounds[1] = (shape->bounds[1] + ty) * sy; + shape->bounds[2] = (shape->bounds[2] + tx) * sx; + shape->bounds[3] = (shape->bounds[3] + ty) * sy; + for (path = shape->paths; path != NULL; path = path->next) { + path->bounds[0] = (path->bounds[0] + tx) * sx; + path->bounds[1] = (path->bounds[1] + ty) * sy; + path->bounds[2] = (path->bounds[2] + tx) * sx; + path->bounds[3] = (path->bounds[3] + ty) * sy; + for (i =0; i < path->npts; i++) { + pt = &path->pts[i*2]; + pt[0] = (pt[0] + tx) * sx; + pt[1] = (pt[1] + ty) * sy; + } + } + + if (shape->fill.type == NSVG_PAINT_LINEAR_GRADIENT || shape->fill.type == NSVG_PAINT_RADIAL_GRADIENT) { + nsvg__scaleGradient(shape->fill.gradient, tx,ty, sx,sy); + memcpy(t, shape->fill.gradient->xform, sizeof(float)*6); + nsvg__xformInverse(shape->fill.gradient->xform, t); + } + if (shape->stroke.type == NSVG_PAINT_LINEAR_GRADIENT || shape->stroke.type == NSVG_PAINT_RADIAL_GRADIENT) { + nsvg__scaleGradient(shape->stroke.gradient, tx,ty, sx,sy); + memcpy(t, shape->stroke.gradient->xform, sizeof(float)*6); + nsvg__xformInverse(shape->stroke.gradient->xform, t); + } + + shape->strokeWidth *= avgs; + shape->strokeDashOffset *= avgs; + for (i = 0; i < shape->strokeDashCount; i++) + shape->strokeDashArray[i] *= avgs; + } +} + +static void nsvg__createGradients(NSVGparser* p) +{ + NSVGshape* shape; + + for (shape = p->image->shapes; shape != NULL; shape = shape->next) { + if (shape->fill.type == NSVG_PAINT_UNDEF) { + if (shape->fillGradient[0] != '\0') { + float inv[6], localBounds[4]; + nsvg__xformInverse(inv, shape->xform); + nsvg__getLocalBounds(localBounds, shape, inv); + shape->fill.gradient = nsvg__createGradient(p, shape->fillGradient, localBounds, shape->xform, &shape->fill.type); + } + if (shape->fill.type == NSVG_PAINT_UNDEF) { + shape->fill.type = NSVG_PAINT_NONE; + } + } + if (shape->stroke.type == NSVG_PAINT_UNDEF) { + if (shape->strokeGradient[0] != '\0') { + float inv[6], localBounds[4]; + nsvg__xformInverse(inv, shape->xform); + nsvg__getLocalBounds(localBounds, shape, inv); + shape->stroke.gradient = nsvg__createGradient(p, shape->strokeGradient, localBounds, shape->xform, &shape->stroke.type); + } + if (shape->stroke.type == NSVG_PAINT_UNDEF) { + shape->stroke.type = NSVG_PAINT_NONE; + } + } + } +} + +NSVGimage* nsvgParse(char* input, const char* units, float dpi) +{ + NSVGparser* p; + NSVGimage* ret = 0; + + p = nsvg__createParser(); + if (p == NULL) { + return NULL; + } + p->dpi = dpi; + + nsvg__parseXML(input, nsvg__startElement, nsvg__endElement, nsvg__content, p); + + // Create gradients after all definitions have been parsed + nsvg__createGradients(p); + + // Scale to viewBox + nsvg__scaleToViewbox(p, units); + + ret = p->image; + p->image = NULL; + + nsvg__deleteParser(p); + + return ret; +} + +NSVGimage* nsvgParseFromFile(const char* filename, const char* units, float dpi) +{ + FILE* fp = NULL; + size_t size; + char* data = NULL; + NSVGimage* image = NULL; + + fp = fopen(filename, "rb"); + if (!fp) goto error; + fseek(fp, 0, SEEK_END); + size = ftell(fp); + fseek(fp, 0, SEEK_SET); + data = (char*)malloc(size+1); + if (data == NULL) goto error; + if (fread(data, 1, size, fp) != size) goto error; + data[size] = '\0'; // Must be null terminated. + fclose(fp); + image = nsvgParse(data, units, dpi); + free(data); + + return image; + +error: + if (fp) fclose(fp); + if (data) free(data); + if (image) nsvgDelete(image); + return NULL; +} + +NSVGpath* nsvgDuplicatePath(NSVGpath* p) +{ + NSVGpath* res = NULL; + + if (p == NULL) + return NULL; + + res = (NSVGpath*)malloc(sizeof(NSVGpath)); + if (res == NULL) goto error; + memset(res, 0, sizeof(NSVGpath)); + + res->pts = (float*)malloc(p->npts*2*sizeof(float)); + if (res->pts == NULL) goto error; + memcpy(res->pts, p->pts, p->npts * sizeof(float) * 2); + res->npts = p->npts; + + memcpy(res->bounds, p->bounds, sizeof(p->bounds)); + + res->closed = p->closed; + + return res; + +error: + if (res != NULL) { + free(res->pts); + free(res); + } + return NULL; +} + +void nsvgDelete(NSVGimage* image) +{ + NSVGshape *snext, *shape; + if (image == NULL) return; + shape = image->shapes; + while (shape != NULL) { + snext = shape->next; + nsvg__deletePaths(shape->paths); + nsvg__deletePaint(&shape->fill); + nsvg__deletePaint(&shape->stroke); + free(shape); + shape = snext; + } + free(image); +} + +#endif // NANOSVG_IMPLEMENTATION + +#endif // NANOSVG_H + diff --git a/tests/data/c/nanosvg/nanosvgrast.h b/tests/data/c/nanosvg/nanosvgrast.h new file mode 100644 index 000000000..6f6414e78 --- /dev/null +++ b/tests/data/c/nanosvg/nanosvgrast.h @@ -0,0 +1,1473 @@ +/* + * Copyright (c) 2013-14 Mikko Mononen memon@inside.org + * + * This software is provided 'as-is', without any express or implied + * warranty. In no event will the authors be held liable for any damages + * arising from the use of this software. + * + * Permission is granted to anyone to use this software for any purpose, + * including commercial applications, and to alter it and redistribute it + * freely, subject to the following restrictions: + * + * 1. The origin of this software must not be misrepresented; you must not + * claim that you wrote the original software. If you use this software + * in a product, an acknowledgment in the product documentation would be + * appreciated but is not required. + * 2. Altered source versions must be plainly marked as such, and must not be + * misrepresented as being the original software. + * 3. This notice may not be removed or altered from any source distribution. + * + * The polygon rasterization is heavily based on stb_truetype rasterizer + * by Sean Barrett - http://nothings.org/ + * + */ + +#ifndef NANOSVGRAST_H +#define NANOSVGRAST_H + +#include "nanosvg.h" + +#ifndef NANOSVGRAST_CPLUSPLUS +#ifdef __cplusplus +extern "C" { +#endif +#endif + +typedef struct NSVGrasterizer NSVGrasterizer; + +/* Example Usage: + // Load SVG + NSVGimage* image; + image = nsvgParseFromFile("test.svg", "px", 96); + + // Create rasterizer (can be used to render multiple images). + struct NSVGrasterizer* rast = nsvgCreateRasterizer(); + // Allocate memory for image + unsigned char* img = malloc(w*h*4); + // Rasterize + nsvgRasterize(rast, image, 0,0,1, img, w, h, w*4); +*/ + +// Allocated rasterizer context. +NSVGrasterizer* nsvgCreateRasterizer(void); + +// Rasterizes SVG image, returns RGBA image (non-premultiplied alpha) +// r - pointer to rasterizer context +// image - pointer to image to rasterize +// tx,ty - image offset (applied after scaling) +// scale - image scale +// dst - pointer to destination image data, 4 bytes per pixel (RGBA) +// w - width of the image to render +// h - height of the image to render +// stride - number of bytes per scaleline in the destination buffer +void nsvgRasterize(NSVGrasterizer* r, + NSVGimage* image, float tx, float ty, float scale, + unsigned char* dst, int w, int h, int stride); + +// Deletes rasterizer context. +void nsvgDeleteRasterizer(NSVGrasterizer*); + + +#ifndef NANOSVGRAST_CPLUSPLUS +#ifdef __cplusplus +} +#endif +#endif + +#ifdef NANOSVGRAST_IMPLEMENTATION + +#include +#include +#include + +#define NSVG__SUBSAMPLES 5 +#define NSVG__FIXSHIFT 10 +#define NSVG__FIX (1 << NSVG__FIXSHIFT) +#define NSVG__FIXMASK (NSVG__FIX-1) +#define NSVG__MEMPAGE_SIZE 1024 + +typedef struct NSVGedge { + float x0,y0, x1,y1; + int dir; + struct NSVGedge* next; +} NSVGedge; + +typedef struct NSVGpoint { + float x, y; + float dx, dy; + float len; + float dmx, dmy; + unsigned char flags; +} NSVGpoint; + +typedef struct NSVGactiveEdge { + int x,dx; + float ey; + int dir; + struct NSVGactiveEdge *next; +} NSVGactiveEdge; + +typedef struct NSVGmemPage { + unsigned char mem[NSVG__MEMPAGE_SIZE]; + int size; + struct NSVGmemPage* next; +} NSVGmemPage; + +typedef struct NSVGcachedPaint { + signed char type; + char spread; + float xform[6]; + unsigned int colors[256]; +} NSVGcachedPaint; + +struct NSVGrasterizer +{ + float px, py; + + float tessTol; + float distTol; + + NSVGedge* edges; + int nedges; + int cedges; + + NSVGpoint* points; + int npoints; + int cpoints; + + NSVGpoint* points2; + int npoints2; + int cpoints2; + + NSVGactiveEdge* freelist; + NSVGmemPage* pages; + NSVGmemPage* curpage; + + unsigned char* scanline; + int cscanline; + + unsigned char* bitmap; + int width, height, stride; +}; + +NSVGrasterizer* nsvgCreateRasterizer(void) +{ + NSVGrasterizer* r = (NSVGrasterizer*)malloc(sizeof(NSVGrasterizer)); + if (r == NULL) goto error; + memset(r, 0, sizeof(NSVGrasterizer)); + + r->tessTol = 0.25f; + r->distTol = 0.01f; + + return r; + +error: + nsvgDeleteRasterizer(r); + return NULL; +} + +void nsvgDeleteRasterizer(NSVGrasterizer* r) +{ + NSVGmemPage* p; + + if (r == NULL) return; + + p = r->pages; + while (p != NULL) { + NSVGmemPage* next = p->next; + free(p); + p = next; + } + + if (r->edges) free(r->edges); + if (r->points) free(r->points); + if (r->points2) free(r->points2); + if (r->scanline) free(r->scanline); + + free(r); +} + +static NSVGmemPage* nsvg__nextPage(NSVGrasterizer* r, NSVGmemPage* cur) +{ + NSVGmemPage *newp; + + // If using existing chain, return the next page in chain + if (cur != NULL && cur->next != NULL) { + return cur->next; + } + + // Alloc new page + newp = (NSVGmemPage*)malloc(sizeof(NSVGmemPage)); + if (newp == NULL) return NULL; + memset(newp, 0, sizeof(NSVGmemPage)); + + // Add to linked list + if (cur != NULL) + cur->next = newp; + else + r->pages = newp; + + return newp; +} + +static void nsvg__resetPool(NSVGrasterizer* r) +{ + NSVGmemPage* p = r->pages; + while (p != NULL) { + p->size = 0; + p = p->next; + } + r->curpage = r->pages; +} + +static unsigned char* nsvg__alloc(NSVGrasterizer* r, int size) +{ + unsigned char* buf; + if (size > NSVG__MEMPAGE_SIZE) return NULL; + if (r->curpage == NULL || r->curpage->size+size > NSVG__MEMPAGE_SIZE) { + r->curpage = nsvg__nextPage(r, r->curpage); + } + buf = &r->curpage->mem[r->curpage->size]; + r->curpage->size += size; + return buf; +} + +static int nsvg__ptEquals(float x1, float y1, float x2, float y2, float tol) +{ + float dx = x2 - x1; + float dy = y2 - y1; + return dx*dx + dy*dy < tol*tol; +} + +static void nsvg__addPathPoint(NSVGrasterizer* r, float x, float y, int flags) +{ + NSVGpoint* pt; + + if (r->npoints > 0) { + pt = &r->points[r->npoints-1]; + if (nsvg__ptEquals(pt->x,pt->y, x,y, r->distTol)) { + pt->flags = (unsigned char)(pt->flags | flags); + return; + } + } + + if (r->npoints+1 > r->cpoints) { + r->cpoints = r->cpoints > 0 ? r->cpoints * 2 : 64; + r->points = (NSVGpoint*)realloc(r->points, sizeof(NSVGpoint) * r->cpoints); + if (r->points == NULL) return; + } + + pt = &r->points[r->npoints]; + pt->x = x; + pt->y = y; + pt->flags = (unsigned char)flags; + r->npoints++; +} + +static void nsvg__appendPathPoint(NSVGrasterizer* r, NSVGpoint pt) +{ + if (r->npoints+1 > r->cpoints) { + r->cpoints = r->cpoints > 0 ? r->cpoints * 2 : 64; + r->points = (NSVGpoint*)realloc(r->points, sizeof(NSVGpoint) * r->cpoints); + if (r->points == NULL) return; + } + r->points[r->npoints] = pt; + r->npoints++; +} + +static void nsvg__duplicatePoints(NSVGrasterizer* r) +{ + if (r->npoints > r->cpoints2) { + r->cpoints2 = r->npoints; + r->points2 = (NSVGpoint*)realloc(r->points2, sizeof(NSVGpoint) * r->cpoints2); + if (r->points2 == NULL) return; + } + + memcpy(r->points2, r->points, sizeof(NSVGpoint) * r->npoints); + r->npoints2 = r->npoints; +} + +static void nsvg__addEdge(NSVGrasterizer* r, float x0, float y0, float x1, float y1) +{ + NSVGedge* e; + + // Skip horizontal edges + if (y0 == y1) + return; + + if (r->nedges+1 > r->cedges) { + r->cedges = r->cedges > 0 ? r->cedges * 2 : 64; + r->edges = (NSVGedge*)realloc(r->edges, sizeof(NSVGedge) * r->cedges); + if (r->edges == NULL) return; + } + + e = &r->edges[r->nedges]; + r->nedges++; + + if (y0 < y1) { + e->x0 = x0; + e->y0 = y0; + e->x1 = x1; + e->y1 = y1; + e->dir = 1; + } else { + e->x0 = x1; + e->y0 = y1; + e->x1 = x0; + e->y1 = y0; + e->dir = -1; + } +} + +static float nsvg__normalize(float *x, float* y) +{ + float d = sqrtf((*x)*(*x) + (*y)*(*y)); + if (d > 1e-6f) { + float id = 1.0f / d; + *x *= id; + *y *= id; + } + return d; +} + +static float nsvg__absf(float x) { return x < 0 ? -x : x; } +static float nsvg__roundf(float x) { return (x >= 0) ? floorf(x + 0.5) : ceilf(x - 0.5); } + +static void nsvg__flattenCubicBez(NSVGrasterizer* r, + float x1, float y1, float x2, float y2, + float x3, float y3, float x4, float y4, + int level, int type) +{ + float x12,y12,x23,y23,x34,y34,x123,y123,x234,y234,x1234,y1234; + float dx,dy,d2,d3; + + if (level > 10) return; + + x12 = (x1+x2)*0.5f; + y12 = (y1+y2)*0.5f; + x23 = (x2+x3)*0.5f; + y23 = (y2+y3)*0.5f; + x34 = (x3+x4)*0.5f; + y34 = (y3+y4)*0.5f; + x123 = (x12+x23)*0.5f; + y123 = (y12+y23)*0.5f; + + dx = x4 - x1; + dy = y4 - y1; + d2 = nsvg__absf((x2 - x4) * dy - (y2 - y4) * dx); + d3 = nsvg__absf((x3 - x4) * dy - (y3 - y4) * dx); + + if ((d2 + d3)*(d2 + d3) < r->tessTol * (dx*dx + dy*dy)) { + nsvg__addPathPoint(r, x4, y4, type); + return; + } + + x234 = (x23+x34)*0.5f; + y234 = (y23+y34)*0.5f; + x1234 = (x123+x234)*0.5f; + y1234 = (y123+y234)*0.5f; + + nsvg__flattenCubicBez(r, x1,y1, x12,y12, x123,y123, x1234,y1234, level+1, 0); + nsvg__flattenCubicBez(r, x1234,y1234, x234,y234, x34,y34, x4,y4, level+1, type); +} + +static void nsvg__flattenShape(NSVGrasterizer* r, NSVGshape* shape, float scale) +{ + int i, j; + NSVGpath* path; + + for (path = shape->paths; path != NULL; path = path->next) { + r->npoints = 0; + // Flatten path + nsvg__addPathPoint(r, path->pts[0]*scale, path->pts[1]*scale, 0); + for (i = 0; i < path->npts-1; i += 3) { + float* p = &path->pts[i*2]; + nsvg__flattenCubicBez(r, p[0]*scale,p[1]*scale, p[2]*scale,p[3]*scale, p[4]*scale,p[5]*scale, p[6]*scale,p[7]*scale, 0, 0); + } + // Close path + nsvg__addPathPoint(r, path->pts[0]*scale, path->pts[1]*scale, 0); + // Build edges + for (i = 0, j = r->npoints-1; i < r->npoints; j = i++) + nsvg__addEdge(r, r->points[j].x, r->points[j].y, r->points[i].x, r->points[i].y); + } +} + +enum NSVGpointFlags +{ + NSVG_PT_CORNER = 0x01, + NSVG_PT_BEVEL = 0x02, + NSVG_PT_LEFT = 0x04 +}; + +static void nsvg__initClosed(NSVGpoint* left, NSVGpoint* right, NSVGpoint* p0, NSVGpoint* p1, float lineWidth) +{ + float w = lineWidth * 0.5f; + float dx = p1->x - p0->x; + float dy = p1->y - p0->y; + float len = nsvg__normalize(&dx, &dy); + float px = p0->x + dx*len*0.5f, py = p0->y + dy*len*0.5f; + float dlx = dy, dly = -dx; + float lx = px - dlx*w, ly = py - dly*w; + float rx = px + dlx*w, ry = py + dly*w; + left->x = lx; left->y = ly; + right->x = rx; right->y = ry; +} + +static void nsvg__buttCap(NSVGrasterizer* r, NSVGpoint* left, NSVGpoint* right, NSVGpoint* p, float dx, float dy, float lineWidth, int connect) +{ + float w = lineWidth * 0.5f; + float px = p->x, py = p->y; + float dlx = dy, dly = -dx; + float lx = px - dlx*w, ly = py - dly*w; + float rx = px + dlx*w, ry = py + dly*w; + + nsvg__addEdge(r, lx, ly, rx, ry); + + if (connect) { + nsvg__addEdge(r, left->x, left->y, lx, ly); + nsvg__addEdge(r, rx, ry, right->x, right->y); + } + left->x = lx; left->y = ly; + right->x = rx; right->y = ry; +} + +static void nsvg__squareCap(NSVGrasterizer* r, NSVGpoint* left, NSVGpoint* right, NSVGpoint* p, float dx, float dy, float lineWidth, int connect) +{ + float w = lineWidth * 0.5f; + float px = p->x - dx*w, py = p->y - dy*w; + float dlx = dy, dly = -dx; + float lx = px - dlx*w, ly = py - dly*w; + float rx = px + dlx*w, ry = py + dly*w; + + nsvg__addEdge(r, lx, ly, rx, ry); + + if (connect) { + nsvg__addEdge(r, left->x, left->y, lx, ly); + nsvg__addEdge(r, rx, ry, right->x, right->y); + } + left->x = lx; left->y = ly; + right->x = rx; right->y = ry; +} + +#ifndef NSVG_PI +#define NSVG_PI (3.14159265358979323846264338327f) +#endif + +static void nsvg__roundCap(NSVGrasterizer* r, NSVGpoint* left, NSVGpoint* right, NSVGpoint* p, float dx, float dy, float lineWidth, int ncap, int connect) +{ + int i; + float w = lineWidth * 0.5f; + float px = p->x, py = p->y; + float dlx = dy, dly = -dx; + float lx = 0, ly = 0, rx = 0, ry = 0, prevx = 0, prevy = 0; + + for (i = 0; i < ncap; i++) { + float a = (float)i/(float)(ncap-1)*NSVG_PI; + float ax = cosf(a) * w, ay = sinf(a) * w; + float x = px - dlx*ax - dx*ay; + float y = py - dly*ax - dy*ay; + + if (i > 0) + nsvg__addEdge(r, prevx, prevy, x, y); + + prevx = x; + prevy = y; + + if (i == 0) { + lx = x; ly = y; + } else if (i == ncap-1) { + rx = x; ry = y; + } + } + + if (connect) { + nsvg__addEdge(r, left->x, left->y, lx, ly); + nsvg__addEdge(r, rx, ry, right->x, right->y); + } + + left->x = lx; left->y = ly; + right->x = rx; right->y = ry; +} + +static void nsvg__bevelJoin(NSVGrasterizer* r, NSVGpoint* left, NSVGpoint* right, NSVGpoint* p0, NSVGpoint* p1, float lineWidth) +{ + float w = lineWidth * 0.5f; + float dlx0 = p0->dy, dly0 = -p0->dx; + float dlx1 = p1->dy, dly1 = -p1->dx; + float lx0 = p1->x - (dlx0 * w), ly0 = p1->y - (dly0 * w); + float rx0 = p1->x + (dlx0 * w), ry0 = p1->y + (dly0 * w); + float lx1 = p1->x - (dlx1 * w), ly1 = p1->y - (dly1 * w); + float rx1 = p1->x + (dlx1 * w), ry1 = p1->y + (dly1 * w); + + nsvg__addEdge(r, lx0, ly0, left->x, left->y); + nsvg__addEdge(r, lx1, ly1, lx0, ly0); + + nsvg__addEdge(r, right->x, right->y, rx0, ry0); + nsvg__addEdge(r, rx0, ry0, rx1, ry1); + + left->x = lx1; left->y = ly1; + right->x = rx1; right->y = ry1; +} + +static void nsvg__miterJoin(NSVGrasterizer* r, NSVGpoint* left, NSVGpoint* right, NSVGpoint* p0, NSVGpoint* p1, float lineWidth) +{ + float w = lineWidth * 0.5f; + float dlx0 = p0->dy, dly0 = -p0->dx; + float dlx1 = p1->dy, dly1 = -p1->dx; + float lx0, rx0, lx1, rx1; + float ly0, ry0, ly1, ry1; + + if (p1->flags & NSVG_PT_LEFT) { + lx0 = lx1 = p1->x - p1->dmx * w; + ly0 = ly1 = p1->y - p1->dmy * w; + nsvg__addEdge(r, lx1, ly1, left->x, left->y); + + rx0 = p1->x + (dlx0 * w); + ry0 = p1->y + (dly0 * w); + rx1 = p1->x + (dlx1 * w); + ry1 = p1->y + (dly1 * w); + nsvg__addEdge(r, right->x, right->y, rx0, ry0); + nsvg__addEdge(r, rx0, ry0, rx1, ry1); + } else { + lx0 = p1->x - (dlx0 * w); + ly0 = p1->y - (dly0 * w); + lx1 = p1->x - (dlx1 * w); + ly1 = p1->y - (dly1 * w); + nsvg__addEdge(r, lx0, ly0, left->x, left->y); + nsvg__addEdge(r, lx1, ly1, lx0, ly0); + + rx0 = rx1 = p1->x + p1->dmx * w; + ry0 = ry1 = p1->y + p1->dmy * w; + nsvg__addEdge(r, right->x, right->y, rx1, ry1); + } + + left->x = lx1; left->y = ly1; + right->x = rx1; right->y = ry1; +} + +static void nsvg__roundJoin(NSVGrasterizer* r, NSVGpoint* left, NSVGpoint* right, NSVGpoint* p0, NSVGpoint* p1, float lineWidth, int ncap) +{ + int i, n; + float w = lineWidth * 0.5f; + float dlx0 = p0->dy, dly0 = -p0->dx; + float dlx1 = p1->dy, dly1 = -p1->dx; + float a0 = atan2f(dly0, dlx0); + float a1 = atan2f(dly1, dlx1); + float da = a1 - a0; + float lx, ly, rx, ry; + + if (da < NSVG_PI) da += NSVG_PI*2; + if (da > NSVG_PI) da -= NSVG_PI*2; + + n = (int)ceilf((nsvg__absf(da) / NSVG_PI) * (float)ncap); + if (n < 2) n = 2; + if (n > ncap) n = ncap; + + lx = left->x; + ly = left->y; + rx = right->x; + ry = right->y; + + for (i = 0; i < n; i++) { + float u = (float)i/(float)(n-1); + float a = a0 + u*da; + float ax = cosf(a) * w, ay = sinf(a) * w; + float lx1 = p1->x - ax, ly1 = p1->y - ay; + float rx1 = p1->x + ax, ry1 = p1->y + ay; + + nsvg__addEdge(r, lx1, ly1, lx, ly); + nsvg__addEdge(r, rx, ry, rx1, ry1); + + lx = lx1; ly = ly1; + rx = rx1; ry = ry1; + } + + left->x = lx; left->y = ly; + right->x = rx; right->y = ry; +} + +static void nsvg__straightJoin(NSVGrasterizer* r, NSVGpoint* left, NSVGpoint* right, NSVGpoint* p1, float lineWidth) +{ + float w = lineWidth * 0.5f; + float lx = p1->x - (p1->dmx * w), ly = p1->y - (p1->dmy * w); + float rx = p1->x + (p1->dmx * w), ry = p1->y + (p1->dmy * w); + + nsvg__addEdge(r, lx, ly, left->x, left->y); + nsvg__addEdge(r, right->x, right->y, rx, ry); + + left->x = lx; left->y = ly; + right->x = rx; right->y = ry; +} + +static int nsvg__curveDivs(float r, float arc, float tol) +{ + float da = acosf(r / (r + tol)) * 2.0f; + int divs = (int)ceilf(arc / da); + if (divs < 2) divs = 2; + return divs; +} + +static void nsvg__expandStroke(NSVGrasterizer* r, NSVGpoint* points, int npoints, int closed, int lineJoin, int lineCap, float lineWidth) +{ + int ncap = nsvg__curveDivs(lineWidth*0.5f, NSVG_PI, r->tessTol); // Calculate divisions per half circle. + NSVGpoint left = {0,0,0,0,0,0,0,0}, right = {0,0,0,0,0,0,0,0}, firstLeft = {0,0,0,0,0,0,0,0}, firstRight = {0,0,0,0,0,0,0,0}; + NSVGpoint* p0, *p1; + int j, s, e; + + // Build stroke edges + if (closed) { + // Looping + p0 = &points[npoints-1]; + p1 = &points[0]; + s = 0; + e = npoints; + } else { + // Add cap + p0 = &points[0]; + p1 = &points[1]; + s = 1; + e = npoints-1; + } + + if (closed) { + nsvg__initClosed(&left, &right, p0, p1, lineWidth); + firstLeft = left; + firstRight = right; + } else { + // Add cap + float dx = p1->x - p0->x; + float dy = p1->y - p0->y; + nsvg__normalize(&dx, &dy); + if (lineCap == NSVG_CAP_BUTT) + nsvg__buttCap(r, &left, &right, p0, dx, dy, lineWidth, 0); + else if (lineCap == NSVG_CAP_SQUARE) + nsvg__squareCap(r, &left, &right, p0, dx, dy, lineWidth, 0); + else if (lineCap == NSVG_CAP_ROUND) + nsvg__roundCap(r, &left, &right, p0, dx, dy, lineWidth, ncap, 0); + } + + for (j = s; j < e; ++j) { + if (p1->flags & NSVG_PT_CORNER) { + if (lineJoin == NSVG_JOIN_ROUND) + nsvg__roundJoin(r, &left, &right, p0, p1, lineWidth, ncap); + else if (lineJoin == NSVG_JOIN_BEVEL || (p1->flags & NSVG_PT_BEVEL)) + nsvg__bevelJoin(r, &left, &right, p0, p1, lineWidth); + else + nsvg__miterJoin(r, &left, &right, p0, p1, lineWidth); + } else { + nsvg__straightJoin(r, &left, &right, p1, lineWidth); + } + p0 = p1++; + } + + if (closed) { + // Loop it + nsvg__addEdge(r, firstLeft.x, firstLeft.y, left.x, left.y); + nsvg__addEdge(r, right.x, right.y, firstRight.x, firstRight.y); + } else { + // Add cap + float dx = p1->x - p0->x; + float dy = p1->y - p0->y; + nsvg__normalize(&dx, &dy); + if (lineCap == NSVG_CAP_BUTT) + nsvg__buttCap(r, &right, &left, p1, -dx, -dy, lineWidth, 1); + else if (lineCap == NSVG_CAP_SQUARE) + nsvg__squareCap(r, &right, &left, p1, -dx, -dy, lineWidth, 1); + else if (lineCap == NSVG_CAP_ROUND) + nsvg__roundCap(r, &right, &left, p1, -dx, -dy, lineWidth, ncap, 1); + } +} + +static void nsvg__prepareStroke(NSVGrasterizer* r, float miterLimit, int lineJoin) +{ + int i, j; + NSVGpoint* p0, *p1; + + p0 = &r->points[r->npoints-1]; + p1 = &r->points[0]; + for (i = 0; i < r->npoints; i++) { + // Calculate segment direction and length + p0->dx = p1->x - p0->x; + p0->dy = p1->y - p0->y; + p0->len = nsvg__normalize(&p0->dx, &p0->dy); + // Advance + p0 = p1++; + } + + // calculate joins + p0 = &r->points[r->npoints-1]; + p1 = &r->points[0]; + for (j = 0; j < r->npoints; j++) { + float dlx0, dly0, dlx1, dly1, dmr2, cross; + dlx0 = p0->dy; + dly0 = -p0->dx; + dlx1 = p1->dy; + dly1 = -p1->dx; + // Calculate extrusions + p1->dmx = (dlx0 + dlx1) * 0.5f; + p1->dmy = (dly0 + dly1) * 0.5f; + dmr2 = p1->dmx*p1->dmx + p1->dmy*p1->dmy; + if (dmr2 > 0.000001f) { + float s2 = 1.0f / dmr2; + if (s2 > 600.0f) { + s2 = 600.0f; + } + p1->dmx *= s2; + p1->dmy *= s2; + } + + // Clear flags, but keep the corner. + p1->flags = (p1->flags & NSVG_PT_CORNER) ? NSVG_PT_CORNER : 0; + + // Keep track of left turns. + cross = p1->dx * p0->dy - p0->dx * p1->dy; + if (cross > 0.0f) + p1->flags |= NSVG_PT_LEFT; + + // Check to see if the corner needs to be beveled. + if (p1->flags & NSVG_PT_CORNER) { + if ((dmr2 * miterLimit*miterLimit) < 1.0f || lineJoin == NSVG_JOIN_BEVEL || lineJoin == NSVG_JOIN_ROUND) { + p1->flags |= NSVG_PT_BEVEL; + } + } + + p0 = p1++; + } +} + +static void nsvg__flattenShapeStroke(NSVGrasterizer* r, NSVGshape* shape, float scale) +{ + int i, j, closed; + NSVGpath* path; + NSVGpoint* p0, *p1; + float miterLimit = shape->miterLimit; + int lineJoin = shape->strokeLineJoin; + int lineCap = shape->strokeLineCap; + float lineWidth = shape->strokeWidth * scale; + + for (path = shape->paths; path != NULL; path = path->next) { + // Flatten path + r->npoints = 0; + nsvg__addPathPoint(r, path->pts[0]*scale, path->pts[1]*scale, NSVG_PT_CORNER); + for (i = 0; i < path->npts-1; i += 3) { + float* p = &path->pts[i*2]; + nsvg__flattenCubicBez(r, p[0]*scale,p[1]*scale, p[2]*scale,p[3]*scale, p[4]*scale,p[5]*scale, p[6]*scale,p[7]*scale, 0, NSVG_PT_CORNER); + } + if (r->npoints < 2) + continue; + + closed = path->closed; + + // If the first and last points are the same, remove the last, mark as closed path. + p0 = &r->points[r->npoints-1]; + p1 = &r->points[0]; + if (nsvg__ptEquals(p0->x,p0->y, p1->x,p1->y, r->distTol)) { + r->npoints--; + p0 = &r->points[r->npoints-1]; + closed = 1; + } + + if (shape->strokeDashCount > 0) { + int idash = 0, dashState = 1; + float totalDist = 0, dashLen, allDashLen, dashOffset; + NSVGpoint cur; + + if (closed) + nsvg__appendPathPoint(r, r->points[0]); + + // Duplicate points -> points2. + nsvg__duplicatePoints(r); + + r->npoints = 0; + cur = r->points2[0]; + nsvg__appendPathPoint(r, cur); + + // Figure out dash offset. + allDashLen = 0; + for (j = 0; j < shape->strokeDashCount; j++) + allDashLen += shape->strokeDashArray[j]; + if (shape->strokeDashCount & 1) + allDashLen *= 2.0f; + // Find location inside pattern + dashOffset = fmodf(shape->strokeDashOffset, allDashLen); + if (dashOffset < 0.0f) + dashOffset += allDashLen; + + while (dashOffset > shape->strokeDashArray[idash]) { + dashOffset -= shape->strokeDashArray[idash]; + idash = (idash + 1) % shape->strokeDashCount; + } + dashLen = (shape->strokeDashArray[idash] - dashOffset) * scale; + + for (j = 1; j < r->npoints2; ) { + float dx = r->points2[j].x - cur.x; + float dy = r->points2[j].y - cur.y; + float dist = sqrtf(dx*dx + dy*dy); + + if ((totalDist + dist) > dashLen) { + // Calculate intermediate point + float d = (dashLen - totalDist) / dist; + float x = cur.x + dx * d; + float y = cur.y + dy * d; + nsvg__addPathPoint(r, x, y, NSVG_PT_CORNER); + + // Stroke + if (r->npoints > 1 && dashState) { + nsvg__prepareStroke(r, miterLimit, lineJoin); + nsvg__expandStroke(r, r->points, r->npoints, 0, lineJoin, lineCap, lineWidth); + } + // Advance dash pattern + dashState = !dashState; + idash = (idash+1) % shape->strokeDashCount; + dashLen = shape->strokeDashArray[idash] * scale; + // Restart + cur.x = x; + cur.y = y; + cur.flags = NSVG_PT_CORNER; + totalDist = 0.0f; + r->npoints = 0; + nsvg__appendPathPoint(r, cur); + } else { + totalDist += dist; + cur = r->points2[j]; + nsvg__appendPathPoint(r, cur); + j++; + } + } + // Stroke any leftover path + if (r->npoints > 1 && dashState) { + nsvg__prepareStroke(r, miterLimit, lineJoin); + nsvg__expandStroke(r, r->points, r->npoints, 0, lineJoin, lineCap, lineWidth); + } + } else { + nsvg__prepareStroke(r, miterLimit, lineJoin); + nsvg__expandStroke(r, r->points, r->npoints, closed, lineJoin, lineCap, lineWidth); + } + } +} + +static int nsvg__cmpEdge(const void *p, const void *q) +{ + const NSVGedge* a = (const NSVGedge*)p; + const NSVGedge* b = (const NSVGedge*)q; + + if (a->y0 < b->y0) return -1; + if (a->y0 > b->y0) return 1; + return 0; +} + + +static NSVGactiveEdge* nsvg__addActive(NSVGrasterizer* r, NSVGedge* e, float startPoint) +{ + NSVGactiveEdge* z; + + if (r->freelist != NULL) { + // Restore from freelist. + z = r->freelist; + r->freelist = z->next; + } else { + // Alloc new edge. + z = (NSVGactiveEdge*)nsvg__alloc(r, sizeof(NSVGactiveEdge)); + if (z == NULL) return NULL; + } + + float dxdy = (e->x1 - e->x0) / (e->y1 - e->y0); +// STBTT_assert(e->y0 <= start_point); + // round dx down to avoid going too far + if (dxdy < 0) + z->dx = (int)(-nsvg__roundf(NSVG__FIX * -dxdy)); + else + z->dx = (int)nsvg__roundf(NSVG__FIX * dxdy); + z->x = (int)nsvg__roundf(NSVG__FIX * (e->x0 + dxdy * (startPoint - e->y0))); +// z->x -= off_x * FIX; + z->ey = e->y1; + z->next = 0; + z->dir = e->dir; + + return z; +} + +static void nsvg__freeActive(NSVGrasterizer* r, NSVGactiveEdge* z) +{ + z->next = r->freelist; + r->freelist = z; +} + +static void nsvg__fillScanline(unsigned char* scanline, int len, int x0, int x1, int maxWeight, int* xmin, int* xmax) +{ + int i = x0 >> NSVG__FIXSHIFT; + int j = x1 >> NSVG__FIXSHIFT; + if (i < *xmin) *xmin = i; + if (j > *xmax) *xmax = j; + if (i < len && j >= 0) { + if (i == j) { + // x0,x1 are the same pixel, so compute combined coverage + scanline[i] = (unsigned char)(scanline[i] + ((x1 - x0) * maxWeight >> NSVG__FIXSHIFT)); + } else { + if (i >= 0) // add antialiasing for x0 + scanline[i] = (unsigned char)(scanline[i] + (((NSVG__FIX - (x0 & NSVG__FIXMASK)) * maxWeight) >> NSVG__FIXSHIFT)); + else + i = -1; // clip + + if (j < len) // add antialiasing for x1 + scanline[j] = (unsigned char)(scanline[j] + (((x1 & NSVG__FIXMASK) * maxWeight) >> NSVG__FIXSHIFT)); + else + j = len; // clip + + for (++i; i < j; ++i) // fill pixels between x0 and x1 + scanline[i] = (unsigned char)(scanline[i] + maxWeight); + } + } +} + +// note: this routine clips fills that extend off the edges... ideally this +// wouldn't happen, but it could happen if the truetype glyph bounding boxes +// are wrong, or if the user supplies a too-small bitmap +static void nsvg__fillActiveEdges(unsigned char* scanline, int len, NSVGactiveEdge* e, int maxWeight, int* xmin, int* xmax, char fillRule) +{ + // non-zero winding fill + int x0 = 0, w = 0; + + if (fillRule == NSVG_FILLRULE_NONZERO) { + // Non-zero + while (e != NULL) { + if (w == 0) { + // if we're currently at zero, we need to record the edge start point + x0 = e->x; w += e->dir; + } else { + int x1 = e->x; w += e->dir; + // if we went to zero, we need to draw + if (w == 0) + nsvg__fillScanline(scanline, len, x0, x1, maxWeight, xmin, xmax); + } + e = e->next; + } + } else if (fillRule == NSVG_FILLRULE_EVENODD) { + // Even-odd + while (e != NULL) { + if (w == 0) { + // if we're currently at zero, we need to record the edge start point + x0 = e->x; w = 1; + } else { + int x1 = e->x; w = 0; + nsvg__fillScanline(scanline, len, x0, x1, maxWeight, xmin, xmax); + } + e = e->next; + } + } +} + +static float nsvg__clampf(float a, float mn, float mx) { + if (isnan(a)) + return mn; + return a < mn ? mn : (a > mx ? mx : a); +} + +static unsigned int nsvg__RGBA(unsigned char r, unsigned char g, unsigned char b, unsigned char a) +{ + return ((unsigned int)r) | ((unsigned int)g << 8) | ((unsigned int)b << 16) | ((unsigned int)a << 24); +} + +static unsigned int nsvg__lerpRGBA(unsigned int c0, unsigned int c1, float u) +{ + int iu = (int)(nsvg__clampf(u, 0.0f, 1.0f) * 256.0f); + int r = (((c0) & 0xff)*(256-iu) + (((c1) & 0xff)*iu)) >> 8; + int g = (((c0>>8) & 0xff)*(256-iu) + (((c1>>8) & 0xff)*iu)) >> 8; + int b = (((c0>>16) & 0xff)*(256-iu) + (((c1>>16) & 0xff)*iu)) >> 8; + int a = (((c0>>24) & 0xff)*(256-iu) + (((c1>>24) & 0xff)*iu)) >> 8; + return nsvg__RGBA((unsigned char)r, (unsigned char)g, (unsigned char)b, (unsigned char)a); +} + +static unsigned int nsvg__applyOpacity(unsigned int c, float u) +{ + int iu = (int)(nsvg__clampf(u, 0.0f, 1.0f) * 256.0f); + int r = (c) & 0xff; + int g = (c>>8) & 0xff; + int b = (c>>16) & 0xff; + int a = (((c>>24) & 0xff)*iu) >> 8; + return nsvg__RGBA((unsigned char)r, (unsigned char)g, (unsigned char)b, (unsigned char)a); +} + +static inline int nsvg__div255(int x) +{ + return ((x+1) * 257) >> 16; +} + +static void nsvg__scanlineSolid(unsigned char* dst, int count, unsigned char* cover, int x, int y, + float tx, float ty, float scale, NSVGcachedPaint* cache) +{ + + if (cache->type == NSVG_PAINT_COLOR) { + int i, cr, cg, cb, ca; + cr = cache->colors[0] & 0xff; + cg = (cache->colors[0] >> 8) & 0xff; + cb = (cache->colors[0] >> 16) & 0xff; + ca = (cache->colors[0] >> 24) & 0xff; + + for (i = 0; i < count; i++) { + int r,g,b; + int a = nsvg__div255((int)cover[0] * ca); + int ia = 255 - a; + // Premultiply + r = nsvg__div255(cr * a); + g = nsvg__div255(cg * a); + b = nsvg__div255(cb * a); + + // Blend over + r += nsvg__div255(ia * (int)dst[0]); + g += nsvg__div255(ia * (int)dst[1]); + b += nsvg__div255(ia * (int)dst[2]); + a += nsvg__div255(ia * (int)dst[3]); + + dst[0] = (unsigned char)r; + dst[1] = (unsigned char)g; + dst[2] = (unsigned char)b; + dst[3] = (unsigned char)a; + + cover++; + dst += 4; + } + } else if (cache->type == NSVG_PAINT_LINEAR_GRADIENT) { + // TODO: spread modes. + // TODO: plenty of opportunities to optimize. + float fx, fy, dx, gy; + float* t = cache->xform; + int i, cr, cg, cb, ca; + unsigned int c; + + fx = ((float)x - tx) / scale; + fy = ((float)y - ty) / scale; + dx = 1.0f / scale; + + for (i = 0; i < count; i++) { + int r,g,b,a,ia; + gy = fx*t[1] + fy*t[3] + t[5]; + c = cache->colors[(int)nsvg__clampf(gy*255.0f, 0, 255.0f)]; + cr = (c) & 0xff; + cg = (c >> 8) & 0xff; + cb = (c >> 16) & 0xff; + ca = (c >> 24) & 0xff; + + a = nsvg__div255((int)cover[0] * ca); + ia = 255 - a; + + // Premultiply + r = nsvg__div255(cr * a); + g = nsvg__div255(cg * a); + b = nsvg__div255(cb * a); + + // Blend over + r += nsvg__div255(ia * (int)dst[0]); + g += nsvg__div255(ia * (int)dst[1]); + b += nsvg__div255(ia * (int)dst[2]); + a += nsvg__div255(ia * (int)dst[3]); + + dst[0] = (unsigned char)r; + dst[1] = (unsigned char)g; + dst[2] = (unsigned char)b; + dst[3] = (unsigned char)a; + + cover++; + dst += 4; + fx += dx; + } + } else if (cache->type == NSVG_PAINT_RADIAL_GRADIENT) { + // TODO: spread modes. + // TODO: plenty of opportunities to optimize. + // TODO: focus (fx,fy) + float fx, fy, dx, gx, gy, gd; + float* t = cache->xform; + int i, cr, cg, cb, ca; + unsigned int c; + + fx = ((float)x - tx) / scale; + fy = ((float)y - ty) / scale; + dx = 1.0f / scale; + + for (i = 0; i < count; i++) { + int r,g,b,a,ia; + gx = fx*t[0] + fy*t[2] + t[4]; + gy = fx*t[1] + fy*t[3] + t[5]; + gd = sqrtf(gx*gx + gy*gy); + c = cache->colors[(int)nsvg__clampf(gd*255.0f, 0, 255.0f)]; + cr = (c) & 0xff; + cg = (c >> 8) & 0xff; + cb = (c >> 16) & 0xff; + ca = (c >> 24) & 0xff; + + a = nsvg__div255((int)cover[0] * ca); + ia = 255 - a; + + // Premultiply + r = nsvg__div255(cr * a); + g = nsvg__div255(cg * a); + b = nsvg__div255(cb * a); + + // Blend over + r += nsvg__div255(ia * (int)dst[0]); + g += nsvg__div255(ia * (int)dst[1]); + b += nsvg__div255(ia * (int)dst[2]); + a += nsvg__div255(ia * (int)dst[3]); + + dst[0] = (unsigned char)r; + dst[1] = (unsigned char)g; + dst[2] = (unsigned char)b; + dst[3] = (unsigned char)a; + + cover++; + dst += 4; + fx += dx; + } + } +} + +static void nsvg__rasterizeSortedEdges(NSVGrasterizer *r, float tx, float ty, float scale, NSVGcachedPaint* cache, char fillRule) +{ + NSVGactiveEdge *active = NULL; + int y, s; + int e = 0; + int maxWeight = (255 / NSVG__SUBSAMPLES); // weight per vertical scanline + int xmin, xmax; + + for (y = 0; y < r->height; y++) { + memset(r->scanline, 0, r->width); + xmin = r->width; + xmax = 0; + for (s = 0; s < NSVG__SUBSAMPLES; ++s) { + // find center of pixel for this scanline + float scany = (float)(y*NSVG__SUBSAMPLES + s) + 0.5f; + NSVGactiveEdge **step = &active; + + // update all active edges; + // remove all active edges that terminate before the center of this scanline + while (*step) { + NSVGactiveEdge *z = *step; + if (z->ey <= scany) { + *step = z->next; // delete from list +// NSVG__assert(z->valid); + nsvg__freeActive(r, z); + } else { + z->x += z->dx; // advance to position for current scanline + step = &((*step)->next); // advance through list + } + } + + // resort the list if needed + for (;;) { + int changed = 0; + step = &active; + while (*step && (*step)->next) { + if ((*step)->x > (*step)->next->x) { + NSVGactiveEdge* t = *step; + NSVGactiveEdge* q = t->next; + t->next = q->next; + q->next = t; + *step = q; + changed = 1; + } + step = &(*step)->next; + } + if (!changed) break; + } + + // insert all edges that start before the center of this scanline -- omit ones that also end on this scanline + while (e < r->nedges && r->edges[e].y0 <= scany) { + if (r->edges[e].y1 > scany) { + NSVGactiveEdge* z = nsvg__addActive(r, &r->edges[e], scany); + if (z == NULL) break; + // find insertion point + if (active == NULL) { + active = z; + } else if (z->x < active->x) { + // insert at front + z->next = active; + active = z; + } else { + // find thing to insert AFTER + NSVGactiveEdge* p = active; + while (p->next && p->next->x < z->x) + p = p->next; + // at this point, p->next->x is NOT < z->x + z->next = p->next; + p->next = z; + } + } + e++; + } + + // now process all active edges in non-zero fashion + if (active != NULL) + nsvg__fillActiveEdges(r->scanline, r->width, active, maxWeight, &xmin, &xmax, fillRule); + } + // Blit + if (xmin < 0) xmin = 0; + if (xmax > r->width-1) xmax = r->width-1; + if (xmin <= xmax) { + nsvg__scanlineSolid(&r->bitmap[y * r->stride] + xmin*4, xmax-xmin+1, &r->scanline[xmin], xmin, y, tx,ty, scale, cache); + } + } + +} + +static void nsvg__unpremultiplyAlpha(unsigned char* image, int w, int h, int stride) +{ + int x,y; + + // Unpremultiply + for (y = 0; y < h; y++) { + unsigned char *row = &image[y*stride]; + for (x = 0; x < w; x++) { + int r = row[0], g = row[1], b = row[2], a = row[3]; + if (a != 0) { + row[0] = (unsigned char)(r*255/a); + row[1] = (unsigned char)(g*255/a); + row[2] = (unsigned char)(b*255/a); + } + row += 4; + } + } + + // Defringe + for (y = 0; y < h; y++) { + unsigned char *row = &image[y*stride]; + for (x = 0; x < w; x++) { + int r = 0, g = 0, b = 0, a = row[3], n = 0; + if (a == 0) { + if (x-1 > 0 && row[-1] != 0) { + r += row[-4]; + g += row[-3]; + b += row[-2]; + n++; + } + if (x+1 < w && row[7] != 0) { + r += row[4]; + g += row[5]; + b += row[6]; + n++; + } + if (y-1 > 0 && row[-stride+3] != 0) { + r += row[-stride]; + g += row[-stride+1]; + b += row[-stride+2]; + n++; + } + if (y+1 < h && row[stride+3] != 0) { + r += row[stride]; + g += row[stride+1]; + b += row[stride+2]; + n++; + } + if (n > 0) { + row[0] = (unsigned char)(r/n); + row[1] = (unsigned char)(g/n); + row[2] = (unsigned char)(b/n); + } + } + row += 4; + } + } +} + + +static void nsvg__initPaint(NSVGcachedPaint* cache, NSVGpaint* paint, float opacity) +{ + int i, j; + NSVGgradient* grad; + + cache->type = paint->type; + + if (paint->type == NSVG_PAINT_COLOR) { + cache->colors[0] = nsvg__applyOpacity(paint->color, opacity); + return; + } + + grad = paint->gradient; + + cache->spread = grad->spread; + memcpy(cache->xform, grad->xform, sizeof(float)*6); + + if (grad->nstops == 0) { + for (i = 0; i < 256; i++) + cache->colors[i] = 0; + } else if (grad->nstops == 1) { + unsigned int color = nsvg__applyOpacity(grad->stops[0].color, opacity); + for (i = 0; i < 256; i++) + cache->colors[i] = color; + } else { + unsigned int ca, cb = 0; + float ua, ub, du, u; + int ia, ib, count; + + ca = nsvg__applyOpacity(grad->stops[0].color, opacity); + ua = nsvg__clampf(grad->stops[0].offset, 0, 1); + ub = nsvg__clampf(grad->stops[grad->nstops-1].offset, ua, 1); + ia = (int)(ua * 255.0f); + ib = (int)(ub * 255.0f); + for (i = 0; i < ia; i++) { + cache->colors[i] = ca; + } + + for (i = 0; i < grad->nstops-1; i++) { + ca = nsvg__applyOpacity(grad->stops[i].color, opacity); + cb = nsvg__applyOpacity(grad->stops[i+1].color, opacity); + ua = nsvg__clampf(grad->stops[i].offset, 0, 1); + ub = nsvg__clampf(grad->stops[i+1].offset, 0, 1); + ia = (int)(ua * 255.0f); + ib = (int)(ub * 255.0f); + count = ib - ia; + if (count <= 0) continue; + u = 0; + du = 1.0f / (float)count; + for (j = 0; j < count; j++) { + cache->colors[ia+j] = nsvg__lerpRGBA(ca,cb,u); + u += du; + } + } + + for (i = ib; i < 256; i++) + cache->colors[i] = cb; + } + +} + +/* +static void dumpEdges(NSVGrasterizer* r, const char* name) +{ + float xmin = 0, xmax = 0, ymin = 0, ymax = 0; + NSVGedge *e = NULL; + int i; + if (r->nedges == 0) return; + FILE* fp = fopen(name, "w"); + if (fp == NULL) return; + + xmin = xmax = r->edges[0].x0; + ymin = ymax = r->edges[0].y0; + for (i = 0; i < r->nedges; i++) { + e = &r->edges[i]; + xmin = nsvg__minf(xmin, e->x0); + xmin = nsvg__minf(xmin, e->x1); + xmax = nsvg__maxf(xmax, e->x0); + xmax = nsvg__maxf(xmax, e->x1); + ymin = nsvg__minf(ymin, e->y0); + ymin = nsvg__minf(ymin, e->y1); + ymax = nsvg__maxf(ymax, e->y0); + ymax = nsvg__maxf(ymax, e->y1); + } + + fprintf(fp, "", xmin, ymin, (xmax - xmin), (ymax - ymin)); + + for (i = 0; i < r->nedges; i++) { + e = &r->edges[i]; + fprintf(fp ,"", e->x0,e->y0, e->x1,e->y1); + } + + for (i = 0; i < r->npoints; i++) { + if (i+1 < r->npoints) + fprintf(fp ,"", r->points[i].x, r->points[i].y, r->points[i+1].x, r->points[i+1].y); + fprintf(fp ,"", r->points[i].x, r->points[i].y, r->points[i].flags == 0 ? "#f00" : "#0f0"); + } + + fprintf(fp, ""); + fclose(fp); +} +*/ + +void nsvgRasterize(NSVGrasterizer* r, + NSVGimage* image, float tx, float ty, float scale, + unsigned char* dst, int w, int h, int stride) +{ + NSVGshape *shape = NULL; + NSVGedge *e = NULL; + NSVGcachedPaint cache; + int i; + int j; + unsigned char paintOrder; + + r->bitmap = dst; + r->width = w; + r->height = h; + r->stride = stride; + + if (w > r->cscanline) { + r->cscanline = w; + r->scanline = (unsigned char*)realloc(r->scanline, w); + if (r->scanline == NULL) return; + } + + for (i = 0; i < h; i++) + memset(&dst[i*stride], 0, w*4); + + for (shape = image->shapes; shape != NULL; shape = shape->next) { + if (!(shape->flags & NSVG_FLAGS_VISIBLE)) + continue; + + for (j = 0; j < 3; j++) { + paintOrder = (shape->paintOrder >> (2 * j)) & 0x03; + + if (paintOrder == NSVG_PAINT_FILL && shape->fill.type != NSVG_PAINT_NONE) { + nsvg__resetPool(r); + r->freelist = NULL; + r->nedges = 0; + + nsvg__flattenShape(r, shape, scale); + + // Scale and translate edges + for (i = 0; i < r->nedges; i++) { + e = &r->edges[i]; + e->x0 = tx + e->x0; + e->y0 = (ty + e->y0) * NSVG__SUBSAMPLES; + e->x1 = tx + e->x1; + e->y1 = (ty + e->y1) * NSVG__SUBSAMPLES; + } + + // Rasterize edges + if (r->nedges != 0) + qsort(r->edges, r->nedges, sizeof(NSVGedge), nsvg__cmpEdge); + + // now, traverse the scanlines and find the intersections on each scanline, use non-zero rule + nsvg__initPaint(&cache, &shape->fill, shape->opacity); + + nsvg__rasterizeSortedEdges(r, tx,ty,scale, &cache, shape->fillRule); + } + if (paintOrder == NSVG_PAINT_STROKE && shape->stroke.type != NSVG_PAINT_NONE && (shape->strokeWidth * scale) > 0.01f) { + nsvg__resetPool(r); + r->freelist = NULL; + r->nedges = 0; + + nsvg__flattenShapeStroke(r, shape, scale); + + // dumpEdges(r, "edge.svg"); + + // Scale and translate edges + for (i = 0; i < r->nedges; i++) { + e = &r->edges[i]; + e->x0 = tx + e->x0; + e->y0 = (ty + e->y0) * NSVG__SUBSAMPLES; + e->x1 = tx + e->x1; + e->y1 = (ty + e->y1) * NSVG__SUBSAMPLES; + } + + // Rasterize edges + if (r->nedges != 0) + qsort(r->edges, r->nedges, sizeof(NSVGedge), nsvg__cmpEdge); + + // now, traverse the scanlines and find the intersections on each scanline, use non-zero rule + nsvg__initPaint(&cache, &shape->stroke, shape->opacity); + + nsvg__rasterizeSortedEdges(r, tx,ty,scale, &cache, NSVG_FILLRULE_NONZERO); + } + } + } + + nsvg__unpremultiplyAlpha(dst, w, h, stride); + + r->bitmap = NULL; + r->width = 0; + r->height = 0; + r->stride = 0; +} + +#endif // NANOSVGRAST_IMPLEMENTATION + +#endif // NANOSVGRAST_H + diff --git a/tests/data/c/stb/stb_c_lexer.h b/tests/data/c/stb/stb_c_lexer.h new file mode 100644 index 000000000..fd42f1c37 --- /dev/null +++ b/tests/data/c/stb/stb_c_lexer.h @@ -0,0 +1,941 @@ +// stb_c_lexer.h - v0.12 - public domain Sean Barrett 2013 +// lexer for making little C-like languages with recursive-descent parsers +// +// This file provides both the interface and the implementation. +// To instantiate the implementation, +// #define STB_C_LEXER_IMPLEMENTATION +// in *ONE* source file, before #including this file. +// +// The default configuration is fairly close to a C lexer, although +// suffixes on integer constants are not handled (you can override this). +// +// History: +// 0.12 fix compilation bug for NUL support; better support separate inclusion +// 0.11 fix clang static analysis warning +// 0.10 fix warnings +// 0.09 hex floats, no-stdlib fixes +// 0.08 fix bad pointer comparison +// 0.07 fix mishandling of hexadecimal constants parsed by strtol +// 0.06 fix missing next character after ending quote mark (Andreas Fredriksson) +// 0.05 refixed get_location because github version had lost the fix +// 0.04 fix octal parsing bug +// 0.03 added STB_C_LEX_DISCARD_PREPROCESSOR option +// refactor API to simplify (only one struct instead of two) +// change literal enum names to have 'lit' at the end +// 0.02 first public release +// +// Status: +// - haven't tested compiling as C++ +// - haven't tested the float parsing path +// - haven't tested the non-default-config paths (e.g. non-stdlib) +// - only tested default-config paths by eyeballing output of self-parse +// +// - haven't implemented multiline strings +// - haven't implemented octal/hex character constants +// - haven't implemented support for unicode CLEX_char +// - need to expand error reporting so you don't just get "CLEX_parse_error" +// +// Contributors: +// Arpad Goretity (bugfix) +// Alan Hickman (hex floats) +// github:mundusnine (bugfix) +// +// LICENSE +// +// See end of file for license information. + +#ifdef STB_C_LEXER_IMPLEMENTATION +#ifndef STB_C_LEXER_DEFINITIONS +// to change the default parsing rules, copy the following lines +// into your C/C++ file *before* including this, and then replace +// the Y's with N's for the ones you don't want. This needs to be +// set to the same values for every place in your program where +// stb_c_lexer.h is included. +// --BEGIN-- + +#if defined(Y) || defined(N) +#error "Can only use stb_c_lexer in contexts where the preprocessor symbols 'Y' and 'N' are not defined" +#endif + +#define STB_C_LEX_C_DECIMAL_INTS Y // "0|[1-9][0-9]*" CLEX_intlit +#define STB_C_LEX_C_HEX_INTS Y // "0x[0-9a-fA-F]+" CLEX_intlit +#define STB_C_LEX_C_OCTAL_INTS Y // "[0-7]+" CLEX_intlit +#define STB_C_LEX_C_DECIMAL_FLOATS Y // "[0-9]*(.[0-9]*([eE][-+]?[0-9]+)?) CLEX_floatlit +#define STB_C_LEX_C99_HEX_FLOATS N // "0x{hex}+(.{hex}*)?[pP][-+]?{hex}+ CLEX_floatlit +#define STB_C_LEX_C_IDENTIFIERS Y // "[_a-zA-Z][_a-zA-Z0-9]*" CLEX_id +#define STB_C_LEX_C_DQ_STRINGS Y // double-quote-delimited strings with escapes CLEX_dqstring +#define STB_C_LEX_C_SQ_STRINGS N // single-quote-delimited strings with escapes CLEX_ssstring +#define STB_C_LEX_C_CHARS Y // single-quote-delimited character with escape CLEX_charlits +#define STB_C_LEX_C_COMMENTS Y // "/* comment */" +#define STB_C_LEX_CPP_COMMENTS Y // "// comment to end of line\n" +#define STB_C_LEX_C_COMPARISONS Y // "==" CLEX_eq "!=" CLEX_noteq "<=" CLEX_lesseq ">=" CLEX_greatereq +#define STB_C_LEX_C_LOGICAL Y // "&&" CLEX_andand "||" CLEX_oror +#define STB_C_LEX_C_SHIFTS Y // "<<" CLEX_shl ">>" CLEX_shr +#define STB_C_LEX_C_INCREMENTS Y // "++" CLEX_plusplus "--" CLEX_minusminus +#define STB_C_LEX_C_ARROW Y // "->" CLEX_arrow +#define STB_C_LEX_EQUAL_ARROW N // "=>" CLEX_eqarrow +#define STB_C_LEX_C_BITWISEEQ Y // "&=" CLEX_andeq "|=" CLEX_oreq "^=" CLEX_xoreq +#define STB_C_LEX_C_ARITHEQ Y // "+=" CLEX_pluseq "-=" CLEX_minuseq + // "*=" CLEX_muleq "/=" CLEX_diveq "%=" CLEX_modeq + // if both STB_C_LEX_SHIFTS & STB_C_LEX_ARITHEQ: + // "<<=" CLEX_shleq ">>=" CLEX_shreq + +#define STB_C_LEX_PARSE_SUFFIXES N // letters after numbers are parsed as part of those numbers, and must be in suffix list below +#define STB_C_LEX_DECIMAL_SUFFIXES "" // decimal integer suffixes e.g. "uUlL" -- these are returned as-is in string storage +#define STB_C_LEX_HEX_SUFFIXES "" // e.g. "uUlL" +#define STB_C_LEX_OCTAL_SUFFIXES "" // e.g. "uUlL" +#define STB_C_LEX_FLOAT_SUFFIXES "" // + +#define STB_C_LEX_0_IS_EOF N // if Y, ends parsing at '\0'; if N, returns '\0' as token +#define STB_C_LEX_INTEGERS_AS_DOUBLES N // parses integers as doubles so they can be larger than 'int', but only if STB_C_LEX_STDLIB==N +#define STB_C_LEX_MULTILINE_DSTRINGS N // allow newlines in double-quoted strings +#define STB_C_LEX_MULTILINE_SSTRINGS N // allow newlines in single-quoted strings +#define STB_C_LEX_USE_STDLIB Y // use strtod,strtol for parsing #s; otherwise inaccurate hack +#define STB_C_LEX_DOLLAR_IDENTIFIER Y // allow $ as an identifier character +#define STB_C_LEX_FLOAT_NO_DECIMAL Y // allow floats that have no decimal point if they have an exponent + +#define STB_C_LEX_DEFINE_ALL_TOKEN_NAMES N // if Y, all CLEX_ token names are defined, even if never returned + // leaving it as N should help you catch config bugs + +#define STB_C_LEX_DISCARD_PREPROCESSOR Y // discard C-preprocessor directives (e.g. after prepocess + // still have #line, #pragma, etc) + +//#define STB_C_LEX_ISWHITE(str) ... // return length in bytes of whitespace characters if first char is whitespace + +#define STB_C_LEXER_DEFINITIONS // This line prevents the header file from replacing your definitions +// --END-- +#endif +#endif + +#ifndef INCLUDE_STB_C_LEXER_H +#define INCLUDE_STB_C_LEXER_H + +typedef struct +{ + // lexer variables + char *input_stream; + char *eof; + char *parse_point; + char *string_storage; + int string_storage_len; + + // lexer parse location for error messages + char *where_firstchar; + char *where_lastchar; + + // lexer token variables + long token; + double real_number; + long int_number; + char *string; + int string_len; +} stb_lexer; + +typedef struct +{ + int line_number; + int line_offset; +} stb_lex_location; + +#ifdef __cplusplus +extern "C" { +#endif + +extern void stb_c_lexer_init(stb_lexer *lexer, const char *input_stream, const char *input_stream_end, char *string_store, int store_length); +// this function initialize the 'lexer' structure +// Input: +// - input_stream points to the file to parse, loaded into memory +// - input_stream_end points to the end of the file, or NULL if you use 0-for-EOF +// - string_store is storage the lexer can use for storing parsed strings and identifiers +// - store_length is the length of that storage + +extern int stb_c_lexer_get_token(stb_lexer *lexer); +// this function returns non-zero if a token is parsed, or 0 if at EOF +// Output: +// - lexer->token is the token ID, which is unicode code point for a single-char token, < 0 for a multichar or eof or error +// - lexer->real_number is a double constant value for CLEX_floatlit, or CLEX_intlit if STB_C_LEX_INTEGERS_AS_DOUBLES +// - lexer->int_number is an integer constant for CLEX_intlit if !STB_C_LEX_INTEGERS_AS_DOUBLES, or character for CLEX_charlit +// - lexer->string is a 0-terminated string for CLEX_dqstring or CLEX_sqstring or CLEX_identifier +// - lexer->string_len is the byte length of lexer->string + +extern void stb_c_lexer_get_location(const stb_lexer *lexer, const char *where, stb_lex_location *loc); +// this inefficient function returns the line number and character offset of a +// given location in the file as returned by stb_lex_token. Because it's inefficient, +// you should only call it for errors, not for every token. +// For error messages of invalid tokens, you typically want the location of the start +// of the token (which caused the token to be invalid). For bugs involving legit +// tokens, you can report the first or the range. +// Output: +// - loc->line_number is the line number in the file, counting from 1, of the location +// - loc->line_offset is the char-offset in the line, counting from 0, of the location + + +#ifdef __cplusplus +} +#endif + +enum +{ + CLEX_eof = 256, + CLEX_parse_error, + CLEX_intlit , + CLEX_floatlit , + CLEX_id , + CLEX_dqstring , + CLEX_sqstring , + CLEX_charlit , + CLEX_eq , + CLEX_noteq , + CLEX_lesseq , + CLEX_greatereq , + CLEX_andand , + CLEX_oror , + CLEX_shl , + CLEX_shr , + CLEX_plusplus , + CLEX_minusminus , + CLEX_pluseq , + CLEX_minuseq , + CLEX_muleq , + CLEX_diveq , + CLEX_modeq , + CLEX_andeq , + CLEX_oreq , + CLEX_xoreq , + CLEX_arrow , + CLEX_eqarrow , + CLEX_shleq, CLEX_shreq, + + CLEX_first_unused_token + +}; +#endif // INCLUDE_STB_C_LEXER_H + +#ifdef STB_C_LEXER_IMPLEMENTATION + +// Hacky definitions so we can easily #if on them +#define Y(x) 1 +#define N(x) 0 + +#if STB_C_LEX_INTEGERS_AS_DOUBLES(x) +typedef double stb__clex_int; +#define intfield real_number +#define STB__clex_int_as_double +#else +typedef long stb__clex_int; +#define intfield int_number +#endif + +// Convert these config options to simple conditional #defines so we can more +// easily test them once we've change the meaning of Y/N + +#if STB_C_LEX_PARSE_SUFFIXES(x) +#define STB__clex_parse_suffixes +#endif + +#if STB_C_LEX_C99_HEX_FLOATS(x) +#define STB__clex_hex_floats +#endif + +#if STB_C_LEX_C_HEX_INTS(x) +#define STB__clex_hex_ints +#endif + +#if STB_C_LEX_C_DECIMAL_INTS(x) +#define STB__clex_decimal_ints +#endif + +#if STB_C_LEX_C_OCTAL_INTS(x) +#define STB__clex_octal_ints +#endif + +#if STB_C_LEX_C_DECIMAL_FLOATS(x) +#define STB__clex_decimal_floats +#endif + +#if STB_C_LEX_DISCARD_PREPROCESSOR(x) +#define STB__clex_discard_preprocessor +#endif + +#if STB_C_LEX_USE_STDLIB(x) && (!defined(STB__clex_hex_floats) || __STDC_VERSION__ >= 199901L) +#define STB__CLEX_use_stdlib +#include +#endif + +// Now for the rest of the file we'll use the basic definition where +// where Y expands to its contents and N expands to nothing +#undef Y +#define Y(a) a +#undef N +#define N(a) + +// API function +void stb_c_lexer_init(stb_lexer *lexer, const char *input_stream, const char *input_stream_end, char *string_store, int store_length) +{ + lexer->input_stream = (char *) input_stream; + lexer->eof = (char *) input_stream_end; + lexer->parse_point = (char *) input_stream; + lexer->string_storage = string_store; + lexer->string_storage_len = store_length; +} + +// API function +void stb_c_lexer_get_location(const stb_lexer *lexer, const char *where, stb_lex_location *loc) +{ + char *p = lexer->input_stream; + int line_number = 1; + int char_offset = 0; + while (*p && p < where) { + if (*p == '\n' || *p == '\r') { + p += (p[0]+p[1] == '\r'+'\n' ? 2 : 1); // skip newline + line_number += 1; + char_offset = 0; + } else { + ++p; + ++char_offset; + } + } + loc->line_number = line_number; + loc->line_offset = char_offset; +} + +// main helper function for returning a parsed token +static int stb__clex_token(stb_lexer *lexer, int token, char *start, char *end) +{ + lexer->token = token; + lexer->where_firstchar = start; + lexer->where_lastchar = end; + lexer->parse_point = end+1; + return 1; +} + +// helper function for returning eof +static int stb__clex_eof(stb_lexer *lexer) +{ + lexer->token = CLEX_eof; + return 0; +} + +static int stb__clex_iswhite(int x) +{ + return x == ' ' || x == '\t' || x == '\r' || x == '\n' || x == '\f'; +} + +static const char *stb__strchr(const char *str, int ch) +{ + for (; *str; ++str) + if (*str == ch) + return str; + return 0; +} + +// parse suffixes at the end of a number +static int stb__clex_parse_suffixes(stb_lexer *lexer, long tokenid, char *start, char *cur, const char *suffixes) +{ + #ifdef STB__clex_parse_suffixes + lexer->string = lexer->string_storage; + lexer->string_len = 0; + + while ((*cur >= 'a' && *cur <= 'z') || (*cur >= 'A' && *cur <= 'Z')) { + if (stb__strchr(suffixes, *cur) == 0) + return stb__clex_token(lexer, CLEX_parse_error, start, cur); + if (lexer->string_len+1 >= lexer->string_storage_len) + return stb__clex_token(lexer, CLEX_parse_error, start, cur); + lexer->string[lexer->string_len++] = *cur++; + } + #else + suffixes = suffixes; // attempt to suppress warnings + #endif + return stb__clex_token(lexer, tokenid, start, cur-1); +} + +#ifndef STB__CLEX_use_stdlib +static double stb__clex_pow(double base, unsigned int exponent) +{ + double value=1; + for ( ; exponent; exponent >>= 1) { + if (exponent & 1) + value *= base; + base *= base; + } + return value; +} + +static double stb__clex_parse_float(char *p, char **q) +{ + char *s = p; + double value=0; + int base=10; + int exponent=0; + +#ifdef STB__clex_hex_floats + if (*p == '0') { + if (p[1] == 'x' || p[1] == 'X') { + base=16; + p += 2; + } + } +#endif + + for (;;) { + if (*p >= '0' && *p <= '9') + value = value*base + (*p++ - '0'); +#ifdef STB__clex_hex_floats + else if (base == 16 && *p >= 'a' && *p <= 'f') + value = value*base + 10 + (*p++ - 'a'); + else if (base == 16 && *p >= 'A' && *p <= 'F') + value = value*base + 10 + (*p++ - 'A'); +#endif + else + break; + } + + if (*p == '.') { + double pow, addend = 0; + ++p; + for (pow=1; ; pow*=base) { + if (*p >= '0' && *p <= '9') + addend = addend*base + (*p++ - '0'); +#ifdef STB__clex_hex_floats + else if (base == 16 && *p >= 'a' && *p <= 'f') + addend = addend*base + 10 + (*p++ - 'a'); + else if (base == 16 && *p >= 'A' && *p <= 'F') + addend = addend*base + 10 + (*p++ - 'A'); +#endif + else + break; + } + value += addend / pow; + } +#ifdef STB__clex_hex_floats + if (base == 16) { + // exponent required for hex float literal + if (*p != 'p' && *p != 'P') { + *q = s; + return 0; + } + exponent = 1; + } else +#endif + exponent = (*p == 'e' || *p == 'E'); + + if (exponent) { + int sign = p[1] == '-'; + unsigned int exponent=0; + double power=1; + ++p; + if (*p == '-' || *p == '+') + ++p; + while (*p >= '0' && *p <= '9') + exponent = exponent*10 + (*p++ - '0'); + +#ifdef STB__clex_hex_floats + if (base == 16) + power = stb__clex_pow(2, exponent); + else +#endif + power = stb__clex_pow(10, exponent); + if (sign) + value /= power; + else + value *= power; + } + *q = p; + return value; +} +#endif + +static int stb__clex_parse_char(char *p, char **q) +{ + if (*p == '\\') { + *q = p+2; // tentatively guess we'll parse two characters + switch(p[1]) { + case '\\': return '\\'; + case '\'': return '\''; + case '"': return '"'; + case 't': return '\t'; + case 'f': return '\f'; + case 'n': return '\n'; + case 'r': return '\r'; + case '0': return '\0'; // @TODO ocatal constants + case 'x': case 'X': return -1; // @TODO hex constants + case 'u': return -1; // @TODO unicode constants + } + } + *q = p+1; + return (unsigned char) *p; +} + +static int stb__clex_parse_string(stb_lexer *lexer, char *p, int type) +{ + char *start = p; + char delim = *p++; // grab the " or ' for later matching + char *out = lexer->string_storage; + char *outend = lexer->string_storage + lexer->string_storage_len; + while (*p != delim) { + int n; + if (*p == '\\') { + char *q; + n = stb__clex_parse_char(p, &q); + if (n < 0) + return stb__clex_token(lexer, CLEX_parse_error, start, q); + p = q; + } else { + // @OPTIMIZE: could speed this up by looping-while-not-backslash + n = (unsigned char) *p++; + } + if (out+1 > outend) + return stb__clex_token(lexer, CLEX_parse_error, start, p); + // @TODO expand unicode escapes to UTF8 + *out++ = (char) n; + } + *out = 0; + lexer->string = lexer->string_storage; + lexer->string_len = (int) (out - lexer->string_storage); + return stb__clex_token(lexer, type, start, p); +} + +int stb_c_lexer_get_token(stb_lexer *lexer) +{ + char *p = lexer->parse_point; + + // skip whitespace and comments + for (;;) { + #ifdef STB_C_LEX_ISWHITE + while (p != lexer->stream_end) { + int n; + n = STB_C_LEX_ISWHITE(p); + if (n == 0) break; + if (lexer->eof && lexer->eof - lexer->parse_point < n) + return stb__clex_token(tok, CLEX_parse_error, p,lexer->eof-1); + p += n; + } + #else + while (p != lexer->eof && stb__clex_iswhite(*p)) + ++p; + #endif + + STB_C_LEX_CPP_COMMENTS( + if (p != lexer->eof && p[0] == '/' && p[1] == '/') { + while (p != lexer->eof && *p != '\r' && *p != '\n') + ++p; + continue; + } + ) + + STB_C_LEX_C_COMMENTS( + if (p != lexer->eof && p[0] == '/' && p[1] == '*') { + char *start = p; + p += 2; + while (p != lexer->eof && (p[0] != '*' || p[1] != '/')) + ++p; + if (p == lexer->eof) + return stb__clex_token(lexer, CLEX_parse_error, start, p-1); + p += 2; + continue; + } + ) + + #ifdef STB__clex_discard_preprocessor + // @TODO this discards everything after a '#', regardless + // of where in the line the # is, rather than requiring it + // be at the start. (because this parser doesn't otherwise + // check for line breaks!) + if (p != lexer->eof && p[0] == '#') { + while (p != lexer->eof && *p != '\r' && *p != '\n') + ++p; + continue; + } + #endif + + break; + } + + if (p == lexer->eof) + return stb__clex_eof(lexer); + + switch (*p) { + default: + if ( (*p >= 'a' && *p <= 'z') + || (*p >= 'A' && *p <= 'Z') + || *p == '_' || (unsigned char) *p >= 128 // >= 128 is UTF8 char + STB_C_LEX_DOLLAR_IDENTIFIER( || *p == '$' ) ) + { + int n = 0; + lexer->string = lexer->string_storage; + do { + if (n+1 >= lexer->string_storage_len) + return stb__clex_token(lexer, CLEX_parse_error, p, p+n); + lexer->string[n] = p[n]; + ++n; + } while ( + (p[n] >= 'a' && p[n] <= 'z') + || (p[n] >= 'A' && p[n] <= 'Z') + || (p[n] >= '0' && p[n] <= '9') // allow digits in middle of identifier + || p[n] == '_' || (unsigned char) p[n] >= 128 + STB_C_LEX_DOLLAR_IDENTIFIER( || p[n] == '$' ) + ); + lexer->string[n] = 0; + lexer->string_len = n; + return stb__clex_token(lexer, CLEX_id, p, p+n-1); + } + + // check for EOF + STB_C_LEX_0_IS_EOF( + if (*p == 0) + return stb__clex_eof(lexer); + ) + + single_char: + // not an identifier, return the character as itself + return stb__clex_token(lexer, *p, p, p); + + case '+': + if (p+1 != lexer->eof) { + STB_C_LEX_C_INCREMENTS(if (p[1] == '+') return stb__clex_token(lexer, CLEX_plusplus, p,p+1);) + STB_C_LEX_C_ARITHEQ( if (p[1] == '=') return stb__clex_token(lexer, CLEX_pluseq , p,p+1);) + } + goto single_char; + case '-': + if (p+1 != lexer->eof) { + STB_C_LEX_C_INCREMENTS(if (p[1] == '-') return stb__clex_token(lexer, CLEX_minusminus, p,p+1);) + STB_C_LEX_C_ARITHEQ( if (p[1] == '=') return stb__clex_token(lexer, CLEX_minuseq , p,p+1);) + STB_C_LEX_C_ARROW( if (p[1] == '>') return stb__clex_token(lexer, CLEX_arrow , p,p+1);) + } + goto single_char; + case '&': + if (p+1 != lexer->eof) { + STB_C_LEX_C_LOGICAL( if (p[1] == '&') return stb__clex_token(lexer, CLEX_andand, p,p+1);) + STB_C_LEX_C_BITWISEEQ(if (p[1] == '=') return stb__clex_token(lexer, CLEX_andeq , p,p+1);) + } + goto single_char; + case '|': + if (p+1 != lexer->eof) { + STB_C_LEX_C_LOGICAL( if (p[1] == '|') return stb__clex_token(lexer, CLEX_oror, p,p+1);) + STB_C_LEX_C_BITWISEEQ(if (p[1] == '=') return stb__clex_token(lexer, CLEX_oreq, p,p+1);) + } + goto single_char; + case '=': + if (p+1 != lexer->eof) { + STB_C_LEX_C_COMPARISONS(if (p[1] == '=') return stb__clex_token(lexer, CLEX_eq, p,p+1);) + STB_C_LEX_EQUAL_ARROW( if (p[1] == '>') return stb__clex_token(lexer, CLEX_eqarrow, p,p+1);) + } + goto single_char; + case '!': + STB_C_LEX_C_COMPARISONS(if (p+1 != lexer->eof && p[1] == '=') return stb__clex_token(lexer, CLEX_noteq, p,p+1);) + goto single_char; + case '^': + STB_C_LEX_C_BITWISEEQ(if (p+1 != lexer->eof && p[1] == '=') return stb__clex_token(lexer, CLEX_xoreq, p,p+1)); + goto single_char; + case '%': + STB_C_LEX_C_ARITHEQ(if (p+1 != lexer->eof && p[1] == '=') return stb__clex_token(lexer, CLEX_modeq, p,p+1)); + goto single_char; + case '*': + STB_C_LEX_C_ARITHEQ(if (p+1 != lexer->eof && p[1] == '=') return stb__clex_token(lexer, CLEX_muleq, p,p+1)); + goto single_char; + case '/': + STB_C_LEX_C_ARITHEQ(if (p+1 != lexer->eof && p[1] == '=') return stb__clex_token(lexer, CLEX_diveq, p,p+1)); + goto single_char; + case '<': + if (p+1 != lexer->eof) { + STB_C_LEX_C_COMPARISONS(if (p[1] == '=') return stb__clex_token(lexer, CLEX_lesseq, p,p+1);) + STB_C_LEX_C_SHIFTS( if (p[1] == '<') { + STB_C_LEX_C_ARITHEQ(if (p+2 != lexer->eof && p[2] == '=') + return stb__clex_token(lexer, CLEX_shleq, p,p+2);) + return stb__clex_token(lexer, CLEX_shl, p,p+1); + } + ) + } + goto single_char; + case '>': + if (p+1 != lexer->eof) { + STB_C_LEX_C_COMPARISONS(if (p[1] == '=') return stb__clex_token(lexer, CLEX_greatereq, p,p+1);) + STB_C_LEX_C_SHIFTS( if (p[1] == '>') { + STB_C_LEX_C_ARITHEQ(if (p+2 != lexer->eof && p[2] == '=') + return stb__clex_token(lexer, CLEX_shreq, p,p+2);) + return stb__clex_token(lexer, CLEX_shr, p,p+1); + } + ) + } + goto single_char; + + case '"': + STB_C_LEX_C_DQ_STRINGS(return stb__clex_parse_string(lexer, p, CLEX_dqstring);) + goto single_char; + case '\'': + STB_C_LEX_C_SQ_STRINGS(return stb__clex_parse_string(lexer, p, CLEX_sqstring);) + STB_C_LEX_C_CHARS( + { + char *start = p; + lexer->int_number = stb__clex_parse_char(p+1, &p); + if (lexer->int_number < 0) + return stb__clex_token(lexer, CLEX_parse_error, start,start); + if (p == lexer->eof || *p != '\'') + return stb__clex_token(lexer, CLEX_parse_error, start,p); + return stb__clex_token(lexer, CLEX_charlit, start, p+1); + }) + goto single_char; + + case '0': + #if defined(STB__clex_hex_ints) || defined(STB__clex_hex_floats) + if (p+1 != lexer->eof) { + if (p[1] == 'x' || p[1] == 'X') { + char *q; + + #ifdef STB__clex_hex_floats + for (q=p+2; + q != lexer->eof && ((*q >= '0' && *q <= '9') || (*q >= 'a' && *q <= 'f') || (*q >= 'A' && *q <= 'F')); + ++q); + if (q != lexer->eof) { + if (*q == '.' STB_C_LEX_FLOAT_NO_DECIMAL(|| *q == 'p' || *q == 'P')) { + #ifdef STB__CLEX_use_stdlib + lexer->real_number = strtod((char *) p, (char**) &q); + #else + lexer->real_number = stb__clex_parse_float(p, &q); + #endif + + if (p == q) + return stb__clex_token(lexer, CLEX_parse_error, p,q); + return stb__clex_parse_suffixes(lexer, CLEX_floatlit, p,q, STB_C_LEX_FLOAT_SUFFIXES); + + } + } + #endif // STB__CLEX_hex_floats + + #ifdef STB__clex_hex_ints + #ifdef STB__CLEX_use_stdlib + lexer->int_number = strtol((char *) p, (char **) &q, 16); + #else + { + stb__clex_int n=0; + for (q=p+2; q != lexer->eof; ++q) { + if (*q >= '0' && *q <= '9') + n = n*16 + (*q - '0'); + else if (*q >= 'a' && *q <= 'f') + n = n*16 + (*q - 'a') + 10; + else if (*q >= 'A' && *q <= 'F') + n = n*16 + (*q - 'A') + 10; + else + break; + } + lexer->int_number = n; + } + #endif + if (q == p+2) + return stb__clex_token(lexer, CLEX_parse_error, p-2,p-1); + return stb__clex_parse_suffixes(lexer, CLEX_intlit, p,q, STB_C_LEX_HEX_SUFFIXES); + #endif + } + } + #endif // defined(STB__clex_hex_ints) || defined(STB__clex_hex_floats) + // can't test for octal because we might parse '0.0' as float or as '0' '.' '0', + // so have to do float first + + /* FALL THROUGH */ + case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': + + #ifdef STB__clex_decimal_floats + { + char *q = p; + while (q != lexer->eof && (*q >= '0' && *q <= '9')) + ++q; + if (q != lexer->eof) { + if (*q == '.' STB_C_LEX_FLOAT_NO_DECIMAL(|| *q == 'e' || *q == 'E')) { + #ifdef STB__CLEX_use_stdlib + lexer->real_number = strtod((char *) p, (char**) &q); + #else + lexer->real_number = stb__clex_parse_float(p, &q); + #endif + + return stb__clex_parse_suffixes(lexer, CLEX_floatlit, p,q, STB_C_LEX_FLOAT_SUFFIXES); + + } + } + } + #endif // STB__clex_decimal_floats + + #ifdef STB__clex_octal_ints + if (p[0] == '0') { + char *q = p; + #ifdef STB__CLEX_use_stdlib + lexer->int_number = strtol((char *) p, (char **) &q, 8); + #else + stb__clex_int n=0; + while (q != lexer->eof) { + if (*q >= '0' && *q <= '7') + n = n*8 + (*q - '0'); + else + break; + ++q; + } + if (q != lexer->eof && (*q == '8' || *q=='9')) + return stb__clex_token(lexer, CLEX_parse_error, p, q); + lexer->int_number = n; + #endif + return stb__clex_parse_suffixes(lexer, CLEX_intlit, p,q, STB_C_LEX_OCTAL_SUFFIXES); + } + #endif // STB__clex_octal_ints + + #ifdef STB__clex_decimal_ints + { + char *q = p; + #ifdef STB__CLEX_use_stdlib + lexer->int_number = strtol((char *) p, (char **) &q, 10); + #else + stb__clex_int n=0; + while (q != lexer->eof) { + if (*q >= '0' && *q <= '9') + n = n*10 + (*q - '0'); + else + break; + ++q; + } + lexer->int_number = n; + #endif + return stb__clex_parse_suffixes(lexer, CLEX_intlit, p,q, STB_C_LEX_OCTAL_SUFFIXES); + } + #endif // STB__clex_decimal_ints + goto single_char; + } +} +#endif // STB_C_LEXER_IMPLEMENTATION + +#ifdef STB_C_LEXER_SELF_TEST +#define _CRT_SECURE_NO_WARNINGS +#include +#include + +static void print_token(stb_lexer *lexer) +{ + switch (lexer->token) { + case CLEX_id : printf("_%s", lexer->string); break; + case CLEX_eq : printf("=="); break; + case CLEX_noteq : printf("!="); break; + case CLEX_lesseq : printf("<="); break; + case CLEX_greatereq : printf(">="); break; + case CLEX_andand : printf("&&"); break; + case CLEX_oror : printf("||"); break; + case CLEX_shl : printf("<<"); break; + case CLEX_shr : printf(">>"); break; + case CLEX_plusplus : printf("++"); break; + case CLEX_minusminus: printf("--"); break; + case CLEX_arrow : printf("->"); break; + case CLEX_andeq : printf("&="); break; + case CLEX_oreq : printf("|="); break; + case CLEX_xoreq : printf("^="); break; + case CLEX_pluseq : printf("+="); break; + case CLEX_minuseq : printf("-="); break; + case CLEX_muleq : printf("*="); break; + case CLEX_diveq : printf("/="); break; + case CLEX_modeq : printf("%%="); break; + case CLEX_shleq : printf("<<="); break; + case CLEX_shreq : printf(">>="); break; + case CLEX_eqarrow : printf("=>"); break; + case CLEX_dqstring : printf("\"%s\"", lexer->string); break; + case CLEX_sqstring : printf("'\"%s\"'", lexer->string); break; + case CLEX_charlit : printf("'%s'", lexer->string); break; + #if defined(STB__clex_int_as_double) && !defined(STB__CLEX_use_stdlib) + case CLEX_intlit : printf("#%g", lexer->real_number); break; + #else + case CLEX_intlit : printf("#%ld", lexer->int_number); break; + #endif + case CLEX_floatlit : printf("%g", lexer->real_number); break; + default: + if (lexer->token >= 0 && lexer->token < 256) + printf("%c", (int) lexer->token); + else { + printf("<<>>\n", lexer->token); + } + break; + } +} + +/* Force a test +of parsing +multiline comments */ + +/*/ comment /*/ +/**/ extern /**/ + +void dummy(void) +{ + double some_floats[] = { + 1.0501, -10.4e12, 5E+10, +#if 0 // not supported in C++ or C-pre-99, so don't try to compile it, but let our parser test it + 0x1.0p+24, 0xff.FP-8, 0x1p-23, +#endif + 4. + }; + (void) sizeof(some_floats); + (void) some_floats[1]; + + printf("test %d",1); // https://github.com/nothings/stb/issues/13 +} + +int main(int argc, char **argv) +{ + FILE *f = fopen("stb_c_lexer.h","rb"); + char *text = (char *) malloc(1 << 20); + int len = f ? (int) fread(text, 1, 1<<20, f) : -1; + stb_lexer lex; + if (len < 0) { + fprintf(stderr, "Error opening file\n"); + free(text); + fclose(f); + return 1; + } + fclose(f); + + stb_c_lexer_init(&lex, text, text+len, (char *) malloc(0x10000), 0x10000); + while (stb_c_lexer_get_token(&lex)) { + if (lex.token == CLEX_parse_error) { + printf("\n<<>>\n"); + break; + } + print_token(&lex); + printf(" "); + } + return 0; +} +#endif +/* +------------------------------------------------------------------------------ +This software is available under 2 licenses -- choose whichever you prefer. +------------------------------------------------------------------------------ +ALTERNATIVE A - MIT License +Copyright (c) 2017 Sean Barrett +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is furnished to do +so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +------------------------------------------------------------------------------ +ALTERNATIVE B - Public Domain (www.unlicense.org) +This is free and unencumbered software released into the public domain. +Anyone is free to copy, modify, publish, use, compile, sell, or distribute this +software, either in source code form or as a compiled binary, for any purpose, +commercial or non-commercial, and by any means. +In jurisdictions that recognize copyright laws, the author or authors of this +software dedicate any and all copyright interest in the software to the public +domain. We make this dedication for the benefit of the public at large and to +the detriment of our heirs and successors. We intend this dedication to be an +overt act of relinquishment in perpetuity of all present and future rights to +this software under copyright law. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN +ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +------------------------------------------------------------------------------ +*/ diff --git a/tests/data/c/stb/stb_connected_components.h b/tests/data/c/stb/stb_connected_components.h new file mode 100644 index 000000000..f762f655d --- /dev/null +++ b/tests/data/c/stb/stb_connected_components.h @@ -0,0 +1,1049 @@ +// stb_connected_components - v0.96 - public domain connected components on grids +// http://github.com/nothings/stb +// +// Finds connected components on 2D grids for testing reachability between +// two points, with fast updates when changing reachability (e.g. on one machine +// it was typically 0.2ms w/ 1024x1024 grid). Each grid square must be "open" or +// "closed" (traversable or untraversable), and grid squares are only connected +// to their orthogonal neighbors, not diagonally. +// +// In one source file, create the implementation by doing something like this: +// +// #define STBCC_GRID_COUNT_X_LOG2 10 +// #define STBCC_GRID_COUNT_Y_LOG2 10 +// #define STB_CONNECTED_COMPONENTS_IMPLEMENTATION +// #include "stb_connected_components.h" +// +// The above creates an implementation that can run on maps up to 1024x1024. +// Map sizes must be a multiple of (1<<(LOG2/2)) on each axis (e.g. 32 if LOG2=10, +// 16 if LOG2=8, etc.) (You can just pad your map with untraversable space.) +// +// MEMORY USAGE +// +// Uses about 6-7 bytes per grid square (e.g. 7MB for a 1024x1024 grid). +// Uses a single worst-case allocation which you pass in. +// +// PERFORMANCE +// +// On a core i7-2700K at 3.5 Ghz, for a particular 1024x1024 map (map_03.png): +// +// Creating map : 44.85 ms +// Making one square traversable: 0.27 ms (average over 29,448 calls) +// Making one square untraversable: 0.23 ms (average over 30,123 calls) +// Reachability query: 0.00001 ms (average over 4,000,000 calls) +// +// On non-degenerate maps update time is O(N^0.5), but on degenerate maps like +// checkerboards or 50% random, update time is O(N^0.75) (~2ms on above machine). +// +// CHANGELOG +// +// 0.96 (2019-03-04) Fix warnings +// 0.95 (2016-10-16) Bugfix if multiple clumps in one cluster connect to same clump in another +// 0.94 (2016-04-17) Bugfix & optimize worst case (checkerboard & random) +// 0.93 (2016-04-16) Reduce memory by 10x for 1Kx1K map; small speedup +// 0.92 (2016-04-16) Compute sqrt(N) cluster size by default +// 0.91 (2016-04-15) Initial release +// +// TODO: +// - better API documentation +// - more comments +// - try re-integrating naive algorithm & compare performance +// - more optimized batching (current approach still recomputes local clumps many times) +// - function for setting a grid of squares at once (just use batching) +// +// LICENSE +// +// See end of file for license information. +// +// ALGORITHM +// +// The NxN grid map is split into sqrt(N) x sqrt(N) blocks called +// "clusters". Each cluster independently computes a set of connected +// components within that cluster (ignoring all connectivity out of +// that cluster) using a union-find disjoint set forest. This produces a bunch +// of locally connected components called "clumps". Each clump is (a) connected +// within its cluster, (b) does not directly connect to any other clumps in the +// cluster (though it may connect to them by paths that lead outside the cluster, +// but those are ignored at this step), and (c) maintains an adjacency list of +// all clumps in adjacent clusters that it _is_ connected to. Then a second +// union-find disjoint set forest is used to compute connected clumps +// globally, across the whole map. Reachability is then computed by +// finding which clump each input point belongs to, and checking whether +// those clumps are in the same "global" connected component. +// +// The above data structure can be updated efficiently; on a change +// of a single grid square on the map, only one cluster changes its +// purely-local state, so only one cluster needs its clumps fully +// recomputed. Clumps in adjacent clusters need their adjacency lists +// updated: first to remove all references to the old clumps in the +// rebuilt cluster, then to add new references to the new clumps. Both +// of these operations can use the existing "find which clump each input +// point belongs to" query to compute that adjacency information rapidly. + +#ifndef INCLUDE_STB_CONNECTED_COMPONENTS_H +#define INCLUDE_STB_CONNECTED_COMPONENTS_H + +#include + +typedef struct st_stbcc_grid stbcc_grid; + +#ifdef __cplusplus +extern "C" { +#endif + +////////////////////////////////////////////////////////////////////////////////////////// +// +// initialization +// + +// you allocate the grid data structure to this size (note that it will be very big!!!) +extern size_t stbcc_grid_sizeof(void); + +// initialize the grid, value of map[] is 0 = traversable, non-0 is solid +extern void stbcc_init_grid(stbcc_grid *g, unsigned char *map, int w, int h); + + +////////////////////////////////////////////////////////////////////////////////////////// +// +// main functionality +// + +// update a grid square state, 0 = traversable, non-0 is solid +// i can add a batch-update if it's needed +extern void stbcc_update_grid(stbcc_grid *g, int x, int y, int solid); + +// query if two grid squares are reachable from each other +extern int stbcc_query_grid_node_connection(stbcc_grid *g, int x1, int y1, int x2, int y2); + + +////////////////////////////////////////////////////////////////////////////////////////// +// +// bonus functions +// + +// wrap multiple stbcc_update_grid calls in these function to compute +// multiple updates more efficiently; cannot make queries inside batch +extern void stbcc_update_batch_begin(stbcc_grid *g); +extern void stbcc_update_batch_end(stbcc_grid *g); + +// query the grid data structure for whether a given square is open or not +extern int stbcc_query_grid_open(stbcc_grid *g, int x, int y); + +// get a unique id for the connected component this is in; it's not necessarily +// small, you'll need a hash table or something to remap it (or just use +extern unsigned int stbcc_get_unique_id(stbcc_grid *g, int x, int y); +#define STBCC_NULL_UNIQUE_ID 0xffffffff // returned for closed map squares + +#ifdef __cplusplus +} +#endif + +#endif // INCLUDE_STB_CONNECTED_COMPONENTS_H + +#ifdef STB_CONNECTED_COMPONENTS_IMPLEMENTATION + +#include +#include // memset + +#if !defined(STBCC_GRID_COUNT_X_LOG2) || !defined(STBCC_GRID_COUNT_Y_LOG2) + #error "You must define STBCC_GRID_COUNT_X_LOG2 and STBCC_GRID_COUNT_Y_LOG2 to define the max grid supported." +#endif + +#define STBCC__GRID_COUNT_X (1 << STBCC_GRID_COUNT_X_LOG2) +#define STBCC__GRID_COUNT_Y (1 << STBCC_GRID_COUNT_Y_LOG2) + +#define STBCC__MAP_STRIDE (1 << (STBCC_GRID_COUNT_X_LOG2-3)) + +#ifndef STBCC_CLUSTER_SIZE_X_LOG2 + #define STBCC_CLUSTER_SIZE_X_LOG2 (STBCC_GRID_COUNT_X_LOG2/2) // log2(sqrt(2^N)) = 1/2 * log2(2^N)) = 1/2 * N + #if STBCC_CLUSTER_SIZE_X_LOG2 > 6 + #undef STBCC_CLUSTER_SIZE_X_LOG2 + #define STBCC_CLUSTER_SIZE_X_LOG2 6 + #endif +#endif + +#ifndef STBCC_CLUSTER_SIZE_Y_LOG2 + #define STBCC_CLUSTER_SIZE_Y_LOG2 (STBCC_GRID_COUNT_Y_LOG2/2) + #if STBCC_CLUSTER_SIZE_Y_LOG2 > 6 + #undef STBCC_CLUSTER_SIZE_Y_LOG2 + #define STBCC_CLUSTER_SIZE_Y_LOG2 6 + #endif +#endif + +#define STBCC__CLUSTER_SIZE_X (1 << STBCC_CLUSTER_SIZE_X_LOG2) +#define STBCC__CLUSTER_SIZE_Y (1 << STBCC_CLUSTER_SIZE_Y_LOG2) + +#define STBCC__CLUSTER_COUNT_X_LOG2 (STBCC_GRID_COUNT_X_LOG2 - STBCC_CLUSTER_SIZE_X_LOG2) +#define STBCC__CLUSTER_COUNT_Y_LOG2 (STBCC_GRID_COUNT_Y_LOG2 - STBCC_CLUSTER_SIZE_Y_LOG2) + +#define STBCC__CLUSTER_COUNT_X (1 << STBCC__CLUSTER_COUNT_X_LOG2) +#define STBCC__CLUSTER_COUNT_Y (1 << STBCC__CLUSTER_COUNT_Y_LOG2) + +#if STBCC__CLUSTER_SIZE_X >= STBCC__GRID_COUNT_X || STBCC__CLUSTER_SIZE_Y >= STBCC__GRID_COUNT_Y + #error "STBCC_CLUSTER_SIZE_X/Y_LOG2 must be smaller than STBCC_GRID_COUNT_X/Y_LOG2" +#endif + +// worst case # of clumps per cluster +#define STBCC__MAX_CLUMPS_PER_CLUSTER_LOG2 (STBCC_CLUSTER_SIZE_X_LOG2 + STBCC_CLUSTER_SIZE_Y_LOG2-1) +#define STBCC__MAX_CLUMPS_PER_CLUSTER (1 << STBCC__MAX_CLUMPS_PER_CLUSTER_LOG2) +#define STBCC__MAX_CLUMPS (STBCC__MAX_CLUMPS_PER_CLUSTER * STBCC__CLUSTER_COUNT_X * STBCC__CLUSTER_COUNT_Y) +#define STBCC__NULL_CLUMPID STBCC__MAX_CLUMPS_PER_CLUSTER + +#define STBCC__CLUSTER_X_FOR_COORD_X(x) ((x) >> STBCC_CLUSTER_SIZE_X_LOG2) +#define STBCC__CLUSTER_Y_FOR_COORD_Y(y) ((y) >> STBCC_CLUSTER_SIZE_Y_LOG2) + +#define STBCC__MAP_BYTE_MASK(x,y) (1 << ((x) & 7)) +#define STBCC__MAP_BYTE(g,x,y) ((g)->map[y][(x) >> 3]) +#define STBCC__MAP_OPEN(g,x,y) (STBCC__MAP_BYTE(g,x,y) & STBCC__MAP_BYTE_MASK(x,y)) + +typedef unsigned short stbcc__clumpid; +typedef unsigned char stbcc__verify_max_clumps[STBCC__MAX_CLUMPS_PER_CLUSTER < (1 << (8*sizeof(stbcc__clumpid))) ? 1 : -1]; + +#define STBCC__MAX_EXITS_PER_CLUSTER (STBCC__CLUSTER_SIZE_X + STBCC__CLUSTER_SIZE_Y) // 64 for 32x32 +#define STBCC__MAX_EXITS_PER_CLUMP (STBCC__CLUSTER_SIZE_X + STBCC__CLUSTER_SIZE_Y) // 64 for 32x32 +#define STBCC__MAX_EDGE_CLUMPS_PER_CLUSTER (STBCC__MAX_EXITS_PER_CLUMP) + +// 2^19 * 2^6 => 2^25 exits => 2^26 => 64MB for 1024x1024 + +// Logic for above on 4x4 grid: +// +// Many clumps: One clump: +// + + + + +// +X.X. +XX.X+ +// .X.X+ .XXX +// +X.X. XXX. +// .X.X+ +X.XX+ +// + + + + +// +// 8 exits either way + +typedef unsigned char stbcc__verify_max_exits[STBCC__MAX_EXITS_PER_CLUMP <= 256]; + +typedef struct +{ + unsigned short clump_index:12; + signed short cluster_dx:2; + signed short cluster_dy:2; +} stbcc__relative_clumpid; + +typedef union +{ + struct { + unsigned int clump_index:12; + unsigned int cluster_x:10; + unsigned int cluster_y:10; + } f; + unsigned int c; +} stbcc__global_clumpid; + +// rebuilt cluster 3,4 + +// what changes in cluster 2,4 + +typedef struct +{ + stbcc__global_clumpid global_label; // 4 + unsigned char num_adjacent; // 1 + unsigned char max_adjacent; // 1 + unsigned char adjacent_clump_list_index; // 1 + unsigned char reserved; +} stbcc__clump; // 8 + +#define STBCC__CLUSTER_ADJACENCY_COUNT (STBCC__MAX_EXITS_PER_CLUSTER*2) +typedef struct +{ + short num_clumps; + unsigned char num_edge_clumps; + unsigned char rebuild_adjacency; + stbcc__clump clump[STBCC__MAX_CLUMPS_PER_CLUSTER]; // 8 * 2^9 = 4KB + stbcc__relative_clumpid adjacency_storage[STBCC__CLUSTER_ADJACENCY_COUNT]; // 256 bytes +} stbcc__cluster; + +struct st_stbcc_grid +{ + int w,h,cw,ch; + int in_batched_update; + //unsigned char cluster_dirty[STBCC__CLUSTER_COUNT_Y][STBCC__CLUSTER_COUNT_X]; // could bitpack, but: 1K x 1K => 1KB + unsigned char map[STBCC__GRID_COUNT_Y][STBCC__MAP_STRIDE]; // 1K x 1K => 1K x 128 => 128KB + stbcc__clumpid clump_for_node[STBCC__GRID_COUNT_Y][STBCC__GRID_COUNT_X]; // 1K x 1K x 2 = 2MB + stbcc__cluster cluster[STBCC__CLUSTER_COUNT_Y][STBCC__CLUSTER_COUNT_X]; // 1K x 4.5KB = 4.5MB +}; + +int stbcc_query_grid_node_connection(stbcc_grid *g, int x1, int y1, int x2, int y2) +{ + stbcc__global_clumpid label1, label2; + stbcc__clumpid c1 = g->clump_for_node[y1][x1]; + stbcc__clumpid c2 = g->clump_for_node[y2][x2]; + int cx1 = STBCC__CLUSTER_X_FOR_COORD_X(x1); + int cy1 = STBCC__CLUSTER_Y_FOR_COORD_Y(y1); + int cx2 = STBCC__CLUSTER_X_FOR_COORD_X(x2); + int cy2 = STBCC__CLUSTER_Y_FOR_COORD_Y(y2); + assert(!g->in_batched_update); + if (c1 == STBCC__NULL_CLUMPID || c2 == STBCC__NULL_CLUMPID) + return 0; + label1 = g->cluster[cy1][cx1].clump[c1].global_label; + label2 = g->cluster[cy2][cx2].clump[c2].global_label; + if (label1.c == label2.c) + return 1; + return 0; +} + +int stbcc_query_grid_open(stbcc_grid *g, int x, int y) +{ + return STBCC__MAP_OPEN(g, x, y) != 0; +} + +unsigned int stbcc_get_unique_id(stbcc_grid *g, int x, int y) +{ + stbcc__clumpid c = g->clump_for_node[y][x]; + int cx = STBCC__CLUSTER_X_FOR_COORD_X(x); + int cy = STBCC__CLUSTER_Y_FOR_COORD_Y(y); + assert(!g->in_batched_update); + if (c == STBCC__NULL_CLUMPID) return STBCC_NULL_UNIQUE_ID; + return g->cluster[cy][cx].clump[c].global_label.c; +} + +typedef struct +{ + unsigned char x,y; +} stbcc__tinypoint; + +typedef struct +{ + stbcc__tinypoint parent[STBCC__CLUSTER_SIZE_Y][STBCC__CLUSTER_SIZE_X]; // 32x32 => 2KB + stbcc__clumpid label[STBCC__CLUSTER_SIZE_Y][STBCC__CLUSTER_SIZE_X]; +} stbcc__cluster_build_info; + +static void stbcc__build_clumps_for_cluster(stbcc_grid *g, int cx, int cy); +static void stbcc__remove_connections_to_adjacent_cluster(stbcc_grid *g, int cx, int cy, int dx, int dy); +static void stbcc__add_connections_to_adjacent_cluster(stbcc_grid *g, int cx, int cy, int dx, int dy); + +static stbcc__global_clumpid stbcc__clump_find(stbcc_grid *g, stbcc__global_clumpid n) +{ + stbcc__global_clumpid q; + stbcc__clump *c = &g->cluster[n.f.cluster_y][n.f.cluster_x].clump[n.f.clump_index]; + + if (c->global_label.c == n.c) + return n; + + q = stbcc__clump_find(g, c->global_label); + c->global_label = q; + return q; +} + +typedef struct +{ + unsigned int cluster_x; + unsigned int cluster_y; + unsigned int clump_index; +} stbcc__unpacked_clumpid; + +static void stbcc__clump_union(stbcc_grid *g, stbcc__unpacked_clumpid m, int x, int y, int idx) +{ + stbcc__clump *mc = &g->cluster[m.cluster_y][m.cluster_x].clump[m.clump_index]; + stbcc__clump *nc = &g->cluster[y][x].clump[idx]; + stbcc__global_clumpid mp = stbcc__clump_find(g, mc->global_label); + stbcc__global_clumpid np = stbcc__clump_find(g, nc->global_label); + + if (mp.c == np.c) + return; + + g->cluster[mp.f.cluster_y][mp.f.cluster_x].clump[mp.f.clump_index].global_label = np; +} + +static void stbcc__build_connected_components_for_clumps(stbcc_grid *g) +{ + int i,j,k,h; + + for (j=0; j < STBCC__CLUSTER_COUNT_Y; ++j) { + for (i=0; i < STBCC__CLUSTER_COUNT_X; ++i) { + stbcc__cluster *cluster = &g->cluster[j][i]; + for (k=0; k < (int) cluster->num_edge_clumps; ++k) { + stbcc__global_clumpid m; + m.f.clump_index = k; + m.f.cluster_x = i; + m.f.cluster_y = j; + assert((int) m.f.clump_index == k && (int) m.f.cluster_x == i && (int) m.f.cluster_y == j); + cluster->clump[k].global_label = m; + } + } + } + + for (j=0; j < STBCC__CLUSTER_COUNT_Y; ++j) { + for (i=0; i < STBCC__CLUSTER_COUNT_X; ++i) { + stbcc__cluster *cluster = &g->cluster[j][i]; + for (k=0; k < (int) cluster->num_edge_clumps; ++k) { + stbcc__clump *clump = &cluster->clump[k]; + stbcc__unpacked_clumpid m; + stbcc__relative_clumpid *adj; + m.clump_index = k; + m.cluster_x = i; + m.cluster_y = j; + adj = &cluster->adjacency_storage[clump->adjacent_clump_list_index]; + for (h=0; h < clump->num_adjacent; ++h) { + unsigned int clump_index = adj[h].clump_index; + unsigned int x = adj[h].cluster_dx + i; + unsigned int y = adj[h].cluster_dy + j; + stbcc__clump_union(g, m, x, y, clump_index); + } + } + } + } + + for (j=0; j < STBCC__CLUSTER_COUNT_Y; ++j) { + for (i=0; i < STBCC__CLUSTER_COUNT_X; ++i) { + stbcc__cluster *cluster = &g->cluster[j][i]; + for (k=0; k < (int) cluster->num_edge_clumps; ++k) { + stbcc__global_clumpid m; + m.f.clump_index = k; + m.f.cluster_x = i; + m.f.cluster_y = j; + stbcc__clump_find(g, m); + } + } + } +} + +static void stbcc__build_all_connections_for_cluster(stbcc_grid *g, int cx, int cy) +{ + // in this particular case, we are fully non-incremental. that means we + // can discover the correct sizes for the arrays, but requires we build + // the data into temporary data structures, or just count the sizes, so + // for simplicity we do the latter + stbcc__cluster *cluster = &g->cluster[cy][cx]; + unsigned char connected[STBCC__MAX_EDGE_CLUMPS_PER_CLUSTER][STBCC__MAX_EDGE_CLUMPS_PER_CLUSTER/8]; // 64 x 8 => 1KB + unsigned char num_adj[STBCC__MAX_CLUMPS_PER_CLUSTER] = { 0 }; + int x = cx * STBCC__CLUSTER_SIZE_X; + int y = cy * STBCC__CLUSTER_SIZE_Y; + int step_x, step_y=0, i, j, k, n, m, dx, dy, total; + int extra; + + g->cluster[cy][cx].rebuild_adjacency = 0; + + total = 0; + for (m=0; m < 4; ++m) { + switch (m) { + case 0: + dx = 1, dy = 0; + step_x = 0, step_y = 1; + i = STBCC__CLUSTER_SIZE_X-1; + j = 0; + n = STBCC__CLUSTER_SIZE_Y; + break; + case 1: + dx = -1, dy = 0; + i = 0; + j = 0; + step_x = 0; + step_y = 1; + n = STBCC__CLUSTER_SIZE_Y; + break; + case 2: + dy = -1, dx = 0; + i = 0; + j = 0; + step_x = 1; + step_y = 0; + n = STBCC__CLUSTER_SIZE_X; + break; + case 3: + dy = 1, dx = 0; + i = 0; + j = STBCC__CLUSTER_SIZE_Y-1; + step_x = 1; + step_y = 0; + n = STBCC__CLUSTER_SIZE_X; + break; + } + + if (cx+dx < 0 || cx+dx >= g->cw || cy+dy < 0 || cy+dy >= g->ch) + continue; + + memset(connected, 0, sizeof(connected)); + for (k=0; k < n; ++k) { + if (STBCC__MAP_OPEN(g, x+i, y+j) && STBCC__MAP_OPEN(g, x+i+dx, y+j+dy)) { + stbcc__clumpid src = g->clump_for_node[y+j][x+i]; + stbcc__clumpid dest = g->clump_for_node[y+j+dy][x+i+dx]; + if (0 == (connected[src][dest>>3] & (1 << (dest & 7)))) { + connected[src][dest>>3] |= 1 << (dest & 7); + ++num_adj[src]; + ++total; + } + } + i += step_x; + j += step_y; + } + } + + assert(total <= STBCC__CLUSTER_ADJACENCY_COUNT); + + // decide how to apportion unused adjacency slots; only clumps that lie + // on the edges of the cluster need adjacency slots, so divide them up + // evenly between those clumps + + // we want: + // extra = (STBCC__CLUSTER_ADJACENCY_COUNT - total) / cluster->num_edge_clumps; + // but we efficiently approximate this without a divide, because + // ignoring edge-vs-non-edge with 'num_adj[i]*2' was faster than + // 'num_adj[i]+extra' with the divide + if (total + (cluster->num_edge_clumps<<2) <= STBCC__CLUSTER_ADJACENCY_COUNT) + extra = 4; + else if (total + (cluster->num_edge_clumps<<1) <= STBCC__CLUSTER_ADJACENCY_COUNT) + extra = 2; + else if (total + (cluster->num_edge_clumps<<0) <= STBCC__CLUSTER_ADJACENCY_COUNT) + extra = 1; + else + extra = 0; + + total = 0; + for (i=0; i < (int) cluster->num_edge_clumps; ++i) { + int alloc = num_adj[i]+extra; + if (alloc > STBCC__MAX_EXITS_PER_CLUSTER) + alloc = STBCC__MAX_EXITS_PER_CLUSTER; + assert(total < 256); // must fit in byte + cluster->clump[i].adjacent_clump_list_index = (unsigned char) total; + cluster->clump[i].max_adjacent = alloc; + cluster->clump[i].num_adjacent = 0; + total += alloc; + } + assert(total <= STBCC__CLUSTER_ADJACENCY_COUNT); + + stbcc__add_connections_to_adjacent_cluster(g, cx, cy, -1, 0); + stbcc__add_connections_to_adjacent_cluster(g, cx, cy, 1, 0); + stbcc__add_connections_to_adjacent_cluster(g, cx, cy, 0,-1); + stbcc__add_connections_to_adjacent_cluster(g, cx, cy, 0, 1); + // make sure all of the above succeeded. + assert(g->cluster[cy][cx].rebuild_adjacency == 0); +} + +static void stbcc__add_connections_to_adjacent_cluster_with_rebuild(stbcc_grid *g, int cx, int cy, int dx, int dy) +{ + if (cx >= 0 && cx < g->cw && cy >= 0 && cy < g->ch) { + stbcc__add_connections_to_adjacent_cluster(g, cx, cy, dx, dy); + if (g->cluster[cy][cx].rebuild_adjacency) + stbcc__build_all_connections_for_cluster(g, cx, cy); + } +} + +void stbcc_update_grid(stbcc_grid *g, int x, int y, int solid) +{ + int cx,cy; + + if (!solid) { + if (STBCC__MAP_OPEN(g,x,y)) + return; + } else { + if (!STBCC__MAP_OPEN(g,x,y)) + return; + } + + cx = STBCC__CLUSTER_X_FOR_COORD_X(x); + cy = STBCC__CLUSTER_Y_FOR_COORD_Y(y); + + stbcc__remove_connections_to_adjacent_cluster(g, cx-1, cy, 1, 0); + stbcc__remove_connections_to_adjacent_cluster(g, cx+1, cy, -1, 0); + stbcc__remove_connections_to_adjacent_cluster(g, cx, cy-1, 0, 1); + stbcc__remove_connections_to_adjacent_cluster(g, cx, cy+1, 0,-1); + + if (!solid) + STBCC__MAP_BYTE(g,x,y) |= STBCC__MAP_BYTE_MASK(x,y); + else + STBCC__MAP_BYTE(g,x,y) &= ~STBCC__MAP_BYTE_MASK(x,y); + + stbcc__build_clumps_for_cluster(g, cx, cy); + stbcc__build_all_connections_for_cluster(g, cx, cy); + + stbcc__add_connections_to_adjacent_cluster_with_rebuild(g, cx-1, cy, 1, 0); + stbcc__add_connections_to_adjacent_cluster_with_rebuild(g, cx+1, cy, -1, 0); + stbcc__add_connections_to_adjacent_cluster_with_rebuild(g, cx, cy-1, 0, 1); + stbcc__add_connections_to_adjacent_cluster_with_rebuild(g, cx, cy+1, 0,-1); + + if (!g->in_batched_update) + stbcc__build_connected_components_for_clumps(g); + #if 0 + else + g->cluster_dirty[cy][cx] = 1; + #endif +} + +void stbcc_update_batch_begin(stbcc_grid *g) +{ + assert(!g->in_batched_update); + g->in_batched_update = 1; +} + +void stbcc_update_batch_end(stbcc_grid *g) +{ + assert(g->in_batched_update); + g->in_batched_update = 0; + stbcc__build_connected_components_for_clumps(g); // @OPTIMIZE: only do this if update was non-empty +} + +size_t stbcc_grid_sizeof(void) +{ + return sizeof(stbcc_grid); +} + +void stbcc_init_grid(stbcc_grid *g, unsigned char *map, int w, int h) +{ + int i,j,k; + assert(w % STBCC__CLUSTER_SIZE_X == 0); + assert(h % STBCC__CLUSTER_SIZE_Y == 0); + assert(w % 8 == 0); + + g->w = w; + g->h = h; + g->cw = w >> STBCC_CLUSTER_SIZE_X_LOG2; + g->ch = h >> STBCC_CLUSTER_SIZE_Y_LOG2; + g->in_batched_update = 0; + + #if 0 + for (j=0; j < STBCC__CLUSTER_COUNT_Y; ++j) + for (i=0; i < STBCC__CLUSTER_COUNT_X; ++i) + g->cluster_dirty[j][i] = 0; + #endif + + for (j=0; j < h; ++j) { + for (i=0; i < w; i += 8) { + unsigned char c = 0; + for (k=0; k < 8; ++k) + if (map[j*w + (i+k)] == 0) + c |= (1 << k); + g->map[j][i>>3] = c; + } + } + + for (j=0; j < g->ch; ++j) + for (i=0; i < g->cw; ++i) + stbcc__build_clumps_for_cluster(g, i, j); + + for (j=0; j < g->ch; ++j) + for (i=0; i < g->cw; ++i) + stbcc__build_all_connections_for_cluster(g, i, j); + + stbcc__build_connected_components_for_clumps(g); + + for (j=0; j < g->h; ++j) + for (i=0; i < g->w; ++i) + assert(g->clump_for_node[j][i] <= STBCC__NULL_CLUMPID); +} + + +static void stbcc__add_clump_connection(stbcc_grid *g, int x1, int y1, int x2, int y2) +{ + stbcc__cluster *cluster; + stbcc__clump *clump; + + int cx1 = STBCC__CLUSTER_X_FOR_COORD_X(x1); + int cy1 = STBCC__CLUSTER_Y_FOR_COORD_Y(y1); + int cx2 = STBCC__CLUSTER_X_FOR_COORD_X(x2); + int cy2 = STBCC__CLUSTER_Y_FOR_COORD_Y(y2); + + stbcc__clumpid c1 = g->clump_for_node[y1][x1]; + stbcc__clumpid c2 = g->clump_for_node[y2][x2]; + + stbcc__relative_clumpid rc; + + assert(cx1 != cx2 || cy1 != cy2); + assert(abs(cx1-cx2) + abs(cy1-cy2) == 1); + + // add connection to c2 in c1 + + rc.clump_index = c2; + rc.cluster_dx = x2-x1; + rc.cluster_dy = y2-y1; + + cluster = &g->cluster[cy1][cx1]; + clump = &cluster->clump[c1]; + assert(clump->num_adjacent <= clump->max_adjacent); + if (clump->num_adjacent == clump->max_adjacent) + g->cluster[cy1][cx1].rebuild_adjacency = 1; + else { + stbcc__relative_clumpid *adj = &cluster->adjacency_storage[clump->adjacent_clump_list_index]; + assert(clump->num_adjacent < STBCC__MAX_EXITS_PER_CLUMP); + assert(clump->adjacent_clump_list_index + clump->num_adjacent <= STBCC__CLUSTER_ADJACENCY_COUNT); + adj[clump->num_adjacent++] = rc; + } +} + +static void stbcc__remove_clump_connection(stbcc_grid *g, int x1, int y1, int x2, int y2) +{ + stbcc__cluster *cluster; + stbcc__clump *clump; + stbcc__relative_clumpid *adj; + int i; + + int cx1 = STBCC__CLUSTER_X_FOR_COORD_X(x1); + int cy1 = STBCC__CLUSTER_Y_FOR_COORD_Y(y1); + int cx2 = STBCC__CLUSTER_X_FOR_COORD_X(x2); + int cy2 = STBCC__CLUSTER_Y_FOR_COORD_Y(y2); + + stbcc__clumpid c1 = g->clump_for_node[y1][x1]; + stbcc__clumpid c2 = g->clump_for_node[y2][x2]; + + stbcc__relative_clumpid rc; + + assert(cx1 != cx2 || cy1 != cy2); + assert(abs(cx1-cx2) + abs(cy1-cy2) == 1); + + // add connection to c2 in c1 + + rc.clump_index = c2; + rc.cluster_dx = x2-x1; + rc.cluster_dy = y2-y1; + + cluster = &g->cluster[cy1][cx1]; + clump = &cluster->clump[c1]; + adj = &cluster->adjacency_storage[clump->adjacent_clump_list_index]; + + for (i=0; i < clump->num_adjacent; ++i) + if (rc.clump_index == adj[i].clump_index && + rc.cluster_dx == adj[i].cluster_dx && + rc.cluster_dy == adj[i].cluster_dy) + break; + + if (i < clump->num_adjacent) + adj[i] = adj[--clump->num_adjacent]; + else + assert(0); +} + +static void stbcc__add_connections_to_adjacent_cluster(stbcc_grid *g, int cx, int cy, int dx, int dy) +{ + unsigned char connected[STBCC__MAX_EDGE_CLUMPS_PER_CLUSTER][STBCC__MAX_EDGE_CLUMPS_PER_CLUSTER/8] = { { 0 } }; + int x = cx * STBCC__CLUSTER_SIZE_X; + int y = cy * STBCC__CLUSTER_SIZE_Y; + int step_x, step_y=0, i, j, k, n; + + if (cx < 0 || cx >= g->cw || cy < 0 || cy >= g->ch) + return; + + if (cx+dx < 0 || cx+dx >= g->cw || cy+dy < 0 || cy+dy >= g->ch) + return; + + if (g->cluster[cy][cx].rebuild_adjacency) + return; + + assert(abs(dx) + abs(dy) == 1); + + if (dx == 1) { + i = STBCC__CLUSTER_SIZE_X-1; + j = 0; + step_x = 0; + step_y = 1; + n = STBCC__CLUSTER_SIZE_Y; + } else if (dx == -1) { + i = 0; + j = 0; + step_x = 0; + step_y = 1; + n = STBCC__CLUSTER_SIZE_Y; + } else if (dy == -1) { + i = 0; + j = 0; + step_x = 1; + step_y = 0; + n = STBCC__CLUSTER_SIZE_X; + } else if (dy == 1) { + i = 0; + j = STBCC__CLUSTER_SIZE_Y-1; + step_x = 1; + step_y = 0; + n = STBCC__CLUSTER_SIZE_X; + } else { + assert(0); + return; + } + + for (k=0; k < n; ++k) { + if (STBCC__MAP_OPEN(g, x+i, y+j) && STBCC__MAP_OPEN(g, x+i+dx, y+j+dy)) { + stbcc__clumpid src = g->clump_for_node[y+j][x+i]; + stbcc__clumpid dest = g->clump_for_node[y+j+dy][x+i+dx]; + if (0 == (connected[src][dest>>3] & (1 << (dest & 7)))) { + assert((dest>>3) < sizeof(connected)); + connected[src][dest>>3] |= 1 << (dest & 7); + stbcc__add_clump_connection(g, x+i, y+j, x+i+dx, y+j+dy); + if (g->cluster[cy][cx].rebuild_adjacency) + break; + } + } + i += step_x; + j += step_y; + } +} + +static void stbcc__remove_connections_to_adjacent_cluster(stbcc_grid *g, int cx, int cy, int dx, int dy) +{ + unsigned char disconnected[STBCC__MAX_EDGE_CLUMPS_PER_CLUSTER][STBCC__MAX_EDGE_CLUMPS_PER_CLUSTER/8] = { { 0 } }; + int x = cx * STBCC__CLUSTER_SIZE_X; + int y = cy * STBCC__CLUSTER_SIZE_Y; + int step_x, step_y=0, i, j, k, n; + + if (cx < 0 || cx >= g->cw || cy < 0 || cy >= g->ch) + return; + + if (cx+dx < 0 || cx+dx >= g->cw || cy+dy < 0 || cy+dy >= g->ch) + return; + + assert(abs(dx) + abs(dy) == 1); + + if (dx == 1) { + i = STBCC__CLUSTER_SIZE_X-1; + j = 0; + step_x = 0; + step_y = 1; + n = STBCC__CLUSTER_SIZE_Y; + } else if (dx == -1) { + i = 0; + j = 0; + step_x = 0; + step_y = 1; + n = STBCC__CLUSTER_SIZE_Y; + } else if (dy == -1) { + i = 0; + j = 0; + step_x = 1; + step_y = 0; + n = STBCC__CLUSTER_SIZE_X; + } else if (dy == 1) { + i = 0; + j = STBCC__CLUSTER_SIZE_Y-1; + step_x = 1; + step_y = 0; + n = STBCC__CLUSTER_SIZE_X; + } else { + assert(0); + return; + } + + for (k=0; k < n; ++k) { + if (STBCC__MAP_OPEN(g, x+i, y+j) && STBCC__MAP_OPEN(g, x+i+dx, y+j+dy)) { + stbcc__clumpid src = g->clump_for_node[y+j][x+i]; + stbcc__clumpid dest = g->clump_for_node[y+j+dy][x+i+dx]; + if (0 == (disconnected[src][dest>>3] & (1 << (dest & 7)))) { + disconnected[src][dest>>3] |= 1 << (dest & 7); + stbcc__remove_clump_connection(g, x+i, y+j, x+i+dx, y+j+dy); + } + } + i += step_x; + j += step_y; + } +} + +static stbcc__tinypoint stbcc__incluster_find(stbcc__cluster_build_info *cbi, int x, int y) +{ + stbcc__tinypoint p,q; + p = cbi->parent[y][x]; + if (p.x == x && p.y == y) + return p; + q = stbcc__incluster_find(cbi, p.x, p.y); + cbi->parent[y][x] = q; + return q; +} + +static void stbcc__incluster_union(stbcc__cluster_build_info *cbi, int x1, int y1, int x2, int y2) +{ + stbcc__tinypoint p = stbcc__incluster_find(cbi, x1,y1); + stbcc__tinypoint q = stbcc__incluster_find(cbi, x2,y2); + + if (p.x == q.x && p.y == q.y) + return; + + cbi->parent[p.y][p.x] = q; +} + +static void stbcc__switch_root(stbcc__cluster_build_info *cbi, int x, int y, stbcc__tinypoint p) +{ + cbi->parent[p.y][p.x].x = x; + cbi->parent[p.y][p.x].y = y; + cbi->parent[y][x].x = x; + cbi->parent[y][x].y = y; +} + +static void stbcc__build_clumps_for_cluster(stbcc_grid *g, int cx, int cy) +{ + stbcc__cluster *c; + stbcc__cluster_build_info cbi; + int label=0; + int i,j; + int x = cx * STBCC__CLUSTER_SIZE_X; + int y = cy * STBCC__CLUSTER_SIZE_Y; + + // set initial disjoint set forest state + for (j=0; j < STBCC__CLUSTER_SIZE_Y; ++j) { + for (i=0; i < STBCC__CLUSTER_SIZE_X; ++i) { + cbi.parent[j][i].x = i; + cbi.parent[j][i].y = j; + } + } + + // join all sets that are connected + for (j=0; j < STBCC__CLUSTER_SIZE_Y; ++j) { + // check down only if not on bottom row + if (j < STBCC__CLUSTER_SIZE_Y-1) + for (i=0; i < STBCC__CLUSTER_SIZE_X; ++i) + if (STBCC__MAP_OPEN(g,x+i,y+j) && STBCC__MAP_OPEN(g,x+i ,y+j+1)) + stbcc__incluster_union(&cbi, i,j, i,j+1); + // check right for everything but rightmost column + for (i=0; i < STBCC__CLUSTER_SIZE_X-1; ++i) + if (STBCC__MAP_OPEN(g,x+i,y+j) && STBCC__MAP_OPEN(g,x+i+1,y+j )) + stbcc__incluster_union(&cbi, i,j, i+1,j); + } + + // label all non-empty clumps along edges so that all edge clumps are first + // in list; this means in degenerate case we can skip traversing non-edge clumps. + // because in the first pass we only label leaders, we swap the leader to the + // edge first + + // first put solid labels on all the edges; these will get overwritten if they're open + for (j=0; j < STBCC__CLUSTER_SIZE_Y; ++j) + cbi.label[j][0] = cbi.label[j][STBCC__CLUSTER_SIZE_X-1] = STBCC__NULL_CLUMPID; + for (i=0; i < STBCC__CLUSTER_SIZE_X; ++i) + cbi.label[0][i] = cbi.label[STBCC__CLUSTER_SIZE_Y-1][i] = STBCC__NULL_CLUMPID; + + for (j=0; j < STBCC__CLUSTER_SIZE_Y; ++j) { + i = 0; + if (STBCC__MAP_OPEN(g, x+i, y+j)) { + stbcc__tinypoint p = stbcc__incluster_find(&cbi, i,j); + if (p.x == i && p.y == j) + // if this is the leader, give it a label + cbi.label[j][i] = label++; + else if (!(p.x == 0 || p.x == STBCC__CLUSTER_SIZE_X-1 || p.y == 0 || p.y == STBCC__CLUSTER_SIZE_Y-1)) { + // if leader is in interior, promote this edge node to leader and label + stbcc__switch_root(&cbi, i, j, p); + cbi.label[j][i] = label++; + } + // else if leader is on edge, do nothing (it'll get labelled when we reach it) + } + i = STBCC__CLUSTER_SIZE_X-1; + if (STBCC__MAP_OPEN(g, x+i, y+j)) { + stbcc__tinypoint p = stbcc__incluster_find(&cbi, i,j); + if (p.x == i && p.y == j) + cbi.label[j][i] = label++; + else if (!(p.x == 0 || p.x == STBCC__CLUSTER_SIZE_X-1 || p.y == 0 || p.y == STBCC__CLUSTER_SIZE_Y-1)) { + stbcc__switch_root(&cbi, i, j, p); + cbi.label[j][i] = label++; + } + } + } + + for (i=1; i < STBCC__CLUSTER_SIZE_Y-1; ++i) { + j = 0; + if (STBCC__MAP_OPEN(g, x+i, y+j)) { + stbcc__tinypoint p = stbcc__incluster_find(&cbi, i,j); + if (p.x == i && p.y == j) + cbi.label[j][i] = label++; + else if (!(p.x == 0 || p.x == STBCC__CLUSTER_SIZE_X-1 || p.y == 0 || p.y == STBCC__CLUSTER_SIZE_Y-1)) { + stbcc__switch_root(&cbi, i, j, p); + cbi.label[j][i] = label++; + } + } + j = STBCC__CLUSTER_SIZE_Y-1; + if (STBCC__MAP_OPEN(g, x+i, y+j)) { + stbcc__tinypoint p = stbcc__incluster_find(&cbi, i,j); + if (p.x == i && p.y == j) + cbi.label[j][i] = label++; + else if (!(p.x == 0 || p.x == STBCC__CLUSTER_SIZE_X-1 || p.y == 0 || p.y == STBCC__CLUSTER_SIZE_Y-1)) { + stbcc__switch_root(&cbi, i, j, p); + cbi.label[j][i] = label++; + } + } + } + + c = &g->cluster[cy][cx]; + c->num_edge_clumps = label; + + // label any internal clusters + for (j=1; j < STBCC__CLUSTER_SIZE_Y-1; ++j) { + for (i=1; i < STBCC__CLUSTER_SIZE_X-1; ++i) { + stbcc__tinypoint p = cbi.parent[j][i]; + if (p.x == i && p.y == j) { + if (STBCC__MAP_OPEN(g,x+i,y+j)) + cbi.label[j][i] = label++; + else + cbi.label[j][i] = STBCC__NULL_CLUMPID; + } + } + } + + // label all other nodes + for (j=0; j < STBCC__CLUSTER_SIZE_Y; ++j) { + for (i=0; i < STBCC__CLUSTER_SIZE_X; ++i) { + stbcc__tinypoint p = stbcc__incluster_find(&cbi, i,j); + if (p.x != i || p.y != j) { + if (STBCC__MAP_OPEN(g,x+i,y+j)) + cbi.label[j][i] = cbi.label[p.y][p.x]; + } + if (STBCC__MAP_OPEN(g,x+i,y+j)) + assert(cbi.label[j][i] != STBCC__NULL_CLUMPID); + } + } + + c->num_clumps = label; + + for (i=0; i < label; ++i) { + c->clump[i].num_adjacent = 0; + c->clump[i].max_adjacent = 0; + } + + for (j=0; j < STBCC__CLUSTER_SIZE_Y; ++j) + for (i=0; i < STBCC__CLUSTER_SIZE_X; ++i) { + g->clump_for_node[y+j][x+i] = cbi.label[j][i]; // @OPTIMIZE: remove cbi.label entirely + assert(g->clump_for_node[y+j][x+i] <= STBCC__NULL_CLUMPID); + } + + // set the global label for all interior clumps since they can't have connections, + // so we don't have to do this on the global pass (brings from O(N) to O(N^0.75)) + for (i=(int) c->num_edge_clumps; i < (int) c->num_clumps; ++i) { + stbcc__global_clumpid gc; + gc.f.cluster_x = cx; + gc.f.cluster_y = cy; + gc.f.clump_index = i; + c->clump[i].global_label = gc; + } + + c->rebuild_adjacency = 1; // flag that it has no valid adjacency data +} + +#endif // STB_CONNECTED_COMPONENTS_IMPLEMENTATION +/* +------------------------------------------------------------------------------ +This software is available under 2 licenses -- choose whichever you prefer. +------------------------------------------------------------------------------ +ALTERNATIVE A - MIT License +Copyright (c) 2017 Sean Barrett +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is furnished to do +so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +------------------------------------------------------------------------------ +ALTERNATIVE B - Public Domain (www.unlicense.org) +This is free and unencumbered software released into the public domain. +Anyone is free to copy, modify, publish, use, compile, sell, or distribute this +software, either in source code form or as a compiled binary, for any purpose, +commercial or non-commercial, and by any means. +In jurisdictions that recognize copyright laws, the author or authors of this +software dedicate any and all copyright interest in the software to the public +domain. We make this dedication for the benefit of the public at large and to +the detriment of our heirs and successors. We intend this dedication to be an +overt act of relinquishment in perpetuity of all present and future rights to +this software under copyright law. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN +ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +------------------------------------------------------------------------------ +*/ diff --git a/tests/data/c/stb/stb_divide.h b/tests/data/c/stb/stb_divide.h new file mode 100644 index 000000000..6a51e3f2e --- /dev/null +++ b/tests/data/c/stb/stb_divide.h @@ -0,0 +1,433 @@ +// stb_divide.h - v0.94 - public domain - Sean Barrett, Feb 2010 +// Three kinds of divide/modulus of signed integers. +// +// HISTORY +// +// v0.94 Fix integer overflow issues +// v0.93 2020-02-02 Write useful exit() value from main() +// v0.92 2019-02-25 Fix warning +// v0.91 2010-02-27 Fix euclidean division by INT_MIN for non-truncating C +// Check result with 64-bit math to catch such cases +// v0.90 2010-02-24 First public release +// +// USAGE +// +// In *ONE* source file, put: +// +// #define STB_DIVIDE_IMPLEMENTATION +// // #define C_INTEGER_DIVISION_TRUNCATES // see Note 1 +// // #define C_INTEGER_DIVISION_FLOORS // see Note 2 +// #include "stb_divide.h" +// +// Other source files should just include stb_divide.h +// +// Note 1: On platforms/compilers that you know signed C division +// truncates, you can #define C_INTEGER_DIVISION_TRUNCATES. +// +// Note 2: On platforms/compilers that you know signed C division +// floors (rounds to negative infinity), you can #define +// C_INTEGER_DIVISION_FLOORS. +// +// You can #define STB_DIVIDE_TEST in which case the implementation +// will generate a main() and compiling the result will create a +// program that tests the implementation. Run it with no arguments +// and any output indicates an error; run it with any argument and +// it will also print the test results. Define STB_DIVIDE_TEST_64 +// to a 64-bit integer type to avoid overflows in the result-checking +// which give false negatives. +// +// ABOUT +// +// This file provides three different consistent divide/mod pairs +// implemented on top of arbitrary C/C++ division, including correct +// handling of overflow of intermediate calculations: +// +// trunc: a/b truncates to 0, a%b has same sign as a +// floor: a/b truncates to -inf, a%b has same sign as b +// eucl: a/b truncates to sign(b)*inf, a%b is non-negative +// +// Not necessarily optimal; I tried to keep it generally efficient, +// but there may be better ways. +// +// Briefly, for those who are not familiar with the problem, we note +// the reason these divides exist and are interesting: +// +// 'trunc' is easy to implement in hardware (strip the signs, +// compute, reapply the signs), thus is commonly defined +// by many languages (including C99) +// +// 'floor' is simple to define and better behaved than trunc; +// for example it divides integers into fixed-size buckets +// without an extra-wide bucket at 0, and for a fixed +// divisor N there are only |N| possible moduli. +// +// 'eucl' guarantees fixed-sized buckets *and* a non-negative +// modulus and defines division to be whatever is needed +// to achieve that result. +// +// See "The Euclidean definition of the functions div and mod" +// by Raymond Boute (1992), or "Division and Modulus for Computer +// Scientists" by Daan Leijen (2001) +// +// We assume of the built-in C division: +// (a) modulus is the remainder for the corresponding division +// (b) a/b truncates if a and b are the same sign +// +// Property (a) requires (a/b)*b + (a%b)==a, and is required by C. +// Property (b) seems to be true of all hardware but is *not* satisfied +// by the euclidean division operator we define, so it's possibly not +// always true. If any such platform turns up, we can add more cases. +// (Possibly only stb_div_trunc currently relies on property (b).) +// +// LICENSE +// +// See end of file for license information. + + +#ifndef INCLUDE_STB_DIVIDE_H +#define INCLUDE_STB_DIVIDE_H + +#ifdef __cplusplus +extern "C" { +#endif + +extern int stb_div_trunc(int value_to_be_divided, int value_to_divide_by); +extern int stb_div_floor(int value_to_be_divided, int value_to_divide_by); +extern int stb_div_eucl (int value_to_be_divided, int value_to_divide_by); +extern int stb_mod_trunc(int value_to_be_divided, int value_to_divide_by); +extern int stb_mod_floor(int value_to_be_divided, int value_to_divide_by); +extern int stb_mod_eucl (int value_to_be_divided, int value_to_divide_by); + +#ifdef __cplusplus +} +#endif + +#ifdef STB_DIVIDE_IMPLEMENTATION + +#if defined(__STDC_VERSION) && __STDC_VERSION__ >= 19901 + #ifndef C_INTEGER_DIVISION_TRUNCATES + #define C_INTEGER_DIVISION_TRUNCATES + #endif +#endif + +#ifndef INT_MIN +#include // if you have no limits.h, #define INT_MIN yourself +#endif + +// the following macros are designed to allow testing +// other platforms by simulating them +#ifndef STB_DIVIDE_TEST_FLOOR + #define stb__div(a,b) ((a)/(b)) + #define stb__mod(a,b) ((a)%(b)) +#else + // implement floor-style divide on trunc platform + #ifndef C_INTEGER_DIVISION_TRUNCATES + #error "floor test requires truncating division" + #endif + #undef C_INTEGER_DIVISION_TRUNCATES + int stb__div(int v1, int v2) + { + int q = v1/v2, r = v1%v2; + if ((r > 0 && v2 < 0) || (r < 0 && v2 > 0)) + return q-1; + else + return q; + } + + int stb__mod(int v1, int v2) + { + int r = v1%v2; + if ((r > 0 && v2 < 0) || (r < 0 && v2 > 0)) + return r+v2; + else + return r; + } +#endif + +int stb_div_trunc(int v1, int v2) +{ + #ifdef C_INTEGER_DIVISION_TRUNCATES + return v1/v2; + #else + if (v1 >= 0 && v2 <= 0) + return -stb__div(-v1,v2); // both negative to avoid overflow + if (v1 <= 0 && v2 >= 0) + if (v1 != INT_MIN) + return -stb__div(v1,-v2); // both negative to avoid overflow + else + return -stb__div(v1+v2,-v2)-1; // push v1 away from wrap point + else + return v1/v2; // same sign, so expect truncation + #endif +} + +int stb_div_floor(int v1, int v2) +{ + #ifdef C_INTEGER_DIVISION_FLOORS + return v1/v2; + #else + if (v1 >= 0 && v2 < 0) { + if (v2 + 1 >= INT_MIN + v1) // check if increasing v1's magnitude overflows + return -stb__div((v2+1)-v1,v2); // nope, so just compute it + else + return -stb__div(-v1,v2) + ((-v1)%v2 ? -1 : 0); + } + if (v1 < 0 && v2 >= 0) { + if (v1 != INT_MIN) { + if (v1 + 1 >= INT_MIN + v2) // check if increasing v1's magnitude overflows + return -stb__div((v1+1)-v2,-v2); // nope, so just compute it + else + return -stb__div(-v1,v2) + (stb__mod(v1,-v2) ? -1 : 0); + } else // it must be possible to compute -(v1+v2) without overflowing + return -stb__div(-(v1+v2),v2) + (stb__mod(-(v1+v2),v2) ? -2 : -1); + } else + return v1/v2; // same sign, so expect truncation + #endif +} + +int stb_div_eucl(int v1, int v2) +{ + int q,r; + #ifdef C_INTEGER_DIVISION_TRUNCATES + q = v1/v2; + r = v1%v2; + #else + // handle every quadrant separately, since we can't rely on q and r flor + if (v1 >= 0) + if (v2 >= 0) + return stb__div(v1,v2); + else if (v2 != INT_MIN) + q = -stb__div(v1,-v2), r = stb__mod(v1,-v2); + else + q = 0, r = v1; + else if (v1 != INT_MIN) + if (v2 >= 0) + q = -stb__div(-v1,v2), r = -stb__mod(-v1,v2); + else if (v2 != INT_MIN) + q = stb__div(-v1,-v2), r = -stb__mod(-v1,-v2); + else // if v2 is INT_MIN, then we can't use -v2, but we can't divide by v2 + q = 1, r = v1-q*v2; + else // if v1 is INT_MIN, we have to move away from overflow place + if (v2 >= 0) + q = -stb__div(-(v1+v2),v2)-1, r = -stb__mod(-(v1+v2),v2); + else if (v2 != INT_MIN) + q = stb__div(-(v1-v2),-v2)+1, r = -stb__mod(-(v1-v2),-v2); + else // for INT_MIN / INT_MIN, we need to be extra-careful to avoid overflow + q = 1, r = 0; + #endif + if (r >= 0) + return q; + else + return q + (v2 > 0 ? -1 : 1); +} + +int stb_mod_trunc(int v1, int v2) +{ + #ifdef C_INTEGER_DIVISION_TRUNCATES + return v1%v2; + #else + if (v1 >= 0) { // modulus result should always be positive + int r = stb__mod(v1,v2); + if (r >= 0) + return r; + else + return r - (v2 < 0 ? v2 : -v2); + } else { // modulus result should always be negative + int r = stb__mod(v1,v2); + if (r <= 0) + return r; + else + return r + (v2 < 0 ? v2 : -v2); + } + #endif +} + +int stb_mod_floor(int v1, int v2) +{ + #ifdef C_INTEGER_DIVISION_FLOORS + return v1%v2; + #else + if (v2 >= 0) { // result should always be positive + int r = stb__mod(v1,v2); + if (r >= 0) + return r; + else + return r + v2; + } else { // result should always be negative + int r = stb__mod(v1,v2); + if (r <= 0) + return r; + else + return r + v2; + } + #endif +} + +int stb_mod_eucl(int v1, int v2) +{ + int r = stb__mod(v1,v2); + + if (r >= 0) + return r; + else + return r - (v2 < 0 ? v2 : -v2); // negative abs() [to avoid overflow] +} + +#ifdef STB_DIVIDE_TEST +#include +#include +#include + +int show=0; +int err=0; + +void stbdiv_check(int q, int r, int a, int b, char *type, int dir) +{ + if ((dir > 0 && r < 0) || (dir < 0 && r > 0)) { + fprintf(stderr, "FAILED: %s(%d,%d) remainder %d in wrong direction\n", type,a,b,r); + err++; + } else + if (b != INT_MIN) // can't compute abs(), but if b==INT_MIN all remainders are valid + if (r <= -abs(b) || r >= abs(b)) { + fprintf(stderr, "FAILED: %s(%d,%d) remainder %d out of range\n", type,a,b,r); + err++; + } + #ifdef STB_DIVIDE_TEST_64 + { + STB_DIVIDE_TEST_64 q64 = q, r64=r, a64=a, b64=b; + if (q64*b64+r64 != a64) { + fprintf(stderr, "FAILED: %s(%d,%d) remainder %d doesn't match quotient %d\n", type,a,b,r,q); + err++; + } + } + #else + if (q*b+r != a) { + fprintf(stderr, "FAILED: %s(%d,%d) remainder %d doesn't match quotient %d\n", type,a,b,r,q); + err++; + } + #endif +} + +void test(int a, int b) +{ + int q,r; + if (show) printf("(%+11d,%+d) | ", a,b); + q = stb_div_trunc(a,b), r = stb_mod_trunc(a,b); + if (show) printf("(%+11d,%+2d) ", q,r); stbdiv_check(q,r,a,b, "trunc",a); + q = stb_div_floor(a,b), r = stb_mod_floor(a,b); + if (show) printf("(%+11d,%+2d) ", q,r); stbdiv_check(q,r,a,b, "floor",b); + q = stb_div_eucl (a,b), r = stb_mod_eucl (a,b); + if (show) printf("(%+11d,%+2d)\n", q,r); stbdiv_check(q,r,a,b, "euclidean",1); +} + +void testh(int a, int b) +{ + int q,r; + if (show) printf("(%08x,%08x) |\n", a,b); + q = stb_div_trunc(a,b), r = stb_mod_trunc(a,b); stbdiv_check(q,r,a,b, "trunc",a); + if (show) printf(" (%08x,%08x)", q,r); + q = stb_div_floor(a,b), r = stb_mod_floor(a,b); stbdiv_check(q,r,a,b, "floor",b); + if (show) printf(" (%08x,%08x)", q,r); + q = stb_div_eucl (a,b), r = stb_mod_eucl (a,b); stbdiv_check(q,r,a,b, "euclidean",1); + if (show) printf(" (%08x,%08x)\n ", q,r); +} + +int main(int argc, char **argv) +{ + if (argc > 1) show=1; + + test(8,3); + test(8,-3); + test(-8,3); + test(-8,-3); + test(1,2); + test(1,-2); + test(-1,2); + test(-1,-2); + test(8,4); + test(8,-4); + test(-8,4); + test(-8,-4); + + test(INT_MAX,1); + test(INT_MIN,1); + test(INT_MIN+1,1); + test(INT_MAX,-1); + //test(INT_MIN,-1); // this traps in MSVC, so we leave it untested + test(INT_MIN+1,-1); + test(INT_MIN,-2); + test(INT_MIN+1,2); + test(INT_MIN+1,-2); + test(INT_MAX,2); + test(INT_MAX,-2); + test(INT_MIN+1,2); + test(INT_MIN+1,-2); + test(INT_MIN,2); + test(INT_MIN,-2); + test(INT_MIN,7); + test(INT_MIN,-7); + test(INT_MIN+1,4); + test(INT_MIN+1,-4); + + testh(-7, INT_MIN); + testh(-1, INT_MIN); + testh(1, INT_MIN); + testh(7, INT_MIN); + + testh(INT_MAX-1, INT_MIN); + testh(INT_MAX, INT_MIN); + testh(INT_MIN, INT_MIN); + testh(INT_MIN+1, INT_MIN); + + testh(INT_MAX-1, INT_MAX); + testh(INT_MAX , INT_MAX); + testh(INT_MIN , INT_MAX); + testh(INT_MIN+1, INT_MAX); + + return err > 0 ? 1 : 0; +} +#endif // STB_DIVIDE_TEST +#endif // STB_DIVIDE_IMPLEMENTATION +#endif // INCLUDE_STB_DIVIDE_H + +/* +------------------------------------------------------------------------------ +This software is available under 2 licenses -- choose whichever you prefer. +------------------------------------------------------------------------------ +ALTERNATIVE A - MIT License +Copyright (c) 2017 Sean Barrett +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is furnished to do +so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +------------------------------------------------------------------------------ +ALTERNATIVE B - Public Domain (www.unlicense.org) +This is free and unencumbered software released into the public domain. +Anyone is free to copy, modify, publish, use, compile, sell, or distribute this +software, either in source code form or as a compiled binary, for any purpose, +commercial or non-commercial, and by any means. +In jurisdictions that recognize copyright laws, the author or authors of this +software dedicate any and all copyright interest in the software to the public +domain. We make this dedication for the benefit of the public at large and to +the detriment of our heirs and successors. We intend this dedication to be an +overt act of relinquishment in perpetuity of all present and future rights to +this software under copyright law. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN +ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +------------------------------------------------------------------------------ +*/ diff --git a/tests/data/c/stb/stb_ds.h b/tests/data/c/stb/stb_ds.h new file mode 100644 index 000000000..e84c82d1d --- /dev/null +++ b/tests/data/c/stb/stb_ds.h @@ -0,0 +1,1895 @@ +/* stb_ds.h - v0.67 - public domain data structures - Sean Barrett 2019 + + This is a single-header-file library that provides easy-to-use + dynamic arrays and hash tables for C (also works in C++). + + For a gentle introduction: + http://nothings.org/stb_ds + + To use this library, do this in *one* C or C++ file: + #define STB_DS_IMPLEMENTATION + #include "stb_ds.h" + +TABLE OF CONTENTS + + Table of Contents + Compile-time options + License + Documentation + Notes + Notes - Dynamic arrays + Notes - Hash maps + Credits + +COMPILE-TIME OPTIONS + + #define STBDS_NO_SHORT_NAMES + + This flag needs to be set globally. + + By default stb_ds exposes shorter function names that are not qualified + with the "stbds_" prefix. If these names conflict with the names in your + code, define this flag. + + #define STBDS_SIPHASH_2_4 + + This flag only needs to be set in the file containing #define STB_DS_IMPLEMENTATION. + + By default stb_ds.h hashes using a weaker variant of SipHash and a custom hash for + 4- and 8-byte keys. On 64-bit platforms, you can define the above flag to force + stb_ds.h to use specification-compliant SipHash-2-4 for all keys. Doing so makes + hash table insertion about 20% slower on 4- and 8-byte keys, 5% slower on + 64-byte keys, and 10% slower on 256-byte keys on my test computer. + + #define STBDS_REALLOC(context,ptr,size) better_realloc + #define STBDS_FREE(context,ptr) better_free + + These defines only need to be set in the file containing #define STB_DS_IMPLEMENTATION. + + By default stb_ds uses stdlib realloc() and free() for memory management. You can + substitute your own functions instead by defining these symbols. You must either + define both, or neither. Note that at the moment, 'context' will always be NULL. + @TODO add an array/hash initialization function that takes a memory context pointer. + + #define STBDS_UNIT_TESTS + + Defines a function stbds_unit_tests() that checks the functioning of the data structures. + + Note that on older versions of gcc (e.g. 5.x.x) you may need to build with '-std=c++0x' + (or equivalentally '-std=c++11') when using anonymous structures as seen on the web + page or in STBDS_UNIT_TESTS. + +LICENSE + + Placed in the public domain and also MIT licensed. + See end of file for detailed license information. + +DOCUMENTATION + + Dynamic Arrays + + Non-function interface: + + Declare an empty dynamic array of type T + T* foo = NULL; + + Access the i'th item of a dynamic array 'foo' of type T, T* foo: + foo[i] + + Functions (actually macros) + + arrfree: + void arrfree(T*); + Frees the array. + + arrlen: + ptrdiff_t arrlen(T*); + Returns the number of elements in the array. + + arrlenu: + size_t arrlenu(T*); + Returns the number of elements in the array as an unsigned type. + + arrpop: + T arrpop(T* a) + Removes the final element of the array and returns it. + + arrput: + T arrput(T* a, T b); + Appends the item b to the end of array a. Returns b. + + arrins: + T arrins(T* a, int p, T b); + Inserts the item b into the middle of array a, into a[p], + moving the rest of the array over. Returns b. + + arrinsn: + void arrinsn(T* a, int p, int n); + Inserts n uninitialized items into array a starting at a[p], + moving the rest of the array over. + + arraddnptr: + T* arraddnptr(T* a, int n) + Appends n uninitialized items onto array at the end. + Returns a pointer to the first uninitialized item added. + + arraddnindex: + size_t arraddnindex(T* a, int n) + Appends n uninitialized items onto array at the end. + Returns the index of the first uninitialized item added. + + arrdel: + void arrdel(T* a, int p); + Deletes the element at a[p], moving the rest of the array over. + + arrdeln: + void arrdeln(T* a, int p, int n); + Deletes n elements starting at a[p], moving the rest of the array over. + + arrdelswap: + void arrdelswap(T* a, int p); + Deletes the element at a[p], replacing it with the element from + the end of the array. O(1) performance. + + arrsetlen: + void arrsetlen(T* a, int n); + Changes the length of the array to n. Allocates uninitialized + slots at the end if necessary. + + arrsetcap: + size_t arrsetcap(T* a, int n); + Sets the length of allocated storage to at least n. It will not + change the length of the array. + + arrcap: + size_t arrcap(T* a); + Returns the number of total elements the array can contain without + needing to be reallocated. + + Hash maps & String hash maps + + Given T is a structure type: struct { TK key; TV value; }. Note that some + functions do not require TV value and can have other fields. For string + hash maps, TK must be 'char *'. + + Special interface: + + stbds_rand_seed: + void stbds_rand_seed(size_t seed); + For security against adversarially chosen data, you should seed the + library with a strong random number. Or at least seed it with time(). + + stbds_hash_string: + size_t stbds_hash_string(char *str, size_t seed); + Returns a hash value for a string. + + stbds_hash_bytes: + size_t stbds_hash_bytes(void *p, size_t len, size_t seed); + These functions hash an arbitrary number of bytes. The function + uses a custom hash for 4- and 8-byte data, and a weakened version + of SipHash for everything else. On 64-bit platforms you can get + specification-compliant SipHash-2-4 on all data by defining + STBDS_SIPHASH_2_4, at a significant cost in speed. + + Non-function interface: + + Declare an empty hash map of type T + T* foo = NULL; + + Access the i'th entry in a hash table T* foo: + foo[i] + + Function interface (actually macros): + + hmfree + shfree + void hmfree(T*); + void shfree(T*); + Frees the hashmap and sets the pointer to NULL. + + hmlen + shlen + ptrdiff_t hmlen(T*) + ptrdiff_t shlen(T*) + Returns the number of elements in the hashmap. + + hmlenu + shlenu + size_t hmlenu(T*) + size_t shlenu(T*) + Returns the number of elements in the hashmap. + + hmgeti + shgeti + hmgeti_ts + ptrdiff_t hmgeti(T*, TK key) + ptrdiff_t shgeti(T*, char* key) + ptrdiff_t hmgeti_ts(T*, TK key, ptrdiff_t tempvar) + Returns the index in the hashmap which has the key 'key', or -1 + if the key is not present. + + hmget + hmget_ts + shget + TV hmget(T*, TK key) + TV shget(T*, char* key) + TV hmget_ts(T*, TK key, ptrdiff_t tempvar) + Returns the value corresponding to 'key' in the hashmap. + The structure must have a 'value' field + + hmgets + shgets + T hmgets(T*, TK key) + T shgets(T*, char* key) + Returns the structure corresponding to 'key' in the hashmap. + + hmgetp + shgetp + hmgetp_ts + hmgetp_null + shgetp_null + T* hmgetp(T*, TK key) + T* shgetp(T*, char* key) + T* hmgetp_ts(T*, TK key, ptrdiff_t tempvar) + T* hmgetp_null(T*, TK key) + T* shgetp_null(T*, char *key) + Returns a pointer to the structure corresponding to 'key' in + the hashmap. Functions ending in "_null" return NULL if the key + is not present in the hashmap; the others return a pointer to a + structure holding the default value (but not the searched-for key). + + hmdefault + shdefault + TV hmdefault(T*, TV value) + TV shdefault(T*, TV value) + Sets the default value for the hashmap, the value which will be + returned by hmget/shget if the key is not present. + + hmdefaults + shdefaults + TV hmdefaults(T*, T item) + TV shdefaults(T*, T item) + Sets the default struct for the hashmap, the contents which will be + returned by hmgets/shgets if the key is not present. + + hmput + shput + TV hmput(T*, TK key, TV value) + TV shput(T*, char* key, TV value) + Inserts a pair into the hashmap. If the key is already + present in the hashmap, updates its value. + + hmputs + shputs + T hmputs(T*, T item) + T shputs(T*, T item) + Inserts a struct with T.key into the hashmap. If the struct is already + present in the hashmap, updates it. + + hmdel + shdel + int hmdel(T*, TK key) + int shdel(T*, char* key) + If 'key' is in the hashmap, deletes its entry and returns 1. + Otherwise returns 0. + + Function interface (actually macros) for strings only: + + sh_new_strdup + void sh_new_strdup(T*); + Overwrites the existing pointer with a newly allocated + string hashmap which will automatically allocate and free + each string key using realloc/free + + sh_new_arena + void sh_new_arena(T*); + Overwrites the existing pointer with a newly allocated + string hashmap which will automatically allocate each string + key to a string arena. Every string key ever used by this + hash table remains in the arena until the arena is freed. + Additionally, any key which is deleted and reinserted will + be allocated multiple times in the string arena. + +NOTES + + * These data structures are realloc'd when they grow, and the macro + "functions" write to the provided pointer. This means: (a) the pointer + must be an lvalue, and (b) the pointer to the data structure is not + stable, and you must maintain it the same as you would a realloc'd + pointer. For example, if you pass a pointer to a dynamic array to a + function which updates it, the function must return back the new + pointer to the caller. This is the price of trying to do this in C. + + * The following are the only functions that are thread-safe on a single data + structure, i.e. can be run in multiple threads simultaneously on the same + data structure + hmlen shlen + hmlenu shlenu + hmget_ts shget_ts + hmgeti_ts shgeti_ts + hmgets_ts shgets_ts + + * You iterate over the contents of a dynamic array and a hashmap in exactly + the same way, using arrlen/hmlen/shlen: + + for (i=0; i < arrlen(foo); ++i) + ... foo[i] ... + + * All operations except arrins/arrdel are O(1) amortized, but individual + operations can be slow, so these data structures may not be suitable + for real time use. Dynamic arrays double in capacity as needed, so + elements are copied an average of once. Hash tables double/halve + their size as needed, with appropriate hysteresis to maintain O(1) + performance. + +NOTES - DYNAMIC ARRAY + + * If you know how long a dynamic array is going to be in advance, you can avoid + extra memory allocations by using arrsetlen to allocate it to that length in + advance and use foo[n] while filling it out, or arrsetcap to allocate the memory + for that length and use arrput/arrpush as normal. + + * Unlike some other versions of the dynamic array, this version should + be safe to use with strict-aliasing optimizations. + +NOTES - HASH MAP + + * For compilers other than GCC and clang (e.g. Visual Studio), for hmput/hmget/hmdel + and variants, the key must be an lvalue (so the macro can take the address of it). + Extensions are used that eliminate this requirement if you're using C99 and later + in GCC or clang, or if you're using C++ in GCC. But note that this can make your + code less portable. + + * To test for presence of a key in a hashmap, just do 'hmgeti(foo,key) >= 0'. + + * The iteration order of your data in the hashmap is determined solely by the + order of insertions and deletions. In particular, if you never delete, new + keys are always added at the end of the array. This will be consistent + across all platforms and versions of the library. However, you should not + attempt to serialize the internal hash table, as the hash is not consistent + between different platforms, and may change with future versions of the library. + + * Use sh_new_arena() for string hashmaps that you never delete from. Initialize + with NULL if you're managing the memory for your strings, or your strings are + never freed (at least until the hashmap is freed). Otherwise, use sh_new_strdup(). + @TODO: make an arena variant that garbage collects the strings with a trivial + copy collector into a new arena whenever the table shrinks / rebuilds. Since + current arena recommendation is to only use arena if it never deletes, then + this can just replace current arena implementation. + + * If adversarial input is a serious concern and you're on a 64-bit platform, + enable STBDS_SIPHASH_2_4 (see the 'Compile-time options' section), and pass + a strong random number to stbds_rand_seed. + + * The default value for the hash table is stored in foo[-1], so if you + use code like 'hmget(T,k)->value = 5' you can accidentally overwrite + the value stored by hmdefault if 'k' is not present. + +CREDITS + + Sean Barrett -- library, idea for dynamic array API/implementation + Per Vognsen -- idea for hash table API/implementation + Rafael Sachetto -- arrpop() + github:HeroicKatora -- arraddn() reworking + + Bugfixes: + Andy Durdin + Shane Liesegang + Vinh Truong + Andreas Molzer + github:hashitaku + github:srdjanstipic + Macoy Madson + Andreas Vennstrom + Tobias Mansfield-Williams +*/ + +#ifdef STBDS_UNIT_TESTS +#define _CRT_SECURE_NO_WARNINGS +#endif + +#ifndef INCLUDE_STB_DS_H +#define INCLUDE_STB_DS_H + +#include +#include + +#ifndef STBDS_NO_SHORT_NAMES +#define arrlen stbds_arrlen +#define arrlenu stbds_arrlenu +#define arrput stbds_arrput +#define arrpush stbds_arrput +#define arrpop stbds_arrpop +#define arrfree stbds_arrfree +#define arraddn stbds_arraddn // deprecated, use one of the following instead: +#define arraddnptr stbds_arraddnptr +#define arraddnindex stbds_arraddnindex +#define arrsetlen stbds_arrsetlen +#define arrlast stbds_arrlast +#define arrins stbds_arrins +#define arrinsn stbds_arrinsn +#define arrdel stbds_arrdel +#define arrdeln stbds_arrdeln +#define arrdelswap stbds_arrdelswap +#define arrcap stbds_arrcap +#define arrsetcap stbds_arrsetcap + +#define hmput stbds_hmput +#define hmputs stbds_hmputs +#define hmget stbds_hmget +#define hmget_ts stbds_hmget_ts +#define hmgets stbds_hmgets +#define hmgetp stbds_hmgetp +#define hmgetp_ts stbds_hmgetp_ts +#define hmgetp_null stbds_hmgetp_null +#define hmgeti stbds_hmgeti +#define hmgeti_ts stbds_hmgeti_ts +#define hmdel stbds_hmdel +#define hmlen stbds_hmlen +#define hmlenu stbds_hmlenu +#define hmfree stbds_hmfree +#define hmdefault stbds_hmdefault +#define hmdefaults stbds_hmdefaults + +#define shput stbds_shput +#define shputi stbds_shputi +#define shputs stbds_shputs +#define shget stbds_shget +#define shgeti stbds_shgeti +#define shgets stbds_shgets +#define shgetp stbds_shgetp +#define shgetp_null stbds_shgetp_null +#define shdel stbds_shdel +#define shlen stbds_shlen +#define shlenu stbds_shlenu +#define shfree stbds_shfree +#define shdefault stbds_shdefault +#define shdefaults stbds_shdefaults +#define sh_new_arena stbds_sh_new_arena +#define sh_new_strdup stbds_sh_new_strdup + +#define stralloc stbds_stralloc +#define strreset stbds_strreset +#endif + +#if defined(STBDS_REALLOC) && !defined(STBDS_FREE) || !defined(STBDS_REALLOC) && defined(STBDS_FREE) +#error "You must define both STBDS_REALLOC and STBDS_FREE, or neither." +#endif +#if !defined(STBDS_REALLOC) && !defined(STBDS_FREE) +#include +#define STBDS_REALLOC(c,p,s) realloc(p,s) +#define STBDS_FREE(c,p) free(p) +#endif + +#ifdef _MSC_VER +#define STBDS_NOTUSED(v) (void)(v) +#else +#define STBDS_NOTUSED(v) (void)sizeof(v) +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +// for security against attackers, seed the library with a random number, at least time() but stronger is better +extern void stbds_rand_seed(size_t seed); + +// these are the hash functions used internally if you want to test them or use them for other purposes +extern size_t stbds_hash_bytes(void *p, size_t len, size_t seed); +extern size_t stbds_hash_string(char *str, size_t seed); + +// this is a simple string arena allocator, initialize with e.g. 'stbds_string_arena my_arena={0}'. +typedef struct stbds_string_arena stbds_string_arena; +extern char * stbds_stralloc(stbds_string_arena *a, char *str); +extern void stbds_strreset(stbds_string_arena *a); + +// have to #define STBDS_UNIT_TESTS to call this +extern void stbds_unit_tests(void); + +/////////////// +// +// Everything below here is implementation details +// + +extern void * stbds_arrgrowf(void *a, size_t elemsize, size_t addlen, size_t min_cap); +extern void stbds_arrfreef(void *a); +extern void stbds_hmfree_func(void *p, size_t elemsize); +extern void * stbds_hmget_key(void *a, size_t elemsize, void *key, size_t keysize, int mode); +extern void * stbds_hmget_key_ts(void *a, size_t elemsize, void *key, size_t keysize, ptrdiff_t *temp, int mode); +extern void * stbds_hmput_default(void *a, size_t elemsize); +extern void * stbds_hmput_key(void *a, size_t elemsize, void *key, size_t keysize, int mode); +extern void * stbds_hmdel_key(void *a, size_t elemsize, void *key, size_t keysize, size_t keyoffset, int mode); +extern void * stbds_shmode_func(size_t elemsize, int mode); + +#ifdef __cplusplus +} +#endif + +#if defined(__GNUC__) || defined(__clang__) +#define STBDS_HAS_TYPEOF +#ifdef __cplusplus +//#define STBDS_HAS_LITERAL_ARRAY // this is currently broken for clang +#endif +#endif + +#if !defined(__cplusplus) +#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L +#define STBDS_HAS_LITERAL_ARRAY +#endif +#endif + +// this macro takes the address of the argument, but on gcc/clang can accept rvalues +#if defined(STBDS_HAS_LITERAL_ARRAY) && defined(STBDS_HAS_TYPEOF) + #if __clang__ + #define STBDS_ADDRESSOF(typevar, value) ((__typeof__(typevar)[1]){value}) // literal array decays to pointer to value + #else + #define STBDS_ADDRESSOF(typevar, value) ((typeof(typevar)[1]){value}) // literal array decays to pointer to value + #endif +#else +#define STBDS_ADDRESSOF(typevar, value) &(value) +#endif + +#define STBDS_OFFSETOF(var,field) ((char *) &(var)->field - (char *) (var)) + +#define stbds_header(t) ((stbds_array_header *) (t) - 1) +#define stbds_temp(t) stbds_header(t)->temp +#define stbds_temp_key(t) (*(char **) stbds_header(t)->hash_table) + +#define stbds_arrsetcap(a,n) (stbds_arrgrow(a,0,n)) +#define stbds_arrsetlen(a,n) ((stbds_arrcap(a) < (size_t) (n) ? stbds_arrsetcap((a),(size_t)(n)),0 : 0), (a) ? stbds_header(a)->length = (size_t) (n) : 0) +#define stbds_arrcap(a) ((a) ? stbds_header(a)->capacity : 0) +#define stbds_arrlen(a) ((a) ? (ptrdiff_t) stbds_header(a)->length : 0) +#define stbds_arrlenu(a) ((a) ? stbds_header(a)->length : 0) +#define stbds_arrput(a,v) (stbds_arrmaybegrow(a,1), (a)[stbds_header(a)->length++] = (v)) +#define stbds_arrpush stbds_arrput // synonym +#define stbds_arrpop(a) (stbds_header(a)->length--, (a)[stbds_header(a)->length]) +#define stbds_arraddn(a,n) ((void)(stbds_arraddnindex(a, n))) // deprecated, use one of the following instead: +#define stbds_arraddnptr(a,n) (stbds_arrmaybegrow(a,n), (n) ? (stbds_header(a)->length += (n), &(a)[stbds_header(a)->length-(n)]) : (a)) +#define stbds_arraddnindex(a,n)(stbds_arrmaybegrow(a,n), (n) ? (stbds_header(a)->length += (n), stbds_header(a)->length-(n)) : stbds_arrlen(a)) +#define stbds_arraddnoff stbds_arraddnindex +#define stbds_arrlast(a) ((a)[stbds_header(a)->length-1]) +#define stbds_arrfree(a) ((void) ((a) ? STBDS_FREE(NULL,stbds_header(a)) : (void)0), (a)=NULL) +#define stbds_arrdel(a,i) stbds_arrdeln(a,i,1) +#define stbds_arrdeln(a,i,n) (memmove(&(a)[i], &(a)[(i)+(n)], sizeof *(a) * (stbds_header(a)->length-(n)-(i))), stbds_header(a)->length -= (n)) +#define stbds_arrdelswap(a,i) ((a)[i] = stbds_arrlast(a), stbds_header(a)->length -= 1) +#define stbds_arrinsn(a,i,n) (stbds_arraddn((a),(n)), memmove(&(a)[(i)+(n)], &(a)[i], sizeof *(a) * (stbds_header(a)->length-(n)-(i)))) +#define stbds_arrins(a,i,v) (stbds_arrinsn((a),(i),1), (a)[i]=(v)) + +#define stbds_arrmaybegrow(a,n) ((!(a) || stbds_header(a)->length + (n) > stbds_header(a)->capacity) \ + ? (stbds_arrgrow(a,n,0),0) : 0) + +#define stbds_arrgrow(a,b,c) ((a) = stbds_arrgrowf_wrapper((a), sizeof *(a), (b), (c))) + +#define stbds_hmput(t, k, v) \ + ((t) = stbds_hmput_key_wrapper((t), sizeof *(t), (void*) STBDS_ADDRESSOF((t)->key, (k)), sizeof (t)->key, 0), \ + (t)[stbds_temp((t)-1)].key = (k), \ + (t)[stbds_temp((t)-1)].value = (v)) + +#define stbds_hmputs(t, s) \ + ((t) = stbds_hmput_key_wrapper((t), sizeof *(t), &(s).key, sizeof (s).key, STBDS_HM_BINARY), \ + (t)[stbds_temp((t)-1)] = (s)) + +#define stbds_hmgeti(t,k) \ + ((t) = stbds_hmget_key_wrapper((t), sizeof *(t), (void*) STBDS_ADDRESSOF((t)->key, (k)), sizeof (t)->key, STBDS_HM_BINARY), \ + stbds_temp((t)-1)) + +#define stbds_hmgeti_ts(t,k,temp) \ + ((t) = stbds_hmget_key_ts_wrapper((t), sizeof *(t), (void*) STBDS_ADDRESSOF((t)->key, (k)), sizeof (t)->key, &(temp), STBDS_HM_BINARY), \ + (temp)) + +#define stbds_hmgetp(t, k) \ + ((void) stbds_hmgeti(t,k), &(t)[stbds_temp((t)-1)]) + +#define stbds_hmgetp_ts(t, k, temp) \ + ((void) stbds_hmgeti_ts(t,k,temp), &(t)[temp]) + +#define stbds_hmdel(t,k) \ + (((t) = stbds_hmdel_key_wrapper((t),sizeof *(t), (void*) STBDS_ADDRESSOF((t)->key, (k)), sizeof (t)->key, STBDS_OFFSETOF((t),key), STBDS_HM_BINARY)),(t)?stbds_temp((t)-1):0) + +#define stbds_hmdefault(t, v) \ + ((t) = stbds_hmput_default_wrapper((t), sizeof *(t)), (t)[-1].value = (v)) + +#define stbds_hmdefaults(t, s) \ + ((t) = stbds_hmput_default_wrapper((t), sizeof *(t)), (t)[-1] = (s)) + +#define stbds_hmfree(p) \ + ((void) ((p) != NULL ? stbds_hmfree_func((p)-1,sizeof*(p)),0 : 0),(p)=NULL) + +#define stbds_hmgets(t, k) (*stbds_hmgetp(t,k)) +#define stbds_hmget(t, k) (stbds_hmgetp(t,k)->value) +#define stbds_hmget_ts(t, k, temp) (stbds_hmgetp_ts(t,k,temp)->value) +#define stbds_hmlen(t) ((t) ? (ptrdiff_t) stbds_header((t)-1)->length-1 : 0) +#define stbds_hmlenu(t) ((t) ? stbds_header((t)-1)->length-1 : 0) +#define stbds_hmgetp_null(t,k) (stbds_hmgeti(t,k) == -1 ? NULL : &(t)[stbds_temp((t)-1)]) + +#define stbds_shput(t, k, v) \ + ((t) = stbds_hmput_key_wrapper((t), sizeof *(t), (void*) (k), sizeof (t)->key, STBDS_HM_STRING), \ + (t)[stbds_temp((t)-1)].value = (v)) + +#define stbds_shputi(t, k, v) \ + ((t) = stbds_hmput_key_wrapper((t), sizeof *(t), (void*) (k), sizeof (t)->key, STBDS_HM_STRING), \ + (t)[stbds_temp((t)-1)].value = (v), stbds_temp((t)-1)) + +#define stbds_shputs(t, s) \ + ((t) = stbds_hmput_key_wrapper((t), sizeof *(t), (void*) (s).key, sizeof (s).key, STBDS_HM_STRING), \ + (t)[stbds_temp((t)-1)] = (s), \ + (t)[stbds_temp((t)-1)].key = stbds_temp_key((t)-1)) // above line overwrites whole structure, so must rewrite key here if it was allocated internally + +#define stbds_pshput(t, p) \ + ((t) = stbds_hmput_key_wrapper((t), sizeof *(t), (void*) (p)->key, sizeof (p)->key, STBDS_HM_PTR_TO_STRING), \ + (t)[stbds_temp((t)-1)] = (p)) + +#define stbds_shgeti(t,k) \ + ((t) = stbds_hmget_key_wrapper((t), sizeof *(t), (void*) (k), sizeof (t)->key, STBDS_HM_STRING), \ + stbds_temp((t)-1)) + +#define stbds_pshgeti(t,k) \ + ((t) = stbds_hmget_key_wrapper((t), sizeof *(t), (void*) (k), sizeof (*(t))->key, STBDS_HM_PTR_TO_STRING), \ + stbds_temp((t)-1)) + +#define stbds_shgetp(t, k) \ + ((void) stbds_shgeti(t,k), &(t)[stbds_temp((t)-1)]) + +#define stbds_pshget(t, k) \ + ((void) stbds_pshgeti(t,k), (t)[stbds_temp((t)-1)]) + +#define stbds_shdel(t,k) \ + (((t) = stbds_hmdel_key_wrapper((t),sizeof *(t), (void*) (k), sizeof (t)->key, STBDS_OFFSETOF((t),key), STBDS_HM_STRING)),(t)?stbds_temp((t)-1):0) +#define stbds_pshdel(t,k) \ + (((t) = stbds_hmdel_key_wrapper((t),sizeof *(t), (void*) (k), sizeof (*(t))->key, STBDS_OFFSETOF(*(t),key), STBDS_HM_PTR_TO_STRING)),(t)?stbds_temp((t)-1):0) + +#define stbds_sh_new_arena(t) \ + ((t) = stbds_shmode_func_wrapper(t, sizeof *(t), STBDS_SH_ARENA)) +#define stbds_sh_new_strdup(t) \ + ((t) = stbds_shmode_func_wrapper(t, sizeof *(t), STBDS_SH_STRDUP)) + +#define stbds_shdefault(t, v) stbds_hmdefault(t,v) +#define stbds_shdefaults(t, s) stbds_hmdefaults(t,s) + +#define stbds_shfree stbds_hmfree +#define stbds_shlenu stbds_hmlenu + +#define stbds_shgets(t, k) (*stbds_shgetp(t,k)) +#define stbds_shget(t, k) (stbds_shgetp(t,k)->value) +#define stbds_shgetp_null(t,k) (stbds_shgeti(t,k) == -1 ? NULL : &(t)[stbds_temp((t)-1)]) +#define stbds_shlen stbds_hmlen + +typedef struct +{ + size_t length; + size_t capacity; + void * hash_table; + ptrdiff_t temp; +} stbds_array_header; + +typedef struct stbds_string_block +{ + struct stbds_string_block *next; + char storage[8]; +} stbds_string_block; + +struct stbds_string_arena +{ + stbds_string_block *storage; + size_t remaining; + unsigned char block; + unsigned char mode; // this isn't used by the string arena itself +}; + +#define STBDS_HM_BINARY 0 +#define STBDS_HM_STRING 1 + +enum +{ + STBDS_SH_NONE, + STBDS_SH_DEFAULT, + STBDS_SH_STRDUP, + STBDS_SH_ARENA +}; + +#ifdef __cplusplus +// in C we use implicit assignment from these void*-returning functions to T*. +// in C++ these templates make the same code work +template static T * stbds_arrgrowf_wrapper(T *a, size_t elemsize, size_t addlen, size_t min_cap) { + return (T*)stbds_arrgrowf((void *)a, elemsize, addlen, min_cap); +} +template static T * stbds_hmget_key_wrapper(T *a, size_t elemsize, void *key, size_t keysize, int mode) { + return (T*)stbds_hmget_key((void*)a, elemsize, key, keysize, mode); +} +template static T * stbds_hmget_key_ts_wrapper(T *a, size_t elemsize, void *key, size_t keysize, ptrdiff_t *temp, int mode) { + return (T*)stbds_hmget_key_ts((void*)a, elemsize, key, keysize, temp, mode); +} +template static T * stbds_hmput_default_wrapper(T *a, size_t elemsize) { + return (T*)stbds_hmput_default((void *)a, elemsize); +} +template static T * stbds_hmput_key_wrapper(T *a, size_t elemsize, void *key, size_t keysize, int mode) { + return (T*)stbds_hmput_key((void*)a, elemsize, key, keysize, mode); +} +template static T * stbds_hmdel_key_wrapper(T *a, size_t elemsize, void *key, size_t keysize, size_t keyoffset, int mode){ + return (T*)stbds_hmdel_key((void*)a, elemsize, key, keysize, keyoffset, mode); +} +template static T * stbds_shmode_func_wrapper(T *, size_t elemsize, int mode) { + return (T*)stbds_shmode_func(elemsize, mode); +} +#else +#define stbds_arrgrowf_wrapper stbds_arrgrowf +#define stbds_hmget_key_wrapper stbds_hmget_key +#define stbds_hmget_key_ts_wrapper stbds_hmget_key_ts +#define stbds_hmput_default_wrapper stbds_hmput_default +#define stbds_hmput_key_wrapper stbds_hmput_key +#define stbds_hmdel_key_wrapper stbds_hmdel_key +#define stbds_shmode_func_wrapper(t,e,m) stbds_shmode_func(e,m) +#endif + +#endif // INCLUDE_STB_DS_H + + +////////////////////////////////////////////////////////////////////////////// +// +// IMPLEMENTATION +// + +#ifdef STB_DS_IMPLEMENTATION +#include +#include + +#ifndef STBDS_ASSERT +#define STBDS_ASSERT_WAS_UNDEFINED +#define STBDS_ASSERT(x) ((void) 0) +#endif + +#ifdef STBDS_STATISTICS +#define STBDS_STATS(x) x +size_t stbds_array_grow; +size_t stbds_hash_grow; +size_t stbds_hash_shrink; +size_t stbds_hash_rebuild; +size_t stbds_hash_probes; +size_t stbds_hash_alloc; +size_t stbds_rehash_probes; +size_t stbds_rehash_items; +#else +#define STBDS_STATS(x) +#endif + +// +// stbds_arr implementation +// + +//int *prev_allocs[65536]; +//int num_prev; + +void *stbds_arrgrowf(void *a, size_t elemsize, size_t addlen, size_t min_cap) +{ + stbds_array_header temp={0}; // force debugging + void *b; + size_t min_len = stbds_arrlen(a) + addlen; + (void) sizeof(temp); + + // compute the minimum capacity needed + if (min_len > min_cap) + min_cap = min_len; + + if (min_cap <= stbds_arrcap(a)) + return a; + + // increase needed capacity to guarantee O(1) amortized + if (min_cap < 2 * stbds_arrcap(a)) + min_cap = 2 * stbds_arrcap(a); + else if (min_cap < 4) + min_cap = 4; + + //if (num_prev < 65536) if (a) prev_allocs[num_prev++] = (int *) ((char *) a+1); + //if (num_prev == 2201) + // num_prev = num_prev; + b = STBDS_REALLOC(NULL, (a) ? stbds_header(a) : 0, elemsize * min_cap + sizeof(stbds_array_header)); + //if (num_prev < 65536) prev_allocs[num_prev++] = (int *) (char *) b; + b = (char *) b + sizeof(stbds_array_header); + if (a == NULL) { + stbds_header(b)->length = 0; + stbds_header(b)->hash_table = 0; + stbds_header(b)->temp = 0; + } else { + STBDS_STATS(++stbds_array_grow); + } + stbds_header(b)->capacity = min_cap; + + return b; +} + +void stbds_arrfreef(void *a) +{ + STBDS_FREE(NULL, stbds_header(a)); +} + +// +// stbds_hm hash table implementation +// + +#ifdef STBDS_INTERNAL_SMALL_BUCKET +#define STBDS_BUCKET_LENGTH 4 +#else +#define STBDS_BUCKET_LENGTH 8 +#endif + +#define STBDS_BUCKET_SHIFT (STBDS_BUCKET_LENGTH == 8 ? 3 : 2) +#define STBDS_BUCKET_MASK (STBDS_BUCKET_LENGTH-1) +#define STBDS_CACHE_LINE_SIZE 64 + +#define STBDS_ALIGN_FWD(n,a) (((n) + (a) - 1) & ~((a)-1)) + +typedef struct +{ + size_t hash [STBDS_BUCKET_LENGTH]; + ptrdiff_t index[STBDS_BUCKET_LENGTH]; +} stbds_hash_bucket; // in 32-bit, this is one 64-byte cache line; in 64-bit, each array is one 64-byte cache line + +typedef struct +{ + char * temp_key; // this MUST be the first field of the hash table + size_t slot_count; + size_t used_count; + size_t used_count_threshold; + size_t used_count_shrink_threshold; + size_t tombstone_count; + size_t tombstone_count_threshold; + size_t seed; + size_t slot_count_log2; + stbds_string_arena string; + stbds_hash_bucket *storage; // not a separate allocation, just 64-byte aligned storage after this struct +} stbds_hash_index; + +#define STBDS_INDEX_EMPTY -1 +#define STBDS_INDEX_DELETED -2 +#define STBDS_INDEX_IN_USE(x) ((x) >= 0) + +#define STBDS_HASH_EMPTY 0 +#define STBDS_HASH_DELETED 1 + +static size_t stbds_hash_seed=0x31415926; + +void stbds_rand_seed(size_t seed) +{ + stbds_hash_seed = seed; +} + +#define stbds_load_32_or_64(var, temp, v32, v64_hi, v64_lo) \ + temp = v64_lo ^ v32, temp <<= 16, temp <<= 16, temp >>= 16, temp >>= 16, /* discard if 32-bit */ \ + var = v64_hi, var <<= 16, var <<= 16, /* discard if 32-bit */ \ + var ^= temp ^ v32 + +#define STBDS_SIZE_T_BITS ((sizeof (size_t)) * 8) + +static size_t stbds_probe_position(size_t hash, size_t slot_count, size_t slot_log2) +{ + size_t pos; + STBDS_NOTUSED(slot_log2); + pos = hash & (slot_count-1); + #ifdef STBDS_INTERNAL_BUCKET_START + pos &= ~STBDS_BUCKET_MASK; + #endif + return pos; +} + +static size_t stbds_log2(size_t slot_count) +{ + size_t n=0; + while (slot_count > 1) { + slot_count >>= 1; + ++n; + } + return n; +} + +static stbds_hash_index *stbds_make_hash_index(size_t slot_count, stbds_hash_index *ot) +{ + stbds_hash_index *t; + t = (stbds_hash_index *) STBDS_REALLOC(NULL,0,(slot_count >> STBDS_BUCKET_SHIFT) * sizeof(stbds_hash_bucket) + sizeof(stbds_hash_index) + STBDS_CACHE_LINE_SIZE-1); + t->storage = (stbds_hash_bucket *) STBDS_ALIGN_FWD((size_t) (t+1), STBDS_CACHE_LINE_SIZE); + t->slot_count = slot_count; + t->slot_count_log2 = stbds_log2(slot_count); + t->tombstone_count = 0; + t->used_count = 0; + + #if 0 // A1 + t->used_count_threshold = slot_count*12/16; // if 12/16th of table is occupied, grow + t->tombstone_count_threshold = slot_count* 2/16; // if tombstones are 2/16th of table, rebuild + t->used_count_shrink_threshold = slot_count* 4/16; // if table is only 4/16th full, shrink + #elif 1 // A2 + //t->used_count_threshold = slot_count*12/16; // if 12/16th of table is occupied, grow + //t->tombstone_count_threshold = slot_count* 3/16; // if tombstones are 3/16th of table, rebuild + //t->used_count_shrink_threshold = slot_count* 4/16; // if table is only 4/16th full, shrink + + // compute without overflowing + t->used_count_threshold = slot_count - (slot_count>>2); + t->tombstone_count_threshold = (slot_count>>3) + (slot_count>>4); + t->used_count_shrink_threshold = slot_count >> 2; + + #elif 0 // B1 + t->used_count_threshold = slot_count*13/16; // if 13/16th of table is occupied, grow + t->tombstone_count_threshold = slot_count* 2/16; // if tombstones are 2/16th of table, rebuild + t->used_count_shrink_threshold = slot_count* 5/16; // if table is only 5/16th full, shrink + #else // C1 + t->used_count_threshold = slot_count*14/16; // if 14/16th of table is occupied, grow + t->tombstone_count_threshold = slot_count* 2/16; // if tombstones are 2/16th of table, rebuild + t->used_count_shrink_threshold = slot_count* 6/16; // if table is only 6/16th full, shrink + #endif + // Following statistics were measured on a Core i7-6700 @ 4.00Ghz, compiled with clang 7.0.1 -O2 + // Note that the larger tables have high variance as they were run fewer times + // A1 A2 B1 C1 + // 0.10ms : 0.10ms : 0.10ms : 0.11ms : 2,000 inserts creating 2K table + // 0.96ms : 0.95ms : 0.97ms : 1.04ms : 20,000 inserts creating 20K table + // 14.48ms : 14.46ms : 10.63ms : 11.00ms : 200,000 inserts creating 200K table + // 195.74ms : 196.35ms : 203.69ms : 214.92ms : 2,000,000 inserts creating 2M table + // 2193.88ms : 2209.22ms : 2285.54ms : 2437.17ms : 20,000,000 inserts creating 20M table + // 65.27ms : 53.77ms : 65.33ms : 65.47ms : 500,000 inserts & deletes in 2K table + // 72.78ms : 62.45ms : 71.95ms : 72.85ms : 500,000 inserts & deletes in 20K table + // 89.47ms : 77.72ms : 96.49ms : 96.75ms : 500,000 inserts & deletes in 200K table + // 97.58ms : 98.14ms : 97.18ms : 97.53ms : 500,000 inserts & deletes in 2M table + // 118.61ms : 119.62ms : 120.16ms : 118.86ms : 500,000 inserts & deletes in 20M table + // 192.11ms : 194.39ms : 196.38ms : 195.73ms : 500,000 inserts & deletes in 200M table + + if (slot_count <= STBDS_BUCKET_LENGTH) + t->used_count_shrink_threshold = 0; + // to avoid infinite loop, we need to guarantee that at least one slot is empty and will terminate probes + STBDS_ASSERT(t->used_count_threshold + t->tombstone_count_threshold < t->slot_count); + STBDS_STATS(++stbds_hash_alloc); + if (ot) { + t->string = ot->string; + // reuse old seed so we can reuse old hashes so below "copy out old data" doesn't do any hashing + t->seed = ot->seed; + } else { + size_t a,b,temp; + memset(&t->string, 0, sizeof(t->string)); + t->seed = stbds_hash_seed; + // LCG + // in 32-bit, a = 2147001325 b = 715136305 + // in 64-bit, a = 2862933555777941757 b = 3037000493 + stbds_load_32_or_64(a,temp, 2147001325, 0x27bb2ee6, 0x87b0b0fd); + stbds_load_32_or_64(b,temp, 715136305, 0, 0xb504f32d); + stbds_hash_seed = stbds_hash_seed * a + b; + } + + { + size_t i,j; + for (i=0; i < slot_count >> STBDS_BUCKET_SHIFT; ++i) { + stbds_hash_bucket *b = &t->storage[i]; + for (j=0; j < STBDS_BUCKET_LENGTH; ++j) + b->hash[j] = STBDS_HASH_EMPTY; + for (j=0; j < STBDS_BUCKET_LENGTH; ++j) + b->index[j] = STBDS_INDEX_EMPTY; + } + } + + // copy out the old data, if any + if (ot) { + size_t i,j; + t->used_count = ot->used_count; + for (i=0; i < ot->slot_count >> STBDS_BUCKET_SHIFT; ++i) { + stbds_hash_bucket *ob = &ot->storage[i]; + for (j=0; j < STBDS_BUCKET_LENGTH; ++j) { + if (STBDS_INDEX_IN_USE(ob->index[j])) { + size_t hash = ob->hash[j]; + size_t pos = stbds_probe_position(hash, t->slot_count, t->slot_count_log2); + size_t step = STBDS_BUCKET_LENGTH; + STBDS_STATS(++stbds_rehash_items); + for (;;) { + size_t limit,z; + stbds_hash_bucket *bucket; + bucket = &t->storage[pos >> STBDS_BUCKET_SHIFT]; + STBDS_STATS(++stbds_rehash_probes); + + for (z=pos & STBDS_BUCKET_MASK; z < STBDS_BUCKET_LENGTH; ++z) { + if (bucket->hash[z] == 0) { + bucket->hash[z] = hash; + bucket->index[z] = ob->index[j]; + goto done; + } + } + + limit = pos & STBDS_BUCKET_MASK; + for (z = 0; z < limit; ++z) { + if (bucket->hash[z] == 0) { + bucket->hash[z] = hash; + bucket->index[z] = ob->index[j]; + goto done; + } + } + + pos += step; // quadratic probing + step += STBDS_BUCKET_LENGTH; + pos &= (t->slot_count-1); + } + } + done: + ; + } + } + } + + return t; +} + +#define STBDS_ROTATE_LEFT(val, n) (((val) << (n)) | ((val) >> (STBDS_SIZE_T_BITS - (n)))) +#define STBDS_ROTATE_RIGHT(val, n) (((val) >> (n)) | ((val) << (STBDS_SIZE_T_BITS - (n)))) + +size_t stbds_hash_string(char *str, size_t seed) +{ + size_t hash = seed; + while (*str) + hash = STBDS_ROTATE_LEFT(hash, 9) + (unsigned char) *str++; + + // Thomas Wang 64-to-32 bit mix function, hopefully also works in 32 bits + hash ^= seed; + hash = (~hash) + (hash << 18); + hash ^= hash ^ STBDS_ROTATE_RIGHT(hash,31); + hash = hash * 21; + hash ^= hash ^ STBDS_ROTATE_RIGHT(hash,11); + hash += (hash << 6); + hash ^= STBDS_ROTATE_RIGHT(hash,22); + return hash+seed; +} + +#ifdef STBDS_SIPHASH_2_4 +#define STBDS_SIPHASH_C_ROUNDS 2 +#define STBDS_SIPHASH_D_ROUNDS 4 +typedef int STBDS_SIPHASH_2_4_can_only_be_used_in_64_bit_builds[sizeof(size_t) == 8 ? 1 : -1]; +#endif + +#ifndef STBDS_SIPHASH_C_ROUNDS +#define STBDS_SIPHASH_C_ROUNDS 1 +#endif +#ifndef STBDS_SIPHASH_D_ROUNDS +#define STBDS_SIPHASH_D_ROUNDS 1 +#endif + +#ifdef _MSC_VER +#pragma warning(push) +#pragma warning(disable:4127) // conditional expression is constant, for do..while(0) and sizeof()== +#endif + +static size_t stbds_siphash_bytes(void *p, size_t len, size_t seed) +{ + unsigned char *d = (unsigned char *) p; + size_t i,j; + size_t v0,v1,v2,v3, data; + + // hash that works on 32- or 64-bit registers without knowing which we have + // (computes different results on 32-bit and 64-bit platform) + // derived from siphash, but on 32-bit platforms very different as it uses 4 32-bit state not 4 64-bit + v0 = ((((size_t) 0x736f6d65 << 16) << 16) + 0x70736575) ^ seed; + v1 = ((((size_t) 0x646f7261 << 16) << 16) + 0x6e646f6d) ^ ~seed; + v2 = ((((size_t) 0x6c796765 << 16) << 16) + 0x6e657261) ^ seed; + v3 = ((((size_t) 0x74656462 << 16) << 16) + 0x79746573) ^ ~seed; + + #ifdef STBDS_TEST_SIPHASH_2_4 + // hardcoded with key material in the siphash test vectors + v0 ^= 0x0706050403020100ull ^ seed; + v1 ^= 0x0f0e0d0c0b0a0908ull ^ ~seed; + v2 ^= 0x0706050403020100ull ^ seed; + v3 ^= 0x0f0e0d0c0b0a0908ull ^ ~seed; + #endif + + #define STBDS_SIPROUND() \ + do { \ + v0 += v1; v1 = STBDS_ROTATE_LEFT(v1, 13); v1 ^= v0; v0 = STBDS_ROTATE_LEFT(v0,STBDS_SIZE_T_BITS/2); \ + v2 += v3; v3 = STBDS_ROTATE_LEFT(v3, 16); v3 ^= v2; \ + v2 += v1; v1 = STBDS_ROTATE_LEFT(v1, 17); v1 ^= v2; v2 = STBDS_ROTATE_LEFT(v2,STBDS_SIZE_T_BITS/2); \ + v0 += v3; v3 = STBDS_ROTATE_LEFT(v3, 21); v3 ^= v0; \ + } while (0) + + for (i=0; i+sizeof(size_t) <= len; i += sizeof(size_t), d += sizeof(size_t)) { + data = d[0] | (d[1] << 8) | (d[2] << 16) | (d[3] << 24); + data |= (size_t) (d[4] | (d[5] << 8) | (d[6] << 16) | (d[7] << 24)) << 16 << 16; // discarded if size_t == 4 + + v3 ^= data; + for (j=0; j < STBDS_SIPHASH_C_ROUNDS; ++j) + STBDS_SIPROUND(); + v0 ^= data; + } + data = len << (STBDS_SIZE_T_BITS-8); + switch (len - i) { + case 7: data |= ((size_t) d[6] << 24) << 24; // fall through + case 6: data |= ((size_t) d[5] << 20) << 20; // fall through + case 5: data |= ((size_t) d[4] << 16) << 16; // fall through + case 4: data |= (d[3] << 24); // fall through + case 3: data |= (d[2] << 16); // fall through + case 2: data |= (d[1] << 8); // fall through + case 1: data |= d[0]; // fall through + case 0: break; + } + v3 ^= data; + for (j=0; j < STBDS_SIPHASH_C_ROUNDS; ++j) + STBDS_SIPROUND(); + v0 ^= data; + v2 ^= 0xff; + for (j=0; j < STBDS_SIPHASH_D_ROUNDS; ++j) + STBDS_SIPROUND(); + +#ifdef STBDS_SIPHASH_2_4 + return v0^v1^v2^v3; +#else + return v1^v2^v3; // slightly stronger since v0^v3 in above cancels out final round operation? I tweeted at the authors of SipHash about this but they didn't reply +#endif +} + +size_t stbds_hash_bytes(void *p, size_t len, size_t seed) +{ +#ifdef STBDS_SIPHASH_2_4 + return stbds_siphash_bytes(p,len,seed); +#else + unsigned char *d = (unsigned char *) p; + + if (len == 4) { + unsigned int hash = d[0] | (d[1] << 8) | (d[2] << 16) | (d[3] << 24); + #if 0 + // HASH32-A Bob Jenkin's hash function w/o large constants + hash ^= seed; + hash -= (hash<<6); + hash ^= (hash>>17); + hash -= (hash<<9); + hash ^= seed; + hash ^= (hash<<4); + hash -= (hash<<3); + hash ^= (hash<<10); + hash ^= (hash>>15); + #elif 1 + // HASH32-BB Bob Jenkin's presumably-accidental version of Thomas Wang hash with rotates turned into shifts. + // Note that converting these back to rotates makes it run a lot slower, presumably due to collisions, so I'm + // not really sure what's going on. + hash ^= seed; + hash = (hash ^ 61) ^ (hash >> 16); + hash = hash + (hash << 3); + hash = hash ^ (hash >> 4); + hash = hash * 0x27d4eb2d; + hash ^= seed; + hash = hash ^ (hash >> 15); + #else // HASH32-C - Murmur3 + hash ^= seed; + hash *= 0xcc9e2d51; + hash = (hash << 17) | (hash >> 15); + hash *= 0x1b873593; + hash ^= seed; + hash = (hash << 19) | (hash >> 13); + hash = hash*5 + 0xe6546b64; + hash ^= hash >> 16; + hash *= 0x85ebca6b; + hash ^= seed; + hash ^= hash >> 13; + hash *= 0xc2b2ae35; + hash ^= hash >> 16; + #endif + // Following statistics were measured on a Core i7-6700 @ 4.00Ghz, compiled with clang 7.0.1 -O2 + // Note that the larger tables have high variance as they were run fewer times + // HASH32-A // HASH32-BB // HASH32-C + // 0.10ms // 0.10ms // 0.10ms : 2,000 inserts creating 2K table + // 0.96ms // 0.95ms // 0.99ms : 20,000 inserts creating 20K table + // 14.69ms // 14.43ms // 14.97ms : 200,000 inserts creating 200K table + // 199.99ms // 195.36ms // 202.05ms : 2,000,000 inserts creating 2M table + // 2234.84ms // 2187.74ms // 2240.38ms : 20,000,000 inserts creating 20M table + // 55.68ms // 53.72ms // 57.31ms : 500,000 inserts & deletes in 2K table + // 63.43ms // 61.99ms // 65.73ms : 500,000 inserts & deletes in 20K table + // 80.04ms // 77.96ms // 81.83ms : 500,000 inserts & deletes in 200K table + // 100.42ms // 97.40ms // 102.39ms : 500,000 inserts & deletes in 2M table + // 119.71ms // 120.59ms // 121.63ms : 500,000 inserts & deletes in 20M table + // 185.28ms // 195.15ms // 187.74ms : 500,000 inserts & deletes in 200M table + // 15.58ms // 14.79ms // 15.52ms : 200,000 inserts creating 200K table with varying key spacing + + return (((size_t) hash << 16 << 16) | hash) ^ seed; + } else if (len == 8 && sizeof(size_t) == 8) { + size_t hash = d[0] | (d[1] << 8) | (d[2] << 16) | (d[3] << 24); + hash |= (size_t) (d[4] | (d[5] << 8) | (d[6] << 16) | (d[7] << 24)) << 16 << 16; // avoid warning if size_t == 4 + hash ^= seed; + hash = (~hash) + (hash << 21); + hash ^= STBDS_ROTATE_RIGHT(hash,24); + hash *= 265; + hash ^= STBDS_ROTATE_RIGHT(hash,14); + hash ^= seed; + hash *= 21; + hash ^= STBDS_ROTATE_RIGHT(hash,28); + hash += (hash << 31); + hash = (~hash) + (hash << 18); + return hash; + } else { + return stbds_siphash_bytes(p,len,seed); + } +#endif +} +#ifdef _MSC_VER +#pragma warning(pop) +#endif + + +static int stbds_is_key_equal(void *a, size_t elemsize, void *key, size_t keysize, size_t keyoffset, int mode, size_t i) +{ + if (mode >= STBDS_HM_STRING) + return 0==strcmp((char *) key, * (char **) ((char *) a + elemsize*i + keyoffset)); + else + return 0==memcmp(key, (char *) a + elemsize*i + keyoffset, keysize); +} + +#define STBDS_HASH_TO_ARR(x,elemsize) ((char*) (x) - (elemsize)) +#define STBDS_ARR_TO_HASH(x,elemsize) ((char*) (x) + (elemsize)) + +#define stbds_hash_table(a) ((stbds_hash_index *) stbds_header(a)->hash_table) + +void stbds_hmfree_func(void *a, size_t elemsize) +{ + if (a == NULL) return; + if (stbds_hash_table(a) != NULL) { + if (stbds_hash_table(a)->string.mode == STBDS_SH_STRDUP) { + size_t i; + // skip 0th element, which is default + for (i=1; i < stbds_header(a)->length; ++i) + STBDS_FREE(NULL, *(char**) ((char *) a + elemsize*i)); + } + stbds_strreset(&stbds_hash_table(a)->string); + } + STBDS_FREE(NULL, stbds_header(a)->hash_table); + STBDS_FREE(NULL, stbds_header(a)); +} + +static ptrdiff_t stbds_hm_find_slot(void *a, size_t elemsize, void *key, size_t keysize, size_t keyoffset, int mode) +{ + void *raw_a = STBDS_HASH_TO_ARR(a,elemsize); + stbds_hash_index *table = stbds_hash_table(raw_a); + size_t hash = mode >= STBDS_HM_STRING ? stbds_hash_string((char*)key,table->seed) : stbds_hash_bytes(key, keysize,table->seed); + size_t step = STBDS_BUCKET_LENGTH; + size_t limit,i; + size_t pos; + stbds_hash_bucket *bucket; + + if (hash < 2) hash += 2; // stored hash values are forbidden from being 0, so we can detect empty slots + + pos = stbds_probe_position(hash, table->slot_count, table->slot_count_log2); + + for (;;) { + STBDS_STATS(++stbds_hash_probes); + bucket = &table->storage[pos >> STBDS_BUCKET_SHIFT]; + + // start searching from pos to end of bucket, this should help performance on small hash tables that fit in cache + for (i=pos & STBDS_BUCKET_MASK; i < STBDS_BUCKET_LENGTH; ++i) { + if (bucket->hash[i] == hash) { + if (stbds_is_key_equal(a, elemsize, key, keysize, keyoffset, mode, bucket->index[i])) { + return (pos & ~STBDS_BUCKET_MASK)+i; + } + } else if (bucket->hash[i] == STBDS_HASH_EMPTY) { + return -1; + } + } + + // search from beginning of bucket to pos + limit = pos & STBDS_BUCKET_MASK; + for (i = 0; i < limit; ++i) { + if (bucket->hash[i] == hash) { + if (stbds_is_key_equal(a, elemsize, key, keysize, keyoffset, mode, bucket->index[i])) { + return (pos & ~STBDS_BUCKET_MASK)+i; + } + } else if (bucket->hash[i] == STBDS_HASH_EMPTY) { + return -1; + } + } + + // quadratic probing + pos += step; + step += STBDS_BUCKET_LENGTH; + pos &= (table->slot_count-1); + } + /* NOTREACHED */ +} + +void * stbds_hmget_key_ts(void *a, size_t elemsize, void *key, size_t keysize, ptrdiff_t *temp, int mode) +{ + size_t keyoffset = 0; + if (a == NULL) { + // make it non-empty so we can return a temp + a = stbds_arrgrowf(0, elemsize, 0, 1); + stbds_header(a)->length += 1; + memset(a, 0, elemsize); + *temp = STBDS_INDEX_EMPTY; + // adjust a to point after the default element + return STBDS_ARR_TO_HASH(a,elemsize); + } else { + stbds_hash_index *table; + void *raw_a = STBDS_HASH_TO_ARR(a,elemsize); + // adjust a to point to the default element + table = (stbds_hash_index *) stbds_header(raw_a)->hash_table; + if (table == 0) { + *temp = -1; + } else { + ptrdiff_t slot = stbds_hm_find_slot(a, elemsize, key, keysize, keyoffset, mode); + if (slot < 0) { + *temp = STBDS_INDEX_EMPTY; + } else { + stbds_hash_bucket *b = &table->storage[slot >> STBDS_BUCKET_SHIFT]; + *temp = b->index[slot & STBDS_BUCKET_MASK]; + } + } + return a; + } +} + +void * stbds_hmget_key(void *a, size_t elemsize, void *key, size_t keysize, int mode) +{ + ptrdiff_t temp; + void *p = stbds_hmget_key_ts(a, elemsize, key, keysize, &temp, mode); + stbds_temp(STBDS_HASH_TO_ARR(p,elemsize)) = temp; + return p; +} + +void * stbds_hmput_default(void *a, size_t elemsize) +{ + // three cases: + // a is NULL <- allocate + // a has a hash table but no entries, because of shmode <- grow + // a has entries <- do nothing + if (a == NULL || stbds_header(STBDS_HASH_TO_ARR(a,elemsize))->length == 0) { + a = stbds_arrgrowf(a ? STBDS_HASH_TO_ARR(a,elemsize) : NULL, elemsize, 0, 1); + stbds_header(a)->length += 1; + memset(a, 0, elemsize); + a=STBDS_ARR_TO_HASH(a,elemsize); + } + return a; +} + +static char *stbds_strdup(char *str); + +void *stbds_hmput_key(void *a, size_t elemsize, void *key, size_t keysize, int mode) +{ + size_t keyoffset=0; + void *raw_a; + stbds_hash_index *table; + + if (a == NULL) { + a = stbds_arrgrowf(0, elemsize, 0, 1); + memset(a, 0, elemsize); + stbds_header(a)->length += 1; + // adjust a to point AFTER the default element + a = STBDS_ARR_TO_HASH(a,elemsize); + } + + // adjust a to point to the default element + raw_a = a; + a = STBDS_HASH_TO_ARR(a,elemsize); + + table = (stbds_hash_index *) stbds_header(a)->hash_table; + + if (table == NULL || table->used_count >= table->used_count_threshold) { + stbds_hash_index *nt; + size_t slot_count; + + slot_count = (table == NULL) ? STBDS_BUCKET_LENGTH : table->slot_count*2; + nt = stbds_make_hash_index(slot_count, table); + if (table) + STBDS_FREE(NULL, table); + else + nt->string.mode = mode >= STBDS_HM_STRING ? STBDS_SH_DEFAULT : 0; + stbds_header(a)->hash_table = table = nt; + STBDS_STATS(++stbds_hash_grow); + } + + // we iterate hash table explicitly because we want to track if we saw a tombstone + { + size_t hash = mode >= STBDS_HM_STRING ? stbds_hash_string((char*)key,table->seed) : stbds_hash_bytes(key, keysize,table->seed); + size_t step = STBDS_BUCKET_LENGTH; + size_t pos; + ptrdiff_t tombstone = -1; + stbds_hash_bucket *bucket; + + // stored hash values are forbidden from being 0, so we can detect empty slots to early out quickly + if (hash < 2) hash += 2; + + pos = stbds_probe_position(hash, table->slot_count, table->slot_count_log2); + + for (;;) { + size_t limit, i; + STBDS_STATS(++stbds_hash_probes); + bucket = &table->storage[pos >> STBDS_BUCKET_SHIFT]; + + // start searching from pos to end of bucket + for (i=pos & STBDS_BUCKET_MASK; i < STBDS_BUCKET_LENGTH; ++i) { + if (bucket->hash[i] == hash) { + if (stbds_is_key_equal(raw_a, elemsize, key, keysize, keyoffset, mode, bucket->index[i])) { + stbds_temp(a) = bucket->index[i]; + if (mode >= STBDS_HM_STRING) + stbds_temp_key(a) = * (char **) ((char *) raw_a + elemsize*bucket->index[i] + keyoffset); + return STBDS_ARR_TO_HASH(a,elemsize); + } + } else if (bucket->hash[i] == 0) { + pos = (pos & ~STBDS_BUCKET_MASK) + i; + goto found_empty_slot; + } else if (tombstone < 0) { + if (bucket->index[i] == STBDS_INDEX_DELETED) + tombstone = (ptrdiff_t) ((pos & ~STBDS_BUCKET_MASK) + i); + } + } + + // search from beginning of bucket to pos + limit = pos & STBDS_BUCKET_MASK; + for (i = 0; i < limit; ++i) { + if (bucket->hash[i] == hash) { + if (stbds_is_key_equal(raw_a, elemsize, key, keysize, keyoffset, mode, bucket->index[i])) { + stbds_temp(a) = bucket->index[i]; + return STBDS_ARR_TO_HASH(a,elemsize); + } + } else if (bucket->hash[i] == 0) { + pos = (pos & ~STBDS_BUCKET_MASK) + i; + goto found_empty_slot; + } else if (tombstone < 0) { + if (bucket->index[i] == STBDS_INDEX_DELETED) + tombstone = (ptrdiff_t) ((pos & ~STBDS_BUCKET_MASK) + i); + } + } + + // quadratic probing + pos += step; + step += STBDS_BUCKET_LENGTH; + pos &= (table->slot_count-1); + } + found_empty_slot: + if (tombstone >= 0) { + pos = tombstone; + --table->tombstone_count; + } + ++table->used_count; + + { + ptrdiff_t i = (ptrdiff_t) stbds_arrlen(a); + // we want to do stbds_arraddn(1), but we can't use the macros since we don't have something of the right type + if ((size_t) i+1 > stbds_arrcap(a)) + *(void **) &a = stbds_arrgrowf(a, elemsize, 1, 0); + raw_a = STBDS_ARR_TO_HASH(a,elemsize); + + STBDS_ASSERT((size_t) i+1 <= stbds_arrcap(a)); + stbds_header(a)->length = i+1; + bucket = &table->storage[pos >> STBDS_BUCKET_SHIFT]; + bucket->hash[pos & STBDS_BUCKET_MASK] = hash; + bucket->index[pos & STBDS_BUCKET_MASK] = i-1; + stbds_temp(a) = i-1; + + switch (table->string.mode) { + case STBDS_SH_STRDUP: stbds_temp_key(a) = *(char **) ((char *) a + elemsize*i) = stbds_strdup((char*) key); break; + case STBDS_SH_ARENA: stbds_temp_key(a) = *(char **) ((char *) a + elemsize*i) = stbds_stralloc(&table->string, (char*)key); break; + case STBDS_SH_DEFAULT: stbds_temp_key(a) = *(char **) ((char *) a + elemsize*i) = (char *) key; break; + default: memcpy((char *) a + elemsize*i, key, keysize); break; + } + } + return STBDS_ARR_TO_HASH(a,elemsize); + } +} + +void * stbds_shmode_func(size_t elemsize, int mode) +{ + void *a = stbds_arrgrowf(0, elemsize, 0, 1); + stbds_hash_index *h; + memset(a, 0, elemsize); + stbds_header(a)->length = 1; + stbds_header(a)->hash_table = h = (stbds_hash_index *) stbds_make_hash_index(STBDS_BUCKET_LENGTH, NULL); + h->string.mode = (unsigned char) mode; + return STBDS_ARR_TO_HASH(a,elemsize); +} + +void * stbds_hmdel_key(void *a, size_t elemsize, void *key, size_t keysize, size_t keyoffset, int mode) +{ + if (a == NULL) { + return 0; + } else { + stbds_hash_index *table; + void *raw_a = STBDS_HASH_TO_ARR(a,elemsize); + table = (stbds_hash_index *) stbds_header(raw_a)->hash_table; + stbds_temp(raw_a) = 0; + if (table == 0) { + return a; + } else { + ptrdiff_t slot; + slot = stbds_hm_find_slot(a, elemsize, key, keysize, keyoffset, mode); + if (slot < 0) + return a; + else { + stbds_hash_bucket *b = &table->storage[slot >> STBDS_BUCKET_SHIFT]; + int i = slot & STBDS_BUCKET_MASK; + ptrdiff_t old_index = b->index[i]; + ptrdiff_t final_index = (ptrdiff_t) stbds_arrlen(raw_a)-1-1; // minus one for the raw_a vs a, and minus one for 'last' + STBDS_ASSERT(slot < (ptrdiff_t) table->slot_count); + --table->used_count; + ++table->tombstone_count; + stbds_temp(raw_a) = 1; + STBDS_ASSERT(table->used_count >= 0); + //STBDS_ASSERT(table->tombstone_count < table->slot_count/4); + b->hash[i] = STBDS_HASH_DELETED; + b->index[i] = STBDS_INDEX_DELETED; + + if (mode == STBDS_HM_STRING && table->string.mode == STBDS_SH_STRDUP) + STBDS_FREE(NULL, *(char**) ((char *) a+elemsize*old_index)); + + // if indices are the same, memcpy is a no-op, but back-pointer-fixup will fail, so skip + if (old_index != final_index) { + // swap delete + memmove((char*) a + elemsize*old_index, (char*) a + elemsize*final_index, elemsize); + + // now find the slot for the last element + if (mode == STBDS_HM_STRING) + slot = stbds_hm_find_slot(a, elemsize, *(char**) ((char *) a+elemsize*old_index + keyoffset), keysize, keyoffset, mode); + else + slot = stbds_hm_find_slot(a, elemsize, (char* ) a+elemsize*old_index + keyoffset, keysize, keyoffset, mode); + STBDS_ASSERT(slot >= 0); + b = &table->storage[slot >> STBDS_BUCKET_SHIFT]; + i = slot & STBDS_BUCKET_MASK; + STBDS_ASSERT(b->index[i] == final_index); + b->index[i] = old_index; + } + stbds_header(raw_a)->length -= 1; + + if (table->used_count < table->used_count_shrink_threshold && table->slot_count > STBDS_BUCKET_LENGTH) { + stbds_header(raw_a)->hash_table = stbds_make_hash_index(table->slot_count>>1, table); + STBDS_FREE(NULL, table); + STBDS_STATS(++stbds_hash_shrink); + } else if (table->tombstone_count > table->tombstone_count_threshold) { + stbds_header(raw_a)->hash_table = stbds_make_hash_index(table->slot_count , table); + STBDS_FREE(NULL, table); + STBDS_STATS(++stbds_hash_rebuild); + } + + return a; + } + } + } + /* NOTREACHED */ +} + +static char *stbds_strdup(char *str) +{ + // to keep replaceable allocator simple, we don't want to use strdup. + // rolling our own also avoids problem of strdup vs _strdup + size_t len = strlen(str)+1; + char *p = (char*) STBDS_REALLOC(NULL, 0, len); + memmove(p, str, len); + return p; +} + +#ifndef STBDS_STRING_ARENA_BLOCKSIZE_MIN +#define STBDS_STRING_ARENA_BLOCKSIZE_MIN 512u +#endif +#ifndef STBDS_STRING_ARENA_BLOCKSIZE_MAX +#define STBDS_STRING_ARENA_BLOCKSIZE_MAX (1u<<20) +#endif + +char *stbds_stralloc(stbds_string_arena *a, char *str) +{ + char *p; + size_t len = strlen(str)+1; + if (len > a->remaining) { + // compute the next blocksize + size_t blocksize = a->block; + + // size is 512, 512, 1024, 1024, 2048, 2048, 4096, 4096, etc., so that + // there are log(SIZE) allocations to free when we destroy the table + blocksize = (size_t) (STBDS_STRING_ARENA_BLOCKSIZE_MIN) << (blocksize>>1); + + // if size is under 1M, advance to next blocktype + if (blocksize < (size_t)(STBDS_STRING_ARENA_BLOCKSIZE_MAX)) + ++a->block; + + if (len > blocksize) { + // if string is larger than blocksize, then just allocate the full size. + // note that we still advance string_block so block size will continue + // increasing, so e.g. if somebody only calls this with 1000-long strings, + // eventually the arena will start doubling and handling those as well + stbds_string_block *sb = (stbds_string_block *) STBDS_REALLOC(NULL, 0, sizeof(*sb)-8 + len); + memmove(sb->storage, str, len); + if (a->storage) { + // insert it after the first element, so that we don't waste the space there + sb->next = a->storage->next; + a->storage->next = sb; + } else { + sb->next = 0; + a->storage = sb; + a->remaining = 0; // this is redundant, but good for clarity + } + return sb->storage; + } else { + stbds_string_block *sb = (stbds_string_block *) STBDS_REALLOC(NULL, 0, sizeof(*sb)-8 + blocksize); + sb->next = a->storage; + a->storage = sb; + a->remaining = blocksize; + } + } + + STBDS_ASSERT(len <= a->remaining); + p = a->storage->storage + a->remaining - len; + a->remaining -= len; + memmove(p, str, len); + return p; +} + +void stbds_strreset(stbds_string_arena *a) +{ + stbds_string_block *x,*y; + x = a->storage; + while (x) { + y = x->next; + STBDS_FREE(NULL, x); + x = y; + } + memset(a, 0, sizeof(*a)); +} + +#endif + +////////////////////////////////////////////////////////////////////////////// +// +// UNIT TESTS +// + +#ifdef STBDS_UNIT_TESTS +#include +#ifdef STBDS_ASSERT_WAS_UNDEFINED +#undef STBDS_ASSERT +#endif +#ifndef STBDS_ASSERT +#define STBDS_ASSERT assert +#include +#endif + +typedef struct { int key,b,c,d; } stbds_struct; +typedef struct { int key[2],b,c,d; } stbds_struct2; + +static char buffer[256]; +char *strkey(int n) +{ +#if defined(_WIN32) && defined(__STDC_WANT_SECURE_LIB__) + sprintf_s(buffer, sizeof(buffer), "test_%d", n); +#else + sprintf(buffer, "test_%d", n); +#endif + return buffer; +} + +void stbds_unit_tests(void) +{ +#if defined(_MSC_VER) && _MSC_VER <= 1200 && defined(__cplusplus) + // VC6 C++ doesn't like the template<> trick on unnamed structures, so do nothing! + STBDS_ASSERT(0); +#else + const int testsize = 100000; + const int testsize2 = testsize/20; + int *arr=NULL; + struct { int key; int value; } *intmap = NULL; + struct { char *key; int value; } *strmap = NULL, s; + struct { stbds_struct key; int value; } *map = NULL; + stbds_struct *map2 = NULL; + stbds_struct2 *map3 = NULL; + stbds_string_arena sa = { 0 }; + int key3[2] = { 1,2 }; + ptrdiff_t temp; + + int i,j; + + STBDS_ASSERT(arrlen(arr)==0); + for (i=0; i < 20000; i += 50) { + for (j=0; j < i; ++j) + arrpush(arr,j); + arrfree(arr); + } + + for (i=0; i < 4; ++i) { + arrpush(arr,1); arrpush(arr,2); arrpush(arr,3); arrpush(arr,4); + arrdel(arr,i); + arrfree(arr); + arrpush(arr,1); arrpush(arr,2); arrpush(arr,3); arrpush(arr,4); + arrdelswap(arr,i); + arrfree(arr); + } + + for (i=0; i < 5; ++i) { + arrpush(arr,1); arrpush(arr,2); arrpush(arr,3); arrpush(arr,4); + stbds_arrins(arr,i,5); + STBDS_ASSERT(arr[i] == 5); + if (i < 4) + STBDS_ASSERT(arr[4] == 4); + arrfree(arr); + } + + i = 1; + STBDS_ASSERT(hmgeti(intmap,i) == -1); + hmdefault(intmap, -2); + STBDS_ASSERT(hmgeti(intmap, i) == -1); + STBDS_ASSERT(hmget (intmap, i) == -2); + for (i=0; i < testsize; i+=2) + hmput(intmap, i, i*5); + for (i=0; i < testsize; i+=1) { + if (i & 1) STBDS_ASSERT(hmget(intmap, i) == -2 ); + else STBDS_ASSERT(hmget(intmap, i) == i*5); + if (i & 1) STBDS_ASSERT(hmget_ts(intmap, i, temp) == -2 ); + else STBDS_ASSERT(hmget_ts(intmap, i, temp) == i*5); + } + for (i=0; i < testsize; i+=2) + hmput(intmap, i, i*3); + for (i=0; i < testsize; i+=1) + if (i & 1) STBDS_ASSERT(hmget(intmap, i) == -2 ); + else STBDS_ASSERT(hmget(intmap, i) == i*3); + for (i=2; i < testsize; i+=4) + hmdel(intmap, i); // delete half the entries + for (i=0; i < testsize; i+=1) + if (i & 3) STBDS_ASSERT(hmget(intmap, i) == -2 ); + else STBDS_ASSERT(hmget(intmap, i) == i*3); + for (i=0; i < testsize; i+=1) + hmdel(intmap, i); // delete the rest of the entries + for (i=0; i < testsize; i+=1) + STBDS_ASSERT(hmget(intmap, i) == -2 ); + hmfree(intmap); + for (i=0; i < testsize; i+=2) + hmput(intmap, i, i*3); + hmfree(intmap); + + #if defined(__clang__) || defined(__GNUC__) + #ifndef __cplusplus + intmap = NULL; + hmput(intmap, 15, 7); + hmput(intmap, 11, 3); + hmput(intmap, 9, 5); + STBDS_ASSERT(hmget(intmap, 9) == 5); + STBDS_ASSERT(hmget(intmap, 11) == 3); + STBDS_ASSERT(hmget(intmap, 15) == 7); + #endif + #endif + + for (i=0; i < testsize; ++i) + stralloc(&sa, strkey(i)); + strreset(&sa); + + { + s.key = "a", s.value = 1; + shputs(strmap, s); + STBDS_ASSERT(*strmap[0].key == 'a'); + STBDS_ASSERT(strmap[0].key == s.key); + STBDS_ASSERT(strmap[0].value == s.value); + shfree(strmap); + } + + { + s.key = "a", s.value = 1; + sh_new_strdup(strmap); + shputs(strmap, s); + STBDS_ASSERT(*strmap[0].key == 'a'); + STBDS_ASSERT(strmap[0].key != s.key); + STBDS_ASSERT(strmap[0].value == s.value); + shfree(strmap); + } + + { + s.key = "a", s.value = 1; + sh_new_arena(strmap); + shputs(strmap, s); + STBDS_ASSERT(*strmap[0].key == 'a'); + STBDS_ASSERT(strmap[0].key != s.key); + STBDS_ASSERT(strmap[0].value == s.value); + shfree(strmap); + } + + for (j=0; j < 2; ++j) { + STBDS_ASSERT(shgeti(strmap,"foo") == -1); + if (j == 0) + sh_new_strdup(strmap); + else + sh_new_arena(strmap); + STBDS_ASSERT(shgeti(strmap,"foo") == -1); + shdefault(strmap, -2); + STBDS_ASSERT(shgeti(strmap,"foo") == -1); + for (i=0; i < testsize; i+=2) + shput(strmap, strkey(i), i*3); + for (i=0; i < testsize; i+=1) + if (i & 1) STBDS_ASSERT(shget(strmap, strkey(i)) == -2 ); + else STBDS_ASSERT(shget(strmap, strkey(i)) == i*3); + for (i=2; i < testsize; i+=4) + shdel(strmap, strkey(i)); // delete half the entries + for (i=0; i < testsize; i+=1) + if (i & 3) STBDS_ASSERT(shget(strmap, strkey(i)) == -2 ); + else STBDS_ASSERT(shget(strmap, strkey(i)) == i*3); + for (i=0; i < testsize; i+=1) + shdel(strmap, strkey(i)); // delete the rest of the entries + for (i=0; i < testsize; i+=1) + STBDS_ASSERT(shget(strmap, strkey(i)) == -2 ); + shfree(strmap); + } + + { + struct { char *key; char value; } *hash = NULL; + char name[4] = "jen"; + shput(hash, "bob" , 'h'); + shput(hash, "sally" , 'e'); + shput(hash, "fred" , 'l'); + shput(hash, "jen" , 'x'); + shput(hash, "doug" , 'o'); + + shput(hash, name , 'l'); + shfree(hash); + } + + for (i=0; i < testsize; i += 2) { + stbds_struct s = { i,i*2,i*3,i*4 }; + hmput(map, s, i*5); + } + + for (i=0; i < testsize; i += 1) { + stbds_struct s = { i,i*2,i*3 ,i*4 }; + stbds_struct t = { i,i*2,i*3+1,i*4 }; + if (i & 1) STBDS_ASSERT(hmget(map, s) == 0); + else STBDS_ASSERT(hmget(map, s) == i*5); + if (i & 1) STBDS_ASSERT(hmget_ts(map, s, temp) == 0); + else STBDS_ASSERT(hmget_ts(map, s, temp) == i*5); + //STBDS_ASSERT(hmget(map, t.key) == 0); + } + + for (i=0; i < testsize; i += 2) { + stbds_struct s = { i,i*2,i*3,i*4 }; + hmputs(map2, s); + } + hmfree(map); + + for (i=0; i < testsize; i += 1) { + stbds_struct s = { i,i*2,i*3,i*4 }; + stbds_struct t = { i,i*2,i*3+1,i*4 }; + if (i & 1) STBDS_ASSERT(hmgets(map2, s.key).d == 0); + else STBDS_ASSERT(hmgets(map2, s.key).d == i*4); + //STBDS_ASSERT(hmgetp(map2, t.key) == 0); + } + hmfree(map2); + + for (i=0; i < testsize; i += 2) { + stbds_struct2 s = { { i,i*2 }, i*3,i*4, i*5 }; + hmputs(map3, s); + } + for (i=0; i < testsize; i += 1) { + stbds_struct2 s = { { i,i*2}, i*3, i*4, i*5 }; + stbds_struct2 t = { { i,i*2}, i*3+1, i*4, i*5 }; + if (i & 1) STBDS_ASSERT(hmgets(map3, s.key).d == 0); + else STBDS_ASSERT(hmgets(map3, s.key).d == i*5); + //STBDS_ASSERT(hmgetp(map3, t.key) == 0); + } +#endif +} +#endif + + +/* +------------------------------------------------------------------------------ +This software is available under 2 licenses -- choose whichever you prefer. +------------------------------------------------------------------------------ +ALTERNATIVE A - MIT License +Copyright (c) 2019 Sean Barrett +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is furnished to do +so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +------------------------------------------------------------------------------ +ALTERNATIVE B - Public Domain (www.unlicense.org) +This is free and unencumbered software released into the public domain. +Anyone is free to copy, modify, publish, use, compile, sell, or distribute this +software, either in source code form or as a compiled binary, for any purpose, +commercial or non-commercial, and by any means. +In jurisdictions that recognize copyright laws, the author or authors of this +software dedicate any and all copyright interest in the software to the public +domain. We make this dedication for the benefit of the public at large and to +the detriment of our heirs and successors. We intend this dedication to be an +overt act of relinquishment in perpetuity of all present and future rights to +this software under copyright law. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN +ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +------------------------------------------------------------------------------ +*/ diff --git a/tests/data/c/stb/stb_dxt.h b/tests/data/c/stb/stb_dxt.h new file mode 100644 index 000000000..6150a87f0 --- /dev/null +++ b/tests/data/c/stb/stb_dxt.h @@ -0,0 +1,719 @@ +// stb_dxt.h - v1.12 - DXT1/DXT5 compressor - public domain +// original by fabian "ryg" giesen - ported to C by stb +// use '#define STB_DXT_IMPLEMENTATION' before including to create the implementation +// +// USAGE: +// call stb_compress_dxt_block() for every block (you must pad) +// source should be a 4x4 block of RGBA data in row-major order; +// Alpha channel is not stored if you specify alpha=0 (but you +// must supply some constant alpha in the alpha channel). +// You can turn on dithering and "high quality" using mode. +// +// version history: +// v1.12 - (ryg) fix bug in single-color table generator +// v1.11 - (ryg) avoid racy global init, better single-color tables, remove dither +// v1.10 - (i.c) various small quality improvements +// v1.09 - (stb) update documentation re: surprising alpha channel requirement +// v1.08 - (stb) fix bug in dxt-with-alpha block +// v1.07 - (stb) bc4; allow not using libc; add STB_DXT_STATIC +// v1.06 - (stb) fix to known-broken 1.05 +// v1.05 - (stb) support bc5/3dc (Arvids Kokins), use extern "C" in C++ (Pavel Krajcevski) +// v1.04 - (ryg) default to no rounding bias for lerped colors (as per S3TC/DX10 spec); +// single color match fix (allow for inexact color interpolation); +// optimal DXT5 index finder; "high quality" mode that runs multiple refinement steps. +// v1.03 - (stb) endianness support +// v1.02 - (stb) fix alpha encoding bug +// v1.01 - (stb) fix bug converting to RGB that messed up quality, thanks ryg & cbloom +// v1.00 - (stb) first release +// +// contributors: +// Rich Geldreich (more accurate index selection) +// Kevin Schmidt (#defines for "freestanding" compilation) +// github:ppiastucki (BC4 support) +// Ignacio Castano - improve DXT endpoint quantization +// Alan Hickman - static table initialization +// +// LICENSE +// +// See end of file for license information. + +#ifndef STB_INCLUDE_STB_DXT_H +#define STB_INCLUDE_STB_DXT_H + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef STB_DXT_STATIC +#define STBDDEF static +#else +#define STBDDEF extern +#endif + +// compression mode (bitflags) +#define STB_DXT_NORMAL 0 +#define STB_DXT_DITHER 1 // use dithering. was always dubious, now deprecated. does nothing! +#define STB_DXT_HIGHQUAL 2 // high quality mode, does two refinement steps instead of 1. ~30-40% slower. + +STBDDEF void stb_compress_dxt_block(unsigned char *dest, const unsigned char *src_rgba_four_bytes_per_pixel, int alpha, int mode); +STBDDEF void stb_compress_bc4_block(unsigned char *dest, const unsigned char *src_r_one_byte_per_pixel); +STBDDEF void stb_compress_bc5_block(unsigned char *dest, const unsigned char *src_rg_two_byte_per_pixel); + +#define STB_COMPRESS_DXT_BLOCK + +#ifdef __cplusplus +} +#endif +#endif // STB_INCLUDE_STB_DXT_H + +#ifdef STB_DXT_IMPLEMENTATION + +// configuration options for DXT encoder. set them in the project/makefile or just define +// them at the top. + +// STB_DXT_USE_ROUNDING_BIAS +// use a rounding bias during color interpolation. this is closer to what "ideal" +// interpolation would do but doesn't match the S3TC/DX10 spec. old versions (pre-1.03) +// implicitly had this turned on. +// +// in case you're targeting a specific type of hardware (e.g. console programmers): +// NVidia and Intel GPUs (as of 2010) as well as DX9 ref use DXT decoders that are closer +// to STB_DXT_USE_ROUNDING_BIAS. AMD/ATI, S3 and DX10 ref are closer to rounding with no bias. +// you also see "(a*5 + b*3) / 8" on some old GPU designs. +// #define STB_DXT_USE_ROUNDING_BIAS + +#include + +#if !defined(STBD_FABS) +#include +#endif + +#ifndef STBD_FABS +#define STBD_FABS(x) fabs(x) +#endif + +static const unsigned char stb__OMatch5[256][2] = { + { 0, 0 }, { 0, 0 }, { 0, 1 }, { 0, 1 }, { 1, 0 }, { 1, 0 }, { 1, 0 }, { 1, 1 }, + { 1, 1 }, { 1, 1 }, { 1, 2 }, { 0, 4 }, { 2, 1 }, { 2, 1 }, { 2, 1 }, { 2, 2 }, + { 2, 2 }, { 2, 2 }, { 2, 3 }, { 1, 5 }, { 3, 2 }, { 3, 2 }, { 4, 0 }, { 3, 3 }, + { 3, 3 }, { 3, 3 }, { 3, 4 }, { 3, 4 }, { 3, 4 }, { 3, 5 }, { 4, 3 }, { 4, 3 }, + { 5, 2 }, { 4, 4 }, { 4, 4 }, { 4, 5 }, { 4, 5 }, { 5, 4 }, { 5, 4 }, { 5, 4 }, + { 6, 3 }, { 5, 5 }, { 5, 5 }, { 5, 6 }, { 4, 8 }, { 6, 5 }, { 6, 5 }, { 6, 5 }, + { 6, 6 }, { 6, 6 }, { 6, 6 }, { 6, 7 }, { 5, 9 }, { 7, 6 }, { 7, 6 }, { 8, 4 }, + { 7, 7 }, { 7, 7 }, { 7, 7 }, { 7, 8 }, { 7, 8 }, { 7, 8 }, { 7, 9 }, { 8, 7 }, + { 8, 7 }, { 9, 6 }, { 8, 8 }, { 8, 8 }, { 8, 9 }, { 8, 9 }, { 9, 8 }, { 9, 8 }, + { 9, 8 }, { 10, 7 }, { 9, 9 }, { 9, 9 }, { 9, 10 }, { 8, 12 }, { 10, 9 }, { 10, 9 }, + { 10, 9 }, { 10, 10 }, { 10, 10 }, { 10, 10 }, { 10, 11 }, { 9, 13 }, { 11, 10 }, { 11, 10 }, + { 12, 8 }, { 11, 11 }, { 11, 11 }, { 11, 11 }, { 11, 12 }, { 11, 12 }, { 11, 12 }, { 11, 13 }, + { 12, 11 }, { 12, 11 }, { 13, 10 }, { 12, 12 }, { 12, 12 }, { 12, 13 }, { 12, 13 }, { 13, 12 }, + { 13, 12 }, { 13, 12 }, { 14, 11 }, { 13, 13 }, { 13, 13 }, { 13, 14 }, { 12, 16 }, { 14, 13 }, + { 14, 13 }, { 14, 13 }, { 14, 14 }, { 14, 14 }, { 14, 14 }, { 14, 15 }, { 13, 17 }, { 15, 14 }, + { 15, 14 }, { 16, 12 }, { 15, 15 }, { 15, 15 }, { 15, 15 }, { 15, 16 }, { 15, 16 }, { 15, 16 }, + { 15, 17 }, { 16, 15 }, { 16, 15 }, { 17, 14 }, { 16, 16 }, { 16, 16 }, { 16, 17 }, { 16, 17 }, + { 17, 16 }, { 17, 16 }, { 17, 16 }, { 18, 15 }, { 17, 17 }, { 17, 17 }, { 17, 18 }, { 16, 20 }, + { 18, 17 }, { 18, 17 }, { 18, 17 }, { 18, 18 }, { 18, 18 }, { 18, 18 }, { 18, 19 }, { 17, 21 }, + { 19, 18 }, { 19, 18 }, { 20, 16 }, { 19, 19 }, { 19, 19 }, { 19, 19 }, { 19, 20 }, { 19, 20 }, + { 19, 20 }, { 19, 21 }, { 20, 19 }, { 20, 19 }, { 21, 18 }, { 20, 20 }, { 20, 20 }, { 20, 21 }, + { 20, 21 }, { 21, 20 }, { 21, 20 }, { 21, 20 }, { 22, 19 }, { 21, 21 }, { 21, 21 }, { 21, 22 }, + { 20, 24 }, { 22, 21 }, { 22, 21 }, { 22, 21 }, { 22, 22 }, { 22, 22 }, { 22, 22 }, { 22, 23 }, + { 21, 25 }, { 23, 22 }, { 23, 22 }, { 24, 20 }, { 23, 23 }, { 23, 23 }, { 23, 23 }, { 23, 24 }, + { 23, 24 }, { 23, 24 }, { 23, 25 }, { 24, 23 }, { 24, 23 }, { 25, 22 }, { 24, 24 }, { 24, 24 }, + { 24, 25 }, { 24, 25 }, { 25, 24 }, { 25, 24 }, { 25, 24 }, { 26, 23 }, { 25, 25 }, { 25, 25 }, + { 25, 26 }, { 24, 28 }, { 26, 25 }, { 26, 25 }, { 26, 25 }, { 26, 26 }, { 26, 26 }, { 26, 26 }, + { 26, 27 }, { 25, 29 }, { 27, 26 }, { 27, 26 }, { 28, 24 }, { 27, 27 }, { 27, 27 }, { 27, 27 }, + { 27, 28 }, { 27, 28 }, { 27, 28 }, { 27, 29 }, { 28, 27 }, { 28, 27 }, { 29, 26 }, { 28, 28 }, + { 28, 28 }, { 28, 29 }, { 28, 29 }, { 29, 28 }, { 29, 28 }, { 29, 28 }, { 30, 27 }, { 29, 29 }, + { 29, 29 }, { 29, 30 }, { 29, 30 }, { 30, 29 }, { 30, 29 }, { 30, 29 }, { 30, 30 }, { 30, 30 }, + { 30, 30 }, { 30, 31 }, { 30, 31 }, { 31, 30 }, { 31, 30 }, { 31, 30 }, { 31, 31 }, { 31, 31 }, +}; +static const unsigned char stb__OMatch6[256][2] = { + { 0, 0 }, { 0, 1 }, { 1, 0 }, { 1, 1 }, { 1, 1 }, { 1, 2 }, { 2, 1 }, { 2, 2 }, + { 2, 2 }, { 2, 3 }, { 3, 2 }, { 3, 3 }, { 3, 3 }, { 3, 4 }, { 4, 3 }, { 4, 4 }, + { 4, 4 }, { 4, 5 }, { 5, 4 }, { 5, 5 }, { 5, 5 }, { 5, 6 }, { 6, 5 }, { 6, 6 }, + { 6, 6 }, { 6, 7 }, { 7, 6 }, { 7, 7 }, { 7, 7 }, { 7, 8 }, { 8, 7 }, { 8, 8 }, + { 8, 8 }, { 8, 9 }, { 9, 8 }, { 9, 9 }, { 9, 9 }, { 9, 10 }, { 10, 9 }, { 10, 10 }, + { 10, 10 }, { 10, 11 }, { 11, 10 }, { 8, 16 }, { 11, 11 }, { 11, 12 }, { 12, 11 }, { 9, 17 }, + { 12, 12 }, { 12, 13 }, { 13, 12 }, { 11, 16 }, { 13, 13 }, { 13, 14 }, { 14, 13 }, { 12, 17 }, + { 14, 14 }, { 14, 15 }, { 15, 14 }, { 14, 16 }, { 15, 15 }, { 15, 16 }, { 16, 14 }, { 16, 15 }, + { 17, 14 }, { 16, 16 }, { 16, 17 }, { 17, 16 }, { 18, 15 }, { 17, 17 }, { 17, 18 }, { 18, 17 }, + { 20, 14 }, { 18, 18 }, { 18, 19 }, { 19, 18 }, { 21, 15 }, { 19, 19 }, { 19, 20 }, { 20, 19 }, + { 20, 20 }, { 20, 20 }, { 20, 21 }, { 21, 20 }, { 21, 21 }, { 21, 21 }, { 21, 22 }, { 22, 21 }, + { 22, 22 }, { 22, 22 }, { 22, 23 }, { 23, 22 }, { 23, 23 }, { 23, 23 }, { 23, 24 }, { 24, 23 }, + { 24, 24 }, { 24, 24 }, { 24, 25 }, { 25, 24 }, { 25, 25 }, { 25, 25 }, { 25, 26 }, { 26, 25 }, + { 26, 26 }, { 26, 26 }, { 26, 27 }, { 27, 26 }, { 24, 32 }, { 27, 27 }, { 27, 28 }, { 28, 27 }, + { 25, 33 }, { 28, 28 }, { 28, 29 }, { 29, 28 }, { 27, 32 }, { 29, 29 }, { 29, 30 }, { 30, 29 }, + { 28, 33 }, { 30, 30 }, { 30, 31 }, { 31, 30 }, { 30, 32 }, { 31, 31 }, { 31, 32 }, { 32, 30 }, + { 32, 31 }, { 33, 30 }, { 32, 32 }, { 32, 33 }, { 33, 32 }, { 34, 31 }, { 33, 33 }, { 33, 34 }, + { 34, 33 }, { 36, 30 }, { 34, 34 }, { 34, 35 }, { 35, 34 }, { 37, 31 }, { 35, 35 }, { 35, 36 }, + { 36, 35 }, { 36, 36 }, { 36, 36 }, { 36, 37 }, { 37, 36 }, { 37, 37 }, { 37, 37 }, { 37, 38 }, + { 38, 37 }, { 38, 38 }, { 38, 38 }, { 38, 39 }, { 39, 38 }, { 39, 39 }, { 39, 39 }, { 39, 40 }, + { 40, 39 }, { 40, 40 }, { 40, 40 }, { 40, 41 }, { 41, 40 }, { 41, 41 }, { 41, 41 }, { 41, 42 }, + { 42, 41 }, { 42, 42 }, { 42, 42 }, { 42, 43 }, { 43, 42 }, { 40, 48 }, { 43, 43 }, { 43, 44 }, + { 44, 43 }, { 41, 49 }, { 44, 44 }, { 44, 45 }, { 45, 44 }, { 43, 48 }, { 45, 45 }, { 45, 46 }, + { 46, 45 }, { 44, 49 }, { 46, 46 }, { 46, 47 }, { 47, 46 }, { 46, 48 }, { 47, 47 }, { 47, 48 }, + { 48, 46 }, { 48, 47 }, { 49, 46 }, { 48, 48 }, { 48, 49 }, { 49, 48 }, { 50, 47 }, { 49, 49 }, + { 49, 50 }, { 50, 49 }, { 52, 46 }, { 50, 50 }, { 50, 51 }, { 51, 50 }, { 53, 47 }, { 51, 51 }, + { 51, 52 }, { 52, 51 }, { 52, 52 }, { 52, 52 }, { 52, 53 }, { 53, 52 }, { 53, 53 }, { 53, 53 }, + { 53, 54 }, { 54, 53 }, { 54, 54 }, { 54, 54 }, { 54, 55 }, { 55, 54 }, { 55, 55 }, { 55, 55 }, + { 55, 56 }, { 56, 55 }, { 56, 56 }, { 56, 56 }, { 56, 57 }, { 57, 56 }, { 57, 57 }, { 57, 57 }, + { 57, 58 }, { 58, 57 }, { 58, 58 }, { 58, 58 }, { 58, 59 }, { 59, 58 }, { 59, 59 }, { 59, 59 }, + { 59, 60 }, { 60, 59 }, { 60, 60 }, { 60, 60 }, { 60, 61 }, { 61, 60 }, { 61, 61 }, { 61, 61 }, + { 61, 62 }, { 62, 61 }, { 62, 62 }, { 62, 62 }, { 62, 63 }, { 63, 62 }, { 63, 63 }, { 63, 63 }, +}; + +static int stb__Mul8Bit(int a, int b) +{ + int t = a*b + 128; + return (t + (t >> 8)) >> 8; +} + +static void stb__From16Bit(unsigned char *out, unsigned short v) +{ + int rv = (v & 0xf800) >> 11; + int gv = (v & 0x07e0) >> 5; + int bv = (v & 0x001f) >> 0; + + // expand to 8 bits via bit replication + out[0] = (rv * 33) >> 2; + out[1] = (gv * 65) >> 4; + out[2] = (bv * 33) >> 2; + out[3] = 0; +} + +static unsigned short stb__As16Bit(int r, int g, int b) +{ + return (unsigned short)((stb__Mul8Bit(r,31) << 11) + (stb__Mul8Bit(g,63) << 5) + stb__Mul8Bit(b,31)); +} + +// linear interpolation at 1/3 point between a and b, using desired rounding type +static int stb__Lerp13(int a, int b) +{ +#ifdef STB_DXT_USE_ROUNDING_BIAS + // with rounding bias + return a + stb__Mul8Bit(b-a, 0x55); +#else + // without rounding bias + // replace "/ 3" by "* 0xaaab) >> 17" if your compiler sucks or you really need every ounce of speed. + return (2*a + b) / 3; +#endif +} + +// lerp RGB color +static void stb__Lerp13RGB(unsigned char *out, unsigned char *p1, unsigned char *p2) +{ + out[0] = (unsigned char)stb__Lerp13(p1[0], p2[0]); + out[1] = (unsigned char)stb__Lerp13(p1[1], p2[1]); + out[2] = (unsigned char)stb__Lerp13(p1[2], p2[2]); +} + +/****************************************************************************/ + +static void stb__EvalColors(unsigned char *color,unsigned short c0,unsigned short c1) +{ + stb__From16Bit(color+ 0, c0); + stb__From16Bit(color+ 4, c1); + stb__Lerp13RGB(color+ 8, color+0, color+4); + stb__Lerp13RGB(color+12, color+4, color+0); +} + +// The color matching function +static unsigned int stb__MatchColorsBlock(unsigned char *block, unsigned char *color) +{ + unsigned int mask = 0; + int dirr = color[0*4+0] - color[1*4+0]; + int dirg = color[0*4+1] - color[1*4+1]; + int dirb = color[0*4+2] - color[1*4+2]; + int dots[16]; + int stops[4]; + int i; + int c0Point, halfPoint, c3Point; + + for(i=0;i<16;i++) + dots[i] = block[i*4+0]*dirr + block[i*4+1]*dirg + block[i*4+2]*dirb; + + for(i=0;i<4;i++) + stops[i] = color[i*4+0]*dirr + color[i*4+1]*dirg + color[i*4+2]*dirb; + + // think of the colors as arranged on a line; project point onto that line, then choose + // next color out of available ones. we compute the crossover points for "best color in top + // half"/"best in bottom half" and then the same inside that subinterval. + // + // relying on this 1d approximation isn't always optimal in terms of euclidean distance, + // but it's very close and a lot faster. + // http://cbloomrants.blogspot.com/2008/12/12-08-08-dxtc-summary.html + + c0Point = (stops[1] + stops[3]); + halfPoint = (stops[3] + stops[2]); + c3Point = (stops[2] + stops[0]); + + for (i=15;i>=0;i--) { + int dot = dots[i]*2; + mask <<= 2; + + if(dot < halfPoint) + mask |= (dot < c0Point) ? 1 : 3; + else + mask |= (dot < c3Point) ? 2 : 0; + } + + return mask; +} + +// The color optimization function. (Clever code, part 1) +static void stb__OptimizeColorsBlock(unsigned char *block, unsigned short *pmax16, unsigned short *pmin16) +{ + int mind,maxd; + unsigned char *minp, *maxp; + double magn; + int v_r,v_g,v_b; + static const int nIterPower = 4; + float covf[6],vfr,vfg,vfb; + + // determine color distribution + int cov[6]; + int mu[3],min[3],max[3]; + int ch,i,iter; + + for(ch=0;ch<3;ch++) + { + const unsigned char *bp = ((const unsigned char *) block) + ch; + int muv,minv,maxv; + + muv = minv = maxv = bp[0]; + for(i=4;i<64;i+=4) + { + muv += bp[i]; + if (bp[i] < minv) minv = bp[i]; + else if (bp[i] > maxv) maxv = bp[i]; + } + + mu[ch] = (muv + 8) >> 4; + min[ch] = minv; + max[ch] = maxv; + } + + // determine covariance matrix + for (i=0;i<6;i++) + cov[i] = 0; + + for (i=0;i<16;i++) + { + int r = block[i*4+0] - mu[0]; + int g = block[i*4+1] - mu[1]; + int b = block[i*4+2] - mu[2]; + + cov[0] += r*r; + cov[1] += r*g; + cov[2] += r*b; + cov[3] += g*g; + cov[4] += g*b; + cov[5] += b*b; + } + + // convert covariance matrix to float, find principal axis via power iter + for(i=0;i<6;i++) + covf[i] = cov[i] / 255.0f; + + vfr = (float) (max[0] - min[0]); + vfg = (float) (max[1] - min[1]); + vfb = (float) (max[2] - min[2]); + + for(iter=0;iter magn) magn = STBD_FABS(vfg); + if (STBD_FABS(vfb) > magn) magn = STBD_FABS(vfb); + + if(magn < 4.0f) { // too small, default to luminance + v_r = 299; // JPEG YCbCr luma coefs, scaled by 1000. + v_g = 587; + v_b = 114; + } else { + magn = 512.0 / magn; + v_r = (int) (vfr * magn); + v_g = (int) (vfg * magn); + v_b = (int) (vfb * magn); + } + + minp = maxp = block; + mind = maxd = block[0]*v_r + block[1]*v_g + block[2]*v_b; + // Pick colors at extreme points + for(i=1;i<16;i++) + { + int dot = block[i*4+0]*v_r + block[i*4+1]*v_g + block[i*4+2]*v_b; + + if (dot < mind) { + mind = dot; + minp = block+i*4; + } + + if (dot > maxd) { + maxd = dot; + maxp = block+i*4; + } + } + + *pmax16 = stb__As16Bit(maxp[0],maxp[1],maxp[2]); + *pmin16 = stb__As16Bit(minp[0],minp[1],minp[2]); +} + +static const float stb__midpoints5[32] = { + 0.015686f, 0.047059f, 0.078431f, 0.111765f, 0.145098f, 0.176471f, 0.207843f, 0.241176f, 0.274510f, 0.305882f, 0.337255f, 0.370588f, 0.403922f, 0.435294f, 0.466667f, 0.5f, + 0.533333f, 0.564706f, 0.596078f, 0.629412f, 0.662745f, 0.694118f, 0.725490f, 0.758824f, 0.792157f, 0.823529f, 0.854902f, 0.888235f, 0.921569f, 0.952941f, 0.984314f, 1.0f +}; + +static const float stb__midpoints6[64] = { + 0.007843f, 0.023529f, 0.039216f, 0.054902f, 0.070588f, 0.086275f, 0.101961f, 0.117647f, 0.133333f, 0.149020f, 0.164706f, 0.180392f, 0.196078f, 0.211765f, 0.227451f, 0.245098f, + 0.262745f, 0.278431f, 0.294118f, 0.309804f, 0.325490f, 0.341176f, 0.356863f, 0.372549f, 0.388235f, 0.403922f, 0.419608f, 0.435294f, 0.450980f, 0.466667f, 0.482353f, 0.500000f, + 0.517647f, 0.533333f, 0.549020f, 0.564706f, 0.580392f, 0.596078f, 0.611765f, 0.627451f, 0.643137f, 0.658824f, 0.674510f, 0.690196f, 0.705882f, 0.721569f, 0.737255f, 0.754902f, + 0.772549f, 0.788235f, 0.803922f, 0.819608f, 0.835294f, 0.850980f, 0.866667f, 0.882353f, 0.898039f, 0.913725f, 0.929412f, 0.945098f, 0.960784f, 0.976471f, 0.992157f, 1.0f +}; + +static unsigned short stb__Quantize5(float x) +{ + unsigned short q; + x = x < 0 ? 0 : x > 1 ? 1 : x; // saturate + q = (unsigned short)(x * 31); + q += (x > stb__midpoints5[q]); + return q; +} + +static unsigned short stb__Quantize6(float x) +{ + unsigned short q; + x = x < 0 ? 0 : x > 1 ? 1 : x; // saturate + q = (unsigned short)(x * 63); + q += (x > stb__midpoints6[q]); + return q; +} + +// The refinement function. (Clever code, part 2) +// Tries to optimize colors to suit block contents better. +// (By solving a least squares system via normal equations+Cramer's rule) +static int stb__RefineBlock(unsigned char *block, unsigned short *pmax16, unsigned short *pmin16, unsigned int mask) +{ + static const int w1Tab[4] = { 3,0,2,1 }; + static const int prods[4] = { 0x090000,0x000900,0x040102,0x010402 }; + // ^some magic to save a lot of multiplies in the accumulating loop... + // (precomputed products of weights for least squares system, accumulated inside one 32-bit register) + + float f; + unsigned short oldMin, oldMax, min16, max16; + int i, akku = 0, xx,xy,yy; + int At1_r,At1_g,At1_b; + int At2_r,At2_g,At2_b; + unsigned int cm = mask; + + oldMin = *pmin16; + oldMax = *pmax16; + + if((mask ^ (mask<<2)) < 4) // all pixels have the same index? + { + // yes, linear system would be singular; solve using optimal + // single-color match on average color + int r = 8, g = 8, b = 8; + for (i=0;i<16;++i) { + r += block[i*4+0]; + g += block[i*4+1]; + b += block[i*4+2]; + } + + r >>= 4; g >>= 4; b >>= 4; + + max16 = (stb__OMatch5[r][0]<<11) | (stb__OMatch6[g][0]<<5) | stb__OMatch5[b][0]; + min16 = (stb__OMatch5[r][1]<<11) | (stb__OMatch6[g][1]<<5) | stb__OMatch5[b][1]; + } else { + At1_r = At1_g = At1_b = 0; + At2_r = At2_g = At2_b = 0; + for (i=0;i<16;++i,cm>>=2) { + int step = cm&3; + int w1 = w1Tab[step]; + int r = block[i*4+0]; + int g = block[i*4+1]; + int b = block[i*4+2]; + + akku += prods[step]; + At1_r += w1*r; + At1_g += w1*g; + At1_b += w1*b; + At2_r += r; + At2_g += g; + At2_b += b; + } + + At2_r = 3*At2_r - At1_r; + At2_g = 3*At2_g - At1_g; + At2_b = 3*At2_b - At1_b; + + // extract solutions and decide solvability + xx = akku >> 16; + yy = (akku >> 8) & 0xff; + xy = (akku >> 0) & 0xff; + + f = 3.0f / 255.0f / (xx*yy - xy*xy); + + max16 = stb__Quantize5((At1_r*yy - At2_r * xy) * f) << 11; + max16 |= stb__Quantize6((At1_g*yy - At2_g * xy) * f) << 5; + max16 |= stb__Quantize5((At1_b*yy - At2_b * xy) * f) << 0; + + min16 = stb__Quantize5((At2_r*xx - At1_r * xy) * f) << 11; + min16 |= stb__Quantize6((At2_g*xx - At1_g * xy) * f) << 5; + min16 |= stb__Quantize5((At2_b*xx - At1_b * xy) * f) << 0; + } + + *pmin16 = min16; + *pmax16 = max16; + return oldMin != min16 || oldMax != max16; +} + +// Color block compression +static void stb__CompressColorBlock(unsigned char *dest, unsigned char *block, int mode) +{ + unsigned int mask; + int i; + int refinecount; + unsigned short max16, min16; + unsigned char color[4*4]; + + refinecount = (mode & STB_DXT_HIGHQUAL) ? 2 : 1; + + // check if block is constant + for (i=1;i<16;i++) + if (((unsigned int *) block)[i] != ((unsigned int *) block)[0]) + break; + + if(i == 16) { // constant color + int r = block[0], g = block[1], b = block[2]; + mask = 0xaaaaaaaa; + max16 = (stb__OMatch5[r][0]<<11) | (stb__OMatch6[g][0]<<5) | stb__OMatch5[b][0]; + min16 = (stb__OMatch5[r][1]<<11) | (stb__OMatch6[g][1]<<5) | stb__OMatch5[b][1]; + } else { + // first step: PCA+map along principal axis + stb__OptimizeColorsBlock(block,&max16,&min16); + if (max16 != min16) { + stb__EvalColors(color,max16,min16); + mask = stb__MatchColorsBlock(block,color); + } else + mask = 0; + + // third step: refine (multiple times if requested) + for (i=0;i> 8); + dest[2] = (unsigned char) (min16); + dest[3] = (unsigned char) (min16 >> 8); + dest[4] = (unsigned char) (mask); + dest[5] = (unsigned char) (mask >> 8); + dest[6] = (unsigned char) (mask >> 16); + dest[7] = (unsigned char) (mask >> 24); +} + +// Alpha block compression (this is easy for a change) +static void stb__CompressAlphaBlock(unsigned char *dest,unsigned char *src, int stride) +{ + int i,dist,bias,dist4,dist2,bits,mask; + + // find min/max color + int mn,mx; + mn = mx = src[0]; + + for (i=1;i<16;i++) + { + if (src[i*stride] < mn) mn = src[i*stride]; + else if (src[i*stride] > mx) mx = src[i*stride]; + } + + // encode them + dest[0] = (unsigned char)mx; + dest[1] = (unsigned char)mn; + dest += 2; + + // determine bias and emit color indices + // given the choice of mx/mn, these indices are optimal: + // http://fgiesen.wordpress.com/2009/12/15/dxt5-alpha-block-index-determination/ + dist = mx-mn; + dist4 = dist*4; + dist2 = dist*2; + bias = (dist < 8) ? (dist - 1) : (dist/2 + 2); + bias -= mn * 7; + bits = 0,mask=0; + + for (i=0;i<16;i++) { + int a = src[i*stride]*7 + bias; + int ind,t; + + // select index. this is a "linear scale" lerp factor between 0 (val=min) and 7 (val=max). + t = (a >= dist4) ? -1 : 0; ind = t & 4; a -= dist4 & t; + t = (a >= dist2) ? -1 : 0; ind += t & 2; a -= dist2 & t; + ind += (a >= dist); + + // turn linear scale into DXT index (0/1 are extremal pts) + ind = -ind & 7; + ind ^= (2 > ind); + + // write index + mask |= ind << bits; + if((bits += 3) >= 8) { + *dest++ = (unsigned char)mask; + mask >>= 8; + bits -= 8; + } + } +} + +void stb_compress_dxt_block(unsigned char *dest, const unsigned char *src, int alpha, int mode) +{ + unsigned char data[16][4]; + if (alpha) { + int i; + stb__CompressAlphaBlock(dest,(unsigned char*) src+3, 4); + dest += 8; + // make a new copy of the data in which alpha is opaque, + // because code uses a fast test for color constancy + memcpy(data, src, 4*16); + for (i=0; i < 16; ++i) + data[i][3] = 255; + src = &data[0][0]; + } + + stb__CompressColorBlock(dest,(unsigned char*) src,mode); +} + +void stb_compress_bc4_block(unsigned char *dest, const unsigned char *src) +{ + stb__CompressAlphaBlock(dest,(unsigned char*) src, 1); +} + +void stb_compress_bc5_block(unsigned char *dest, const unsigned char *src) +{ + stb__CompressAlphaBlock(dest,(unsigned char*) src,2); + stb__CompressAlphaBlock(dest + 8,(unsigned char*) src+1,2); +} +#endif // STB_DXT_IMPLEMENTATION + +// Compile with STB_DXT_IMPLEMENTATION and STB_DXT_GENERATE_TABLES +// defined to generate the tables above. +#ifdef STB_DXT_GENERATE_TABLES +#include + +int main() +{ + int i, j; + const char *omatch_names[] = { "stb__OMatch5", "stb__OMatch6" }; + int dequant_mults[2] = { 33*4, 65 }; // .4 fixed-point dequant multipliers + + // optimal endpoint tables + for (i = 0; i < 2; ++i) { + int dequant = dequant_mults[i]; + int size = i ? 64 : 32; + printf("static const unsigned char %s[256][2] = {\n", omatch_names[i]); + for (int j = 0; j < 256; ++j) { + int mn, mx; + int best_mn = 0, best_mx = 0; + int best_err = 256 * 100; + for (mn=0;mn> 4; + int maxe = (mx * dequant) >> 4; + int err = abs(stb__Lerp13(maxe, mine) - j) * 100; + + // DX10 spec says that interpolation must be within 3% of "correct" result, + // add this as error term. Normally we'd expect a random distribution of + // +-1.5% error, but nowhere in the spec does it say that the error has to be + // unbiased - better safe than sorry. + err += abs(maxe - mine) * 3; + + if(err < best_err) { + best_mn = mn; + best_mx = mx; + best_err = err; + } + } + } + if ((j % 8) == 0) printf(" "); // 2 spaces, third is done below + printf(" { %2d, %2d },", best_mx, best_mn); + if ((j % 8) == 7) printf("\n"); + } + printf("};\n"); + } + + return 0; +} +#endif + +/* +------------------------------------------------------------------------------ +This software is available under 2 licenses -- choose whichever you prefer. +------------------------------------------------------------------------------ +ALTERNATIVE A - MIT License +Copyright (c) 2017 Sean Barrett +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is furnished to do +so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +------------------------------------------------------------------------------ +ALTERNATIVE B - Public Domain (www.unlicense.org) +This is free and unencumbered software released into the public domain. +Anyone is free to copy, modify, publish, use, compile, sell, or distribute this +software, either in source code form or as a compiled binary, for any purpose, +commercial or non-commercial, and by any means. +In jurisdictions that recognize copyright laws, the author or authors of this +software dedicate any and all copyright interest in the software to the public +domain. We make this dedication for the benefit of the public at large and to +the detriment of our heirs and successors. We intend this dedication to be an +overt act of relinquishment in perpetuity of all present and future rights to +this software under copyright law. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN +ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +------------------------------------------------------------------------------ +*/ diff --git a/tests/data/c/stb/stb_easy_font.h b/tests/data/c/stb/stb_easy_font.h new file mode 100644 index 000000000..b66325847 --- /dev/null +++ b/tests/data/c/stb/stb_easy_font.h @@ -0,0 +1,305 @@ +// stb_easy_font.h - v1.1 - bitmap font for 3D rendering - public domain +// Sean Barrett, Feb 2015 +// +// Easy-to-deploy, +// reasonably compact, +// extremely inefficient performance-wise, +// crappy-looking, +// ASCII-only, +// bitmap font for use in 3D APIs. +// +// Intended for when you just want to get some text displaying +// in a 3D app as quickly as possible. +// +// Doesn't use any textures, instead builds characters out of quads. +// +// DOCUMENTATION: +// +// int stb_easy_font_width(char *text) +// int stb_easy_font_height(char *text) +// +// Takes a string and returns the horizontal size and the +// vertical size (which can vary if 'text' has newlines). +// +// int stb_easy_font_print(float x, float y, +// char *text, unsigned char color[4], +// void *vertex_buffer, int vbuf_size) +// +// Takes a string (which can contain '\n') and fills out a +// vertex buffer with renderable data to draw the string. +// Output data assumes increasing x is rightwards, increasing y +// is downwards. +// +// The vertex data is divided into quads, i.e. there are four +// vertices in the vertex buffer for each quad. +// +// The vertices are stored in an interleaved format: +// +// x:float +// y:float +// z:float +// color:uint8[4] +// +// You can ignore z and color if you get them from elsewhere +// This format was chosen in the hopes it would make it +// easier for you to reuse existing vertex-buffer-drawing code. +// +// If you pass in NULL for color, it becomes 255,255,255,255. +// +// Returns the number of quads. +// +// If the buffer isn't large enough, it will truncate. +// Expect it to use an average of ~270 bytes per character. +// +// If your API doesn't draw quads, build a reusable index +// list that allows you to render quads as indexed triangles. +// +// void stb_easy_font_spacing(float spacing) +// +// Use positive values to expand the space between characters, +// and small negative values (no smaller than -1.5) to contract +// the space between characters. +// +// E.g. spacing = 1 adds one "pixel" of spacing between the +// characters. spacing = -1 is reasonable but feels a bit too +// compact to me; -0.5 is a reasonable compromise as long as +// you're scaling the font up. +// +// LICENSE +// +// See end of file for license information. +// +// VERSION HISTORY +// +// (2020-02-02) 1.1 make everything static so can compile it in more than one src file +// (2017-01-15) 1.0 space character takes same space as numbers; fix bad spacing of 'f' +// (2016-01-22) 0.7 width() supports multiline text; add height() +// (2015-09-13) 0.6 #include ; updated license +// (2015-02-01) 0.5 First release +// +// CONTRIBUTORS +// +// github:vassvik -- bug report +// github:podsvirov -- fix multiple definition errors + +#if 0 +// SAMPLE CODE: +// +// Here's sample code for old OpenGL; it's a lot more complicated +// to make work on modern APIs, and that's your problem. +// +void print_string(float x, float y, char *text, float r, float g, float b) +{ + static char buffer[99999]; // ~500 chars + int num_quads; + + num_quads = stb_easy_font_print(x, y, text, NULL, buffer, sizeof(buffer)); + + glColor3f(r,g,b); + glEnableClientState(GL_VERTEX_ARRAY); + glVertexPointer(2, GL_FLOAT, 16, buffer); + glDrawArrays(GL_QUADS, 0, num_quads*4); + glDisableClientState(GL_VERTEX_ARRAY); +} +#endif + +#ifndef INCLUDE_STB_EASY_FONT_H +#define INCLUDE_STB_EASY_FONT_H + +#include +#include + +static struct stb_easy_font_info_struct { + unsigned char advance; + unsigned char h_seg; + unsigned char v_seg; +} stb_easy_font_charinfo[96] = { + { 6, 0, 0 }, { 3, 0, 0 }, { 5, 1, 1 }, { 7, 1, 4 }, + { 7, 3, 7 }, { 7, 6, 12 }, { 7, 8, 19 }, { 4, 16, 21 }, + { 4, 17, 22 }, { 4, 19, 23 }, { 23, 21, 24 }, { 23, 22, 31 }, + { 20, 23, 34 }, { 22, 23, 36 }, { 19, 24, 36 }, { 21, 25, 36 }, + { 6, 25, 39 }, { 6, 27, 43 }, { 6, 28, 45 }, { 6, 30, 49 }, + { 6, 33, 53 }, { 6, 34, 57 }, { 6, 40, 58 }, { 6, 46, 59 }, + { 6, 47, 62 }, { 6, 55, 64 }, { 19, 57, 68 }, { 20, 59, 68 }, + { 21, 61, 69 }, { 22, 66, 69 }, { 21, 68, 69 }, { 7, 73, 69 }, + { 9, 75, 74 }, { 6, 78, 81 }, { 6, 80, 85 }, { 6, 83, 90 }, + { 6, 85, 91 }, { 6, 87, 95 }, { 6, 90, 96 }, { 7, 92, 97 }, + { 6, 96,102 }, { 5, 97,106 }, { 6, 99,107 }, { 6,100,110 }, + { 6,100,115 }, { 7,101,116 }, { 6,101,121 }, { 6,101,125 }, + { 6,102,129 }, { 7,103,133 }, { 6,104,140 }, { 6,105,145 }, + { 7,107,149 }, { 6,108,151 }, { 7,109,155 }, { 7,109,160 }, + { 7,109,165 }, { 7,118,167 }, { 6,118,172 }, { 4,120,176 }, + { 6,122,177 }, { 4,122,181 }, { 23,124,182 }, { 22,129,182 }, + { 4,130,182 }, { 22,131,183 }, { 6,133,187 }, { 22,135,191 }, + { 6,137,192 }, { 22,139,196 }, { 6,144,197 }, { 22,147,198 }, + { 6,150,202 }, { 19,151,206 }, { 21,152,207 }, { 6,155,209 }, + { 3,160,210 }, { 23,160,211 }, { 22,164,216 }, { 22,165,220 }, + { 22,167,224 }, { 22,169,228 }, { 21,171,232 }, { 21,173,233 }, + { 5,178,233 }, { 22,179,234 }, { 23,180,238 }, { 23,180,243 }, + { 23,180,248 }, { 22,189,248 }, { 22,191,252 }, { 5,196,252 }, + { 3,203,252 }, { 5,203,253 }, { 22,210,253 }, { 0,214,253 }, +}; + +static unsigned char stb_easy_font_hseg[214] = { + 97,37,69,84,28,51,2,18,10,49,98,41,65,25,81,105,33,9,97,1,97,37,37,36, + 81,10,98,107,3,100,3,99,58,51,4,99,58,8,73,81,10,50,98,8,73,81,4,10,50, + 98,8,25,33,65,81,10,50,17,65,97,25,33,25,49,9,65,20,68,1,65,25,49,41, + 11,105,13,101,76,10,50,10,50,98,11,99,10,98,11,50,99,11,50,11,99,8,57, + 58,3,99,99,107,10,10,11,10,99,11,5,100,41,65,57,41,65,9,17,81,97,3,107, + 9,97,1,97,33,25,9,25,41,100,41,26,82,42,98,27,83,42,98,26,51,82,8,41, + 35,8,10,26,82,114,42,1,114,8,9,73,57,81,41,97,18,8,8,25,26,26,82,26,82, + 26,82,41,25,33,82,26,49,73,35,90,17,81,41,65,57,41,65,25,81,90,114,20, + 84,73,57,41,49,25,33,65,81,9,97,1,97,25,33,65,81,57,33,25,41,25, +}; + +static unsigned char stb_easy_font_vseg[253] = { + 4,2,8,10,15,8,15,33,8,15,8,73,82,73,57,41,82,10,82,18,66,10,21,29,1,65, + 27,8,27,9,65,8,10,50,97,74,66,42,10,21,57,41,29,25,14,81,73,57,26,8,8, + 26,66,3,8,8,15,19,21,90,58,26,18,66,18,105,89,28,74,17,8,73,57,26,21, + 8,42,41,42,8,28,22,8,8,30,7,8,8,26,66,21,7,8,8,29,7,7,21,8,8,8,59,7,8, + 8,15,29,8,8,14,7,57,43,10,82,7,7,25,42,25,15,7,25,41,15,21,105,105,29, + 7,57,57,26,21,105,73,97,89,28,97,7,57,58,26,82,18,57,57,74,8,30,6,8,8, + 14,3,58,90,58,11,7,74,43,74,15,2,82,2,42,75,42,10,67,57,41,10,7,2,42, + 74,106,15,2,35,8,8,29,7,8,8,59,35,51,8,8,15,35,30,35,8,8,30,7,8,8,60, + 36,8,45,7,7,36,8,43,8,44,21,8,8,44,35,8,8,43,23,8,8,43,35,8,8,31,21,15, + 20,8,8,28,18,58,89,58,26,21,89,73,89,29,20,8,8,30,7, +}; + +typedef struct +{ + unsigned char c[4]; +} stb_easy_font_color; + +static int stb_easy_font_draw_segs(float x, float y, unsigned char *segs, int num_segs, int vertical, stb_easy_font_color c, char *vbuf, int vbuf_size, int offset) +{ + int i,j; + for (i=0; i < num_segs; ++i) { + int len = segs[i] & 7; + x += (float) ((segs[i] >> 3) & 1); + if (len && offset+64 <= vbuf_size) { + float y0 = y + (float) (segs[i]>>4); + for (j=0; j < 4; ++j) { + * (float *) (vbuf+offset+0) = x + (j==1 || j==2 ? (vertical ? 1 : len) : 0); + * (float *) (vbuf+offset+4) = y0 + ( j >= 2 ? (vertical ? len : 1) : 0); + * (float *) (vbuf+offset+8) = 0.f; + * (stb_easy_font_color *) (vbuf+offset+12) = c; + offset += 16; + } + } + } + return offset; +} + +static float stb_easy_font_spacing_val = 0; +static void stb_easy_font_spacing(float spacing) +{ + stb_easy_font_spacing_val = spacing; +} + +static int stb_easy_font_print(float x, float y, char *text, unsigned char color[4], void *vertex_buffer, int vbuf_size) +{ + char *vbuf = (char *) vertex_buffer; + float start_x = x; + int offset = 0; + + stb_easy_font_color c = { 255,255,255,255 }; // use structure copying to avoid needing depending on memcpy() + if (color) { c.c[0] = color[0]; c.c[1] = color[1]; c.c[2] = color[2]; c.c[3] = color[3]; } + + while (*text && offset < vbuf_size) { + if (*text == '\n') { + y += 12; + x = start_x; + } else { + unsigned char advance = stb_easy_font_charinfo[*text-32].advance; + float y_ch = advance & 16 ? y+1 : y; + int h_seg, v_seg, num_h, num_v; + h_seg = stb_easy_font_charinfo[*text-32 ].h_seg; + v_seg = stb_easy_font_charinfo[*text-32 ].v_seg; + num_h = stb_easy_font_charinfo[*text-32+1].h_seg - h_seg; + num_v = stb_easy_font_charinfo[*text-32+1].v_seg - v_seg; + offset = stb_easy_font_draw_segs(x, y_ch, &stb_easy_font_hseg[h_seg], num_h, 0, c, vbuf, vbuf_size, offset); + offset = stb_easy_font_draw_segs(x, y_ch, &stb_easy_font_vseg[v_seg], num_v, 1, c, vbuf, vbuf_size, offset); + x += advance & 15; + x += stb_easy_font_spacing_val; + } + ++text; + } + return (unsigned) offset/64; +} + +static int stb_easy_font_width(char *text) +{ + float len = 0; + float max_len = 0; + while (*text) { + if (*text == '\n') { + if (len > max_len) max_len = len; + len = 0; + } else { + len += stb_easy_font_charinfo[*text-32].advance & 15; + len += stb_easy_font_spacing_val; + } + ++text; + } + if (len > max_len) max_len = len; + return (int) ceil(max_len); +} + +static int stb_easy_font_height(char *text) +{ + float y = 0; + int nonempty_line=0; + while (*text) { + if (*text == '\n') { + y += 12; + nonempty_line = 0; + } else { + nonempty_line = 1; + } + ++text; + } + return (int) ceil(y + (nonempty_line ? 12 : 0)); +} +#endif + +/* +------------------------------------------------------------------------------ +This software is available under 2 licenses -- choose whichever you prefer. +------------------------------------------------------------------------------ +ALTERNATIVE A - MIT License +Copyright (c) 2017 Sean Barrett +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is furnished to do +so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +------------------------------------------------------------------------------ +ALTERNATIVE B - Public Domain (www.unlicense.org) +This is free and unencumbered software released into the public domain. +Anyone is free to copy, modify, publish, use, compile, sell, or distribute this +software, either in source code form or as a compiled binary, for any purpose, +commercial or non-commercial, and by any means. +In jurisdictions that recognize copyright laws, the author or authors of this +software dedicate any and all copyright interest in the software to the public +domain. We make this dedication for the benefit of the public at large and to +the detriment of our heirs and successors. We intend this dedication to be an +overt act of relinquishment in perpetuity of all present and future rights to +this software under copyright law. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN +ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +------------------------------------------------------------------------------ +*/ diff --git a/tests/data/c/stb/stb_herringbone_wang_tile.h b/tests/data/c/stb/stb_herringbone_wang_tile.h new file mode 100644 index 000000000..5517941f7 --- /dev/null +++ b/tests/data/c/stb/stb_herringbone_wang_tile.h @@ -0,0 +1,1221 @@ +/* stbhw - v0.7 - http://nothings.org/gamedev/herringbone + Herringbone Wang Tile Generator - Sean Barrett 2014 - public domain + +== LICENSE ============================== + +This software is dual-licensed to the public domain and under the following +license: you are granted a perpetual, irrevocable license to copy, modify, +publish, and distribute this file as you see fit. + +== WHAT IT IS =========================== + + This library is an SDK for Herringbone Wang Tile generation: + + http://nothings.org/gamedev/herringbone + + The core design is that you use this library offline to generate a + "template" of the tiles you'll create. You then edit those tiles, then + load the created tile image file back into this library and use it at + runtime to generate "maps". + + You cannot load arbitrary tile image files with this library; it is + only designed to load image files made from the template it created. + It stores a binary description of the tile sizes & constraints in a + few pixels, and uses those to recover the rules, rather than trying + to parse the tiles themselves. + + You *can* use this library to generate from arbitrary tile sets, but + only by loading the tile set and specifying the constraints explicitly + yourself. + +== COMPILING ============================ + + 1. #define STB_HERRINGBONE_WANG_TILE_IMPLEMENTATION before including this + header file in *one* source file to create the implementation + in that source file. + + 2. optionally #define STB_HBWANG_RAND() to be a random number + generator. if you don't define it, it will use rand(), + and you need to seed srand() yourself. + + 3. optionally #define STB_HBWANG_ASSERT(x), otherwise + it will use assert() + + 4. optionally #define STB_HBWANG_STATIC to force all symbols to be + static instead of public, so they are only accesible + in the source file that creates the implementation + + 5. optionally #define STB_HBWANG_NO_REPITITION_REDUCTION to disable + the code that tries to reduce having the same tile appear + adjacent to itself in wang-corner-tile mode (e.g. imagine + if you were doing something where 90% of things should be + the same grass tile, you need to disable this system) + + 6. optionally define STB_HBWANG_MAX_X and STB_HBWANG_MAX_Y + to be the max dimensions of the generated map in multiples + of the wang tile's short side's length (e.g. if you + have 20x10 wang tiles, so short_side_len=10, and you + have MAX_X is 17, then the largest map you can generate + is 170 pixels wide). The defaults are 100x100. This + is used to define static arrays which affect memory + usage. + +== USING ================================ + + To use the map generator, you need a tileset. You can download + some sample tilesets from http://nothings.org/gamedev/herringbone + + Then see the "sample application" below. + + You can also use this file to generate templates for + tilesets which you then hand-edit to create the data. + + +== MEMORY MANAGEMENT ==================== + + The tileset loader allocates memory with malloc(). The map + generator does no memory allocation, so e.g. you can load + tilesets at startup and never free them and never do any + further allocation. + + +== SAMPLE APPLICATION =================== + +#include +#include +#include + +#define STB_IMAGE_IMPLEMENTATION +#include "stb_image.h" // http://nothings.org/stb_image.c + +#define STB_IMAGE_WRITE_IMPLEMENTATION +#include "stb_image_write.h" // http://nothings.org/stb/stb_image_write.h + +#define STB_HBWANG_IMPLEMENTATION +#include "stb_hbwang.h" + +int main(int argc, char **argv) +{ + unsigned char *data; + int xs,ys, w,h; + stbhw_tileset ts; + + if (argc != 4) { + fprintf(stderr, "Usage: mapgen {tile-file} {xsize} {ysize}\n" + "generates file named 'test_map.png'\n"); + exit(1); + } + data = stbi_load(argv[1], &w, &h, NULL, 3); + xs = atoi(argv[2]); + ys = atoi(argv[3]); + if (data == NULL) { + fprintf(stderr, "Error opening or parsing '%s' as an image file\n", argv[1]); + exit(1); + } + if (xs < 1 || xs > 1000) { + fprintf(stderr, "xsize invalid or out of range\n"); + exit(1); + } + if (ys < 1 || ys > 1000) { + fprintf(stderr, "ysize invalid or out of range\n"); + exit(1); + } + + stbhw_build_tileset_from_image(&ts, data, w*3, w, h); + free(data); + + // allocate a buffer to create the final image to + data = malloc(3 * xs * ys); + + srand(time(NULL)); + stbhw_generate_image(&ts, NULL, data, xs*3, xs, ys); + + stbi_write_png("test_map.png", xs, ys, 3, data, xs*3); + + stbhw_free_tileset(&ts); + free(data); + + return 0; +} + +== VERSION HISTORY =================== + + 0.7 2019-03-04 - fix warnings + 0.6 2014-08-17 - fix broken map-maker + 0.5 2014-07-07 - initial release + +*/ + +////////////////////////////////////////////////////////////////////////////// +// // +// HEADER FILE SECTION // +// // + +#ifndef INCLUDE_STB_HWANG_H +#define INCLUDE_STB_HWANG_H + +#ifdef STB_HBWANG_STATIC +#define STBHW_EXTERN static +#else +#ifdef __cplusplus +#define STBHW_EXTERN extern "C" +#else +#define STBHW_EXTERN extern +#endif +#endif + +typedef struct stbhw_tileset stbhw_tileset; + +// returns description of last error produced by any function (not thread-safe) +STBHW_EXTERN const char *stbhw_get_last_error(void); + +// build a tileset from an image that conforms to a template created by this +// library. (you allocate storage for stbhw_tileset and function fills it out; +// memory for individual tiles are malloc()ed). +// returns non-zero on success, 0 on error +STBHW_EXTERN int stbhw_build_tileset_from_image(stbhw_tileset *ts, + unsigned char *pixels, int stride_in_bytes, int w, int h); + +// free a tileset built by stbhw_build_tileset_from_image +STBHW_EXTERN void stbhw_free_tileset(stbhw_tileset *ts); + +// generate a map that is w * h pixels (3-bytes each) +// returns non-zero on success, 0 on error +// not thread-safe (uses a global data structure to avoid memory management) +// weighting should be NULL, as non-NULL weighting is currently untested +STBHW_EXTERN int stbhw_generate_image(stbhw_tileset *ts, int **weighting, + unsigned char *pixels, int stride_in_bytes, int w, int h); + +////////////////////////////////////// +// +// TILESET DATA STRUCTURE +// +// if you use the image-to-tileset system from this file, you +// don't need to worry about these data structures. but if you +// want to build/load a tileset yourself, you'll need to fill +// these out. + +typedef struct +{ + // the edge or vertex constraints, according to diagram below + signed char a,b,c,d,e,f; + + // The herringbone wang tile data; it is a bitmap which is either + // w=2*short_sidelen,h=short_sidelen, or w=short_sidelen,h=2*short_sidelen. + // it is always RGB, stored row-major, with no padding between rows. + // (allocate stbhw_tile structure to be large enough for the pixel data) + unsigned char pixels[1]; +} stbhw_tile; + +struct stbhw_tileset +{ + int is_corner; + int num_color[6]; // number of colors for each of 6 edge types or 4 corner types + int short_side_len; + stbhw_tile **h_tiles; + stbhw_tile **v_tiles; + int num_h_tiles, max_h_tiles; + int num_v_tiles, max_v_tiles; +}; + +/////////////// TEMPLATE GENERATOR ////////////////////////// + +// when requesting a template, you fill out this data +typedef struct +{ + int is_corner; // using corner colors or edge colors? + int short_side_len; // rectangles is 2n x n, n = short_side_len + int num_color[6]; // see below diagram for meaning of the index to this; + // 6 values if edge (!is_corner), 4 values if is_corner + // legal numbers: 1..8 if edge, 1..4 if is_corner + int num_vary_x; // additional number of variations along x axis in the template + int num_vary_y; // additional number of variations along y axis in the template + int corner_type_color_template[4][4]; + // if corner_type_color_template[s][t] is non-zero, then any + // corner of type s generated as color t will get a little + // corner sample markup in the template image data + +} stbhw_config; + +// computes the size needed for the template image +STBHW_EXTERN void stbhw_get_template_size(stbhw_config *c, int *w, int *h); + +// generates a template image, assuming data is 3*w*h bytes long, RGB format +STBHW_EXTERN int stbhw_make_template(stbhw_config *c, unsigned char *data, int w, int h, int stride_in_bytes); + +#endif//INCLUDE_STB_HWANG_H + + +// TILE CONSTRAINT TYPES +// +// there are 4 "types" of corners and 6 types of edges. +// you can configure the tileset to have different numbers +// of colors for each type of color or edge. +// +// corner types: +// +// 0---*---1---*---2---*---3 +// | | | +// * * * +// | | | +// 1---*---2---*---3 0---*---1---*---2 +// | | | +// * * * +// | | | +// 0---*---1---*---2---*---3 +// +// +// edge types: +// +// *---2---*---3---* *---0---* +// | | | | +// 1 4 5 1 +// | | | | +// *---0---*---2---* * * +// | | +// 4 5 +// | | +// *---3---* +// +// TILE CONSTRAINTS +// +// each corner/edge has a color; this shows the name +// of the variable containing the color +// +// corner constraints: +// +// a---*---d +// | | +// * * +// | | +// a---*---b---*---c b e +// | | | | +// * * * * +// | | | | +// d---*---e---*---f c---*---f +// +// +// edge constraints: +// +// *---a---*---b---* *---a---* +// | | | | +// c d b c +// | | | | +// *---e---*---f---* * * +// | | +// d e +// | | +// *---f---* +// + + +////////////////////////////////////////////////////////////////////////////// +// // +// IMPLEMENTATION SECTION // +// // + +#ifdef STB_HERRINGBONE_WANG_TILE_IMPLEMENTATION + + +#include // memcpy +#include // malloc + +#ifndef STB_HBWANG_RAND +#include +#define STB_HBWANG_RAND() (rand() >> 4) +#endif + +#ifndef STB_HBWANG_ASSERT +#include +#define STB_HBWANG_ASSERT(x) assert(x) +#endif + +// map size +#ifndef STB_HBWANG_MAX_X +#define STB_HBWANG_MAX_X 100 +#endif + +#ifndef STB_HBWANG_MAX_Y +#define STB_HBWANG_MAX_Y 100 +#endif + +// global variables for color assignments +// @MEMORY change these to just store last two/three rows +// and keep them on the stack +static signed char c_color[STB_HBWANG_MAX_Y+6][STB_HBWANG_MAX_X+6]; +static signed char v_color[STB_HBWANG_MAX_Y+6][STB_HBWANG_MAX_X+5]; +static signed char h_color[STB_HBWANG_MAX_Y+5][STB_HBWANG_MAX_X+6]; + +static const char *stbhw_error; +STBHW_EXTERN const char *stbhw_get_last_error(void) +{ + const char *temp = stbhw_error; + stbhw_error = 0; + return temp; +} + + + + +///////////////////////////////////////////////////////////// +// +// SHARED TEMPLATE-DESCRIPTION CODE +// +// Used by both template generator and tileset parser; by +// using the same code, they are locked in sync and we don't +// need to try to do more sophisticated parsing of edge color +// markup or something. + +typedef void stbhw__process_rect(struct stbhw__process *p, int xpos, int ypos, + int a, int b, int c, int d, int e, int f); + +typedef struct stbhw__process +{ + stbhw_tileset *ts; + stbhw_config *c; + stbhw__process_rect *process_h_rect; + stbhw__process_rect *process_v_rect; + unsigned char *data; + int stride,w,h; +} stbhw__process; + +static void stbhw__process_h_row(stbhw__process *p, + int xpos, int ypos, + int a0, int a1, + int b0, int b1, + int c0, int c1, + int d0, int d1, + int e0, int e1, + int f0, int f1, + int variants) +{ + int a,b,c,d,e,f,v; + + for (v=0; v < variants; ++v) + for (f=f0; f <= f1; ++f) + for (e=e0; e <= e1; ++e) + for (d=d0; d <= d1; ++d) + for (c=c0; c <= c1; ++c) + for (b=b0; b <= b1; ++b) + for (a=a0; a <= a1; ++a) { + p->process_h_rect(p, xpos, ypos, a,b,c,d,e,f); + xpos += 2*p->c->short_side_len + 3; + } +} + +static void stbhw__process_v_row(stbhw__process *p, + int xpos, int ypos, + int a0, int a1, + int b0, int b1, + int c0, int c1, + int d0, int d1, + int e0, int e1, + int f0, int f1, + int variants) +{ + int a,b,c,d,e,f,v; + + for (v=0; v < variants; ++v) + for (f=f0; f <= f1; ++f) + for (e=e0; e <= e1; ++e) + for (d=d0; d <= d1; ++d) + for (c=c0; c <= c1; ++c) + for (b=b0; b <= b1; ++b) + for (a=a0; a <= a1; ++a) { + p->process_v_rect(p, xpos, ypos, a,b,c,d,e,f); + xpos += p->c->short_side_len+3; + } +} + +static void stbhw__get_template_info(stbhw_config *c, int *w, int *h, int *h_count, int *v_count) +{ + int size_x,size_y; + int horz_count,vert_count; + + if (c->is_corner) { + int horz_w = c->num_color[1] * c->num_color[2] * c->num_color[3] * c->num_vary_x; + int horz_h = c->num_color[0] * c->num_color[1] * c->num_color[2] * c->num_vary_y; + + int vert_w = c->num_color[0] * c->num_color[3] * c->num_color[2] * c->num_vary_y; + int vert_h = c->num_color[1] * c->num_color[0] * c->num_color[3] * c->num_vary_x; + + int horz_x = horz_w * (2*c->short_side_len + 3); + int horz_y = horz_h * ( c->short_side_len + 3); + + int vert_x = vert_w * ( c->short_side_len + 3); + int vert_y = vert_h * (2*c->short_side_len + 3); + + horz_count = horz_w * horz_h; + vert_count = vert_w * vert_h; + + size_x = horz_x > vert_x ? horz_x : vert_x; + size_y = 2 + horz_y + 2 + vert_y; + } else { + int horz_w = c->num_color[0] * c->num_color[1] * c->num_color[2] * c->num_vary_x; + int horz_h = c->num_color[3] * c->num_color[4] * c->num_color[2] * c->num_vary_y; + + int vert_w = c->num_color[0] * c->num_color[5] * c->num_color[1] * c->num_vary_y; + int vert_h = c->num_color[3] * c->num_color[4] * c->num_color[5] * c->num_vary_x; + + int horz_x = horz_w * (2*c->short_side_len + 3); + int horz_y = horz_h * ( c->short_side_len + 3); + + int vert_x = vert_w * ( c->short_side_len + 3); + int vert_y = vert_h * (2*c->short_side_len + 3); + + horz_count = horz_w * horz_h; + vert_count = vert_w * vert_h; + + size_x = horz_x > vert_x ? horz_x : vert_x; + size_y = 2 + horz_y + 2 + vert_y; + } + if (w) *w = size_x; + if (h) *h = size_y; + if (h_count) *h_count = horz_count; + if (v_count) *v_count = vert_count; +} + +STBHW_EXTERN void stbhw_get_template_size(stbhw_config *c, int *w, int *h) +{ + stbhw__get_template_info(c, w, h, NULL, NULL); +} + +static int stbhw__process_template(stbhw__process *p) +{ + int i,j,k,q, ypos; + int size_x, size_y; + stbhw_config *c = p->c; + + stbhw__get_template_info(c, &size_x, &size_y, NULL, NULL); + + if (p->w < size_x || p->h < size_y) { + stbhw_error = "image too small for configuration"; + return 0; + } + + if (c->is_corner) { + ypos = 2; + for (k=0; k < c->num_color[2]; ++k) { + for (j=0; j < c->num_color[1]; ++j) { + for (i=0; i < c->num_color[0]; ++i) { + for (q=0; q < c->num_vary_y; ++q) { + stbhw__process_h_row(p, 0,ypos, + 0,c->num_color[1]-1, 0,c->num_color[2]-1, 0,c->num_color[3]-1, + i,i, j,j, k,k, + c->num_vary_x); + ypos += c->short_side_len + 3; + } + } + } + } + ypos += 2; + for (k=0; k < c->num_color[3]; ++k) { + for (j=0; j < c->num_color[0]; ++j) { + for (i=0; i < c->num_color[1]; ++i) { + for (q=0; q < c->num_vary_x; ++q) { + stbhw__process_v_row(p, 0,ypos, + 0,c->num_color[0]-1, 0,c->num_color[3]-1, 0,c->num_color[2]-1, + i,i, j,j, k,k, + c->num_vary_y); + ypos += (c->short_side_len*2) + 3; + } + } + } + } + assert(ypos == size_y); + } else { + ypos = 2; + for (k=0; k < c->num_color[3]; ++k) { + for (j=0; j < c->num_color[4]; ++j) { + for (i=0; i < c->num_color[2]; ++i) { + for (q=0; q < c->num_vary_y; ++q) { + stbhw__process_h_row(p, 0,ypos, + 0,c->num_color[2]-1, k,k, + 0,c->num_color[1]-1, j,j, + 0,c->num_color[0]-1, i,i, + c->num_vary_x); + ypos += c->short_side_len + 3; + } + } + } + } + ypos += 2; + for (k=0; k < c->num_color[3]; ++k) { + for (j=0; j < c->num_color[4]; ++j) { + for (i=0; i < c->num_color[5]; ++i) { + for (q=0; q < c->num_vary_x; ++q) { + stbhw__process_v_row(p, 0,ypos, + 0,c->num_color[0]-1, i,i, + 0,c->num_color[1]-1, j,j, + 0,c->num_color[5]-1, k,k, + c->num_vary_y); + ypos += (c->short_side_len*2) + 3; + } + } + } + } + assert(ypos == size_y); + } + return 1; +} + + +///////////////////////////////////////////////////////////// +// +// MAP GENERATOR +// + +static void stbhw__draw_pixel(unsigned char *output, int stride, int x, int y, unsigned char c[3]) +{ + memcpy(output + y*stride + x*3, c, 3); +} + +static void stbhw__draw_h_tile(unsigned char *output, int stride, int xmax, int ymax, int x, int y, stbhw_tile *h, int sz) +{ + int i,j; + for (j=0; j < sz; ++j) + if (y+j >= 0 && y+j < ymax) + for (i=0; i < sz*2; ++i) + if (x+i >= 0 && x+i < xmax) + stbhw__draw_pixel(output,stride, x+i,y+j, &h->pixels[(j*sz*2 + i)*3]); +} + +static void stbhw__draw_v_tile(unsigned char *output, int stride, int xmax, int ymax, int x, int y, stbhw_tile *h, int sz) +{ + int i,j; + for (j=0; j < sz*2; ++j) + if (y+j >= 0 && y+j < ymax) + for (i=0; i < sz; ++i) + if (x+i >= 0 && x+i < xmax) + stbhw__draw_pixel(output,stride, x+i,y+j, &h->pixels[(j*sz + i)*3]); +} + + +// randomly choose a tile that fits constraints for a given spot, and update the constraints +static stbhw_tile * stbhw__choose_tile(stbhw_tile **list, int numlist, + signed char *a, signed char *b, signed char *c, + signed char *d, signed char *e, signed char *f, + int **weighting) +{ + int i,n,m = 1<<30,pass; + for (pass=0; pass < 2; ++pass) { + n=0; + // pass #1: + // count number of variants that match this partial set of constraints + // pass #2: + // stop on randomly selected match + for (i=0; i < numlist; ++i) { + stbhw_tile *h = list[i]; + if ((*a < 0 || *a == h->a) && + (*b < 0 || *b == h->b) && + (*c < 0 || *c == h->c) && + (*d < 0 || *d == h->d) && + (*e < 0 || *e == h->e) && + (*f < 0 || *f == h->f)) { + if (weighting) + n += weighting[0][i]; + else + n += 1; + if (n > m) { + // use list[i] + // update constraints to reflect what we placed + *a = h->a; + *b = h->b; + *c = h->c; + *d = h->d; + *e = h->e; + *f = h->f; + return h; + } + } + } + if (n == 0) { + stbhw_error = "couldn't find tile matching constraints"; + return NULL; + } + m = STB_HBWANG_RAND() % n; + } + STB_HBWANG_ASSERT(0); + return NULL; +} + +static int stbhw__match(int x, int y) +{ + return c_color[y][x] == c_color[y+1][x+1]; +} + +static int stbhw__weighted(int num_options, int *weights) +{ + int k, total, choice; + total = 0; + for (k=0; k < num_options; ++k) + total += weights[k]; + choice = STB_HBWANG_RAND() % total; + total = 0; + for (k=0; k < num_options; ++k) { + total += weights[k]; + if (choice < total) + break; + } + STB_HBWANG_ASSERT(k < num_options); + return k; +} + +static int stbhw__change_color(int old_color, int num_options, int *weights) +{ + if (weights) { + int k, total, choice; + total = 0; + for (k=0; k < num_options; ++k) + if (k != old_color) + total += weights[k]; + choice = STB_HBWANG_RAND() % total; + total = 0; + for (k=0; k < num_options; ++k) { + if (k != old_color) { + total += weights[k]; + if (choice < total) + break; + } + } + STB_HBWANG_ASSERT(k < num_options); + return k; + } else { + int offset = 1+STB_HBWANG_RAND() % (num_options-1); + return (old_color+offset) % num_options; + } +} + + + +// generate a map that is w * h pixels (3-bytes each) +// returns 1 on success, 0 on error +STBHW_EXTERN int stbhw_generate_image(stbhw_tileset *ts, int **weighting, unsigned char *output, int stride, int w, int h) +{ + int sidelen = ts->short_side_len; + int xmax = (w / sidelen) + 6; + int ymax = (h / sidelen) + 6; + if (xmax > STB_HBWANG_MAX_X+6 || ymax > STB_HBWANG_MAX_Y+6) { + stbhw_error = "increase STB_HBWANG_MAX_X/Y"; + return 0; + } + + if (ts->is_corner) { + int i,j, ypos; + int *cc = ts->num_color; + + for (j=0; j < ymax; ++j) { + for (i=0; i < xmax; ++i) { + int p = (i-j+1)&3; // corner type + if (weighting==NULL || weighting[p]==0 || cc[p] == 1) + c_color[j][i] = STB_HBWANG_RAND() % cc[p]; + else + c_color[j][i] = stbhw__weighted(cc[p], weighting[p]); + } + } + #ifndef STB_HBWANG_NO_REPITITION_REDUCTION + // now go back through and make sure we don't have adjancent 3x2 vertices that are identical, + // to avoid really obvious repetition (which happens easily with extreme weights) + for (j=0; j < ymax-3; ++j) { + for (i=0; i < xmax-3; ++i) { + //int p = (i-j+1) & 3; // corner type // unused, not sure what the intent was so commenting it out + STB_HBWANG_ASSERT(i+3 < STB_HBWANG_MAX_X+6); + STB_HBWANG_ASSERT(j+3 < STB_HBWANG_MAX_Y+6); + if (stbhw__match(i,j) && stbhw__match(i,j+1) && stbhw__match(i,j+2) + && stbhw__match(i+1,j) && stbhw__match(i+1,j+1) && stbhw__match(i+1,j+2)) { + int p = ((i+1)-(j+1)+1) & 3; + if (cc[p] > 1) + c_color[j+1][i+1] = stbhw__change_color(c_color[j+1][i+1], cc[p], weighting ? weighting[p] : NULL); + } + if (stbhw__match(i,j) && stbhw__match(i+1,j) && stbhw__match(i+2,j) + && stbhw__match(i,j+1) && stbhw__match(i+1,j+1) && stbhw__match(i+2,j+1)) { + int p = ((i+2)-(j+1)+1) & 3; + if (cc[p] > 1) + c_color[j+1][i+2] = stbhw__change_color(c_color[j+1][i+2], cc[p], weighting ? weighting[p] : NULL); + } + } + } + #endif + + ypos = -1 * sidelen; + for (j = -1; ypos < h; ++j) { + // a general herringbone row consists of: + // horizontal left block, the bottom of a previous vertical, the top of a new vertical + int phase = (j & 3); + // displace horizontally according to pattern + if (phase == 0) { + i = 0; + } else { + i = phase-4; + } + for (;; i += 4) { + int xpos = i * sidelen; + if (xpos >= w) + break; + // horizontal left-block + if (xpos + sidelen*2 >= 0 && ypos >= 0) { + stbhw_tile *t = stbhw__choose_tile( + ts->h_tiles, ts->num_h_tiles, + &c_color[j+2][i+2], &c_color[j+2][i+3], &c_color[j+2][i+4], + &c_color[j+3][i+2], &c_color[j+3][i+3], &c_color[j+3][i+4], + weighting + ); + if (t == NULL) + return 0; + stbhw__draw_h_tile(output,stride,w,h, xpos, ypos, t, sidelen); + } + xpos += sidelen * 2; + // now we're at the end of a previous vertical one + xpos += sidelen; + // now we're at the start of a new vertical one + if (xpos < w) { + stbhw_tile *t = stbhw__choose_tile( + ts->v_tiles, ts->num_v_tiles, + &c_color[j+2][i+5], &c_color[j+3][i+5], &c_color[j+4][i+5], + &c_color[j+2][i+6], &c_color[j+3][i+6], &c_color[j+4][i+6], + weighting + ); + if (t == NULL) + return 0; + stbhw__draw_v_tile(output,stride,w,h, xpos, ypos, t, sidelen); + } + } + ypos += sidelen; + } + } else { + // @TODO edge-color repetition reduction + int i,j, ypos; + memset(v_color, -1, sizeof(v_color)); + memset(h_color, -1, sizeof(h_color)); + + ypos = -1 * sidelen; + for (j = -1; ypos= w) + break; + // horizontal left-block + if (xpos + sidelen*2 >= 0 && ypos >= 0) { + stbhw_tile *t = stbhw__choose_tile( + ts->h_tiles, ts->num_h_tiles, + &h_color[j+2][i+2], &h_color[j+2][i+3], + &v_color[j+2][i+2], &v_color[j+2][i+4], + &h_color[j+3][i+2], &h_color[j+3][i+3], + weighting + ); + if (t == NULL) return 0; + stbhw__draw_h_tile(output,stride,w,h, xpos, ypos, t, sidelen); + } + xpos += sidelen * 2; + // now we're at the end of a previous vertical one + xpos += sidelen; + // now we're at the start of a new vertical one + if (xpos < w) { + stbhw_tile *t = stbhw__choose_tile( + ts->v_tiles, ts->num_v_tiles, + &h_color[j+2][i+5], + &v_color[j+2][i+5], &v_color[j+2][i+6], + &v_color[j+3][i+5], &v_color[j+3][i+6], + &h_color[j+4][i+5], + weighting + ); + if (t == NULL) return 0; + stbhw__draw_v_tile(output,stride,w,h, xpos, ypos, t, sidelen); + } + } + ypos += sidelen; + } + } + return 1; +} + +static void stbhw__parse_h_rect(stbhw__process *p, int xpos, int ypos, + int a, int b, int c, int d, int e, int f) +{ + int len = p->c->short_side_len; + stbhw_tile *h = (stbhw_tile *) malloc(sizeof(*h)-1 + 3 * (len*2) * len); + int i,j; + ++xpos; + ++ypos; + h->a = a, h->b = b, h->c = c, h->d = d, h->e = e, h->f = f; + for (j=0; j < len; ++j) + for (i=0; i < len*2; ++i) + memcpy(h->pixels + j*(3*len*2) + i*3, p->data+(ypos+j)*p->stride+(xpos+i)*3, 3); + STB_HBWANG_ASSERT(p->ts->num_h_tiles < p->ts->max_h_tiles); + p->ts->h_tiles[p->ts->num_h_tiles++] = h; +} + +static void stbhw__parse_v_rect(stbhw__process *p, int xpos, int ypos, + int a, int b, int c, int d, int e, int f) +{ + int len = p->c->short_side_len; + stbhw_tile *h = (stbhw_tile *) malloc(sizeof(*h)-1 + 3 * (len*2) * len); + int i,j; + ++xpos; + ++ypos; + h->a = a, h->b = b, h->c = c, h->d = d, h->e = e, h->f = f; + for (j=0; j < len*2; ++j) + for (i=0; i < len; ++i) + memcpy(h->pixels + j*(3*len) + i*3, p->data+(ypos+j)*p->stride+(xpos+i)*3, 3); + STB_HBWANG_ASSERT(p->ts->num_v_tiles < p->ts->max_v_tiles); + p->ts->v_tiles[p->ts->num_v_tiles++] = h; +} + +STBHW_EXTERN int stbhw_build_tileset_from_image(stbhw_tileset *ts, unsigned char *data, int stride, int w, int h) +{ + int i, h_count, v_count; + unsigned char header[9]; + stbhw_config c = { 0 }; + stbhw__process p = { 0 }; + + // extract binary header + + // remove encoding that makes it more visually obvious it encodes actual data + for (i=0; i < 9; ++i) + header[i] = data[w*3 - 1 - i] ^ (i*55); + + // extract header info + if (header[7] == 0xc0) { + // corner-type + c.is_corner = 1; + for (i=0; i < 4; ++i) + c.num_color[i] = header[i]; + c.num_vary_x = header[4]; + c.num_vary_y = header[5]; + c.short_side_len = header[6]; + } else { + c.is_corner = 0; + // edge-type + for (i=0; i < 6; ++i) + c.num_color[i] = header[i]; + c.num_vary_x = header[6]; + c.num_vary_y = header[7]; + c.short_side_len = header[8]; + } + + if (c.num_vary_x < 0 || c.num_vary_x > 64 || c.num_vary_y < 0 || c.num_vary_y > 64) + return 0; + if (c.short_side_len == 0) + return 0; + if (c.num_color[0] > 32 || c.num_color[1] > 32 || c.num_color[2] > 32 || c.num_color[3] > 32) + return 0; + + stbhw__get_template_info(&c, NULL, NULL, &h_count, &v_count); + + ts->is_corner = c.is_corner; + ts->short_side_len = c.short_side_len; + memcpy(ts->num_color, c.num_color, sizeof(ts->num_color)); + + ts->max_h_tiles = h_count; + ts->max_v_tiles = v_count; + + ts->num_h_tiles = ts->num_v_tiles = 0; + + ts->h_tiles = (stbhw_tile **) malloc(sizeof(*ts->h_tiles) * h_count); + ts->v_tiles = (stbhw_tile **) malloc(sizeof(*ts->v_tiles) * v_count); + + p.ts = ts; + p.data = data; + p.stride = stride; + p.process_h_rect = stbhw__parse_h_rect; + p.process_v_rect = stbhw__parse_v_rect; + p.w = w; + p.h = h; + p.c = &c; + + // load all the tiles out of the image + return stbhw__process_template(&p); +} + +STBHW_EXTERN void stbhw_free_tileset(stbhw_tileset *ts) +{ + int i; + for (i=0; i < ts->num_h_tiles; ++i) + free(ts->h_tiles[i]); + for (i=0; i < ts->num_v_tiles; ++i) + free(ts->v_tiles[i]); + free(ts->h_tiles); + free(ts->v_tiles); + ts->h_tiles = NULL; + ts->v_tiles = NULL; + ts->num_h_tiles = ts->max_h_tiles = 0; + ts->num_v_tiles = ts->max_v_tiles = 0; +} + +////////////////////////////////////////////////////////////////////////////// +// +// GENERATOR +// +// + + +// shared code + +static void stbhw__set_pixel(unsigned char *data, int stride, int xpos, int ypos, unsigned char color[3]) +{ + memcpy(data + ypos*stride + xpos*3, color, 3); +} + +static void stbhw__stbhw__set_pixel_whiten(unsigned char *data, int stride, int xpos, int ypos, unsigned char color[3]) +{ + unsigned char c2[3]; + int i; + for (i=0; i < 3; ++i) + c2[i] = (color[i]*2 + 255)/3; + memcpy(data + ypos*stride + xpos*3, c2, 3); +} + + +static unsigned char stbhw__black[3] = { 0,0,0 }; + +// each edge set gets its own unique color variants +// used http://phrogz.net/css/distinct-colors.html to generate this set, +// but it's not very good and needs to be revised + +static unsigned char stbhw__color[7][8][3] = +{ + { {255,51,51} , {143,143,29}, {0,199,199}, {159,119,199}, {0,149,199} , {143, 0,143}, {255,128,0}, {64,255,0}, }, + { {235,255,30 }, {255,0,255}, {199,139,119}, {29,143, 57}, {143,0,71} , { 0,143,143}, {0,99,199}, {143,71,0}, }, + { {0,149,199} , {143, 0,143}, {255,128,0}, {64,255,0}, {255,191,0} , {51,255,153}, {0,0,143}, {199,119,159},}, + { {143,0,71} , { 0,143,143}, {0,99,199}, {143,71,0}, {255,190,153}, { 0,255,255}, {128,0,255}, {255,51,102},}, + { {255,191,0} , {51,255,153}, {0,0,143}, {199,119,159}, {255,51,51} , {143,143,29}, {0,199,199}, {159,119,199},}, + { {255,190,153}, { 0,255,255}, {128,0,255}, {255,51,102}, {235,255,30 }, {255,0,255}, {199,139,119}, {29,143, 57}, }, + + { {40,40,40 }, { 90,90,90 }, { 150,150,150 }, { 200,200,200 }, + { 255,90,90 }, { 160,160,80}, { 50,150,150 }, { 200,50,200 } }, +}; + +static void stbhw__draw_hline(unsigned char *data, int stride, int xpos, int ypos, int color, int len, int slot) +{ + int i; + int j = len * 6 / 16; + int k = len * 10 / 16; + for (i=0; i < len; ++i) + stbhw__set_pixel(data, stride, xpos+i, ypos, stbhw__black); + if (k-j < 2) { + j = len/2 - 1; + k = j+2; + if (len & 1) + ++k; + } + for (i=j; i < k; ++i) + stbhw__stbhw__set_pixel_whiten(data, stride, xpos+i, ypos, stbhw__color[slot][color]); +} + +static void stbhw__draw_vline(unsigned char *data, int stride, int xpos, int ypos, int color, int len, int slot) +{ + int i; + int j = len * 6 / 16; + int k = len * 10 / 16; + for (i=0; i < len; ++i) + stbhw__set_pixel(data, stride, xpos, ypos+i, stbhw__black); + if (k-j < 2) { + j = len/2 - 1; + k = j+2; + if (len & 1) + ++k; + } + for (i=j; i < k; ++i) + stbhw__stbhw__set_pixel_whiten(data, stride, xpos, ypos+i, stbhw__color[slot][color]); +} + +// 0--*--1--*--2--*--3 +// | | | +// * * * +// | | | +// 1--*--2--*--3 0--*--1--*--2 +// | | | +// * * * +// | | | +// 0--*--1--*--2--*--3 +// +// variables while enumerating (no correspondence between corners +// of the types is implied by these variables) +// +// a-----b-----c a-----d +// | | | | +// | | | | +// | | | | +// d-----e-----f b e +// | | +// | | +// | | +// c-----f +// + +unsigned char stbhw__corner_colors[4][4][3] = +{ + { { 255,0,0 }, { 200,200,200 }, { 100,100,200 }, { 255,200,150 }, }, + { { 0,0,255 }, { 255,255,0 }, { 100,200,100 }, { 150,255,200 }, }, + { { 255,0,255 }, { 80,80,80 }, { 200,100,100 }, { 200,150,255 }, }, + { { 0,255,255 }, { 0,255,0 }, { 200,120,200 }, { 255,200,200 }, }, +}; + +int stbhw__corner_colors_to_edge_color[4][4] = +{ + // 0 1 2 3 + { 0, 1, 4, 9, }, // 0 + { 2, 3, 5, 10, }, // 1 + { 6, 7, 8, 11, }, // 2 + { 12, 13, 14, 15, }, // 3 +}; + +#define stbhw__c2e stbhw__corner_colors_to_edge_color + +static void stbhw__draw_clipped_corner(unsigned char *data, int stride, int xpos, int ypos, int w, int h, int x, int y) +{ + static unsigned char template_color[3] = { 167,204,204 }; + int i,j; + for (j = -2; j <= 1; ++j) { + for (i = -2; i <= 1; ++i) { + if ((i == -2 || i == 1) && (j == -2 || j == 1)) + continue; + else { + if (x+i < 1 || x+i > w) continue; + if (y+j < 1 || y+j > h) continue; + stbhw__set_pixel(data, stride, xpos+x+i, ypos+y+j, template_color); + + } + } + } +} + +static void stbhw__edge_process_h_rect(stbhw__process *p, int xpos, int ypos, + int a, int b, int c, int d, int e, int f) +{ + int len = p->c->short_side_len; + stbhw__draw_hline(p->data, p->stride, xpos+1 , ypos , a, len, 2); + stbhw__draw_hline(p->data, p->stride, xpos+ len+1 , ypos , b, len, 3); + stbhw__draw_vline(p->data, p->stride, xpos , ypos+1 , c, len, 1); + stbhw__draw_vline(p->data, p->stride, xpos+2*len+1 , ypos+1 , d, len, 4); + stbhw__draw_hline(p->data, p->stride, xpos+1 , ypos + len+1, e, len, 0); + stbhw__draw_hline(p->data, p->stride, xpos + len+1 , ypos + len+1, f, len, 2); +} + +static void stbhw__edge_process_v_rect(stbhw__process *p, int xpos, int ypos, + int a, int b, int c, int d, int e, int f) +{ + int len = p->c->short_side_len; + stbhw__draw_hline(p->data, p->stride, xpos+1 , ypos , a, len, 0); + stbhw__draw_vline(p->data, p->stride, xpos , ypos+1 , b, len, 5); + stbhw__draw_vline(p->data, p->stride, xpos + len+1, ypos+1 , c, len, 1); + stbhw__draw_vline(p->data, p->stride, xpos , ypos + len+1, d, len, 4); + stbhw__draw_vline(p->data, p->stride, xpos + len+1, ypos + len+1, e, len, 5); + stbhw__draw_hline(p->data, p->stride, xpos+1 , ypos + 2*len+1, f, len, 3); +} + +static void stbhw__corner_process_h_rect(stbhw__process *p, int xpos, int ypos, + int a, int b, int c, int d, int e, int f) +{ + int len = p->c->short_side_len; + + stbhw__draw_hline(p->data, p->stride, xpos+1 , ypos , stbhw__c2e[a][b], len, 2); + stbhw__draw_hline(p->data, p->stride, xpos+ len+1 , ypos , stbhw__c2e[b][c], len, 3); + stbhw__draw_vline(p->data, p->stride, xpos , ypos+1 , stbhw__c2e[a][d], len, 1); + stbhw__draw_vline(p->data, p->stride, xpos+2*len+1 , ypos+1 , stbhw__c2e[c][f], len, 4); + stbhw__draw_hline(p->data, p->stride, xpos+1 , ypos + len+1, stbhw__c2e[d][e], len, 0); + stbhw__draw_hline(p->data, p->stride, xpos + len+1 , ypos + len+1, stbhw__c2e[e][f], len, 2); + + if (p->c->corner_type_color_template[1][a]) stbhw__draw_clipped_corner(p->data,p->stride, xpos,ypos, len*2,len, 1,1); + if (p->c->corner_type_color_template[2][b]) stbhw__draw_clipped_corner(p->data,p->stride, xpos,ypos, len*2,len, len+1,1); + if (p->c->corner_type_color_template[3][c]) stbhw__draw_clipped_corner(p->data,p->stride, xpos,ypos, len*2,len, len*2+1,1); + + if (p->c->corner_type_color_template[0][d]) stbhw__draw_clipped_corner(p->data,p->stride, xpos,ypos, len*2,len, 1,len+1); + if (p->c->corner_type_color_template[1][e]) stbhw__draw_clipped_corner(p->data,p->stride, xpos,ypos, len*2,len, len+1,len+1); + if (p->c->corner_type_color_template[2][f]) stbhw__draw_clipped_corner(p->data,p->stride, xpos,ypos, len*2,len, len*2+1,len+1); + + stbhw__set_pixel(p->data, p->stride, xpos , ypos, stbhw__corner_colors[1][a]); + stbhw__set_pixel(p->data, p->stride, xpos+len , ypos, stbhw__corner_colors[2][b]); + stbhw__set_pixel(p->data, p->stride, xpos+2*len+1, ypos, stbhw__corner_colors[3][c]); + stbhw__set_pixel(p->data, p->stride, xpos , ypos+len+1, stbhw__corner_colors[0][d]); + stbhw__set_pixel(p->data, p->stride, xpos+len , ypos+len+1, stbhw__corner_colors[1][e]); + stbhw__set_pixel(p->data, p->stride, xpos+2*len+1, ypos+len+1, stbhw__corner_colors[2][f]); +} + +static void stbhw__corner_process_v_rect(stbhw__process *p, int xpos, int ypos, + int a, int b, int c, int d, int e, int f) +{ + int len = p->c->short_side_len; + + stbhw__draw_hline(p->data, p->stride, xpos+1 , ypos , stbhw__c2e[a][d], len, 0); + stbhw__draw_vline(p->data, p->stride, xpos , ypos+1 , stbhw__c2e[a][b], len, 5); + stbhw__draw_vline(p->data, p->stride, xpos + len+1, ypos+1 , stbhw__c2e[d][e], len, 1); + stbhw__draw_vline(p->data, p->stride, xpos , ypos + len+1, stbhw__c2e[b][c], len, 4); + stbhw__draw_vline(p->data, p->stride, xpos + len+1, ypos + len+1, stbhw__c2e[e][f], len, 5); + stbhw__draw_hline(p->data, p->stride, xpos+1 , ypos + 2*len+1, stbhw__c2e[c][f], len, 3); + + if (p->c->corner_type_color_template[0][a]) stbhw__draw_clipped_corner(p->data,p->stride, xpos,ypos, len,len*2, 1,1); + if (p->c->corner_type_color_template[3][b]) stbhw__draw_clipped_corner(p->data,p->stride, xpos,ypos, len,len*2, 1,len+1); + if (p->c->corner_type_color_template[2][c]) stbhw__draw_clipped_corner(p->data,p->stride, xpos,ypos, len,len*2, 1,len*2+1); + + if (p->c->corner_type_color_template[1][d]) stbhw__draw_clipped_corner(p->data,p->stride, xpos,ypos, len,len*2, len+1,1); + if (p->c->corner_type_color_template[0][e]) stbhw__draw_clipped_corner(p->data,p->stride, xpos,ypos, len,len*2, len+1,len+1); + if (p->c->corner_type_color_template[3][f]) stbhw__draw_clipped_corner(p->data,p->stride, xpos,ypos, len,len*2, len+1,len*2+1); + + stbhw__set_pixel(p->data, p->stride, xpos , ypos , stbhw__corner_colors[0][a]); + stbhw__set_pixel(p->data, p->stride, xpos , ypos+len , stbhw__corner_colors[3][b]); + stbhw__set_pixel(p->data, p->stride, xpos , ypos+2*len+1, stbhw__corner_colors[2][c]); + stbhw__set_pixel(p->data, p->stride, xpos+len+1, ypos , stbhw__corner_colors[1][d]); + stbhw__set_pixel(p->data, p->stride, xpos+len+1, ypos+len , stbhw__corner_colors[0][e]); + stbhw__set_pixel(p->data, p->stride, xpos+len+1, ypos+2*len+1, stbhw__corner_colors[3][f]); +} + +// generates a template image, assuming data is 3*w*h bytes long, RGB format +STBHW_EXTERN int stbhw_make_template(stbhw_config *c, unsigned char *data, int w, int h, int stride_in_bytes) +{ + stbhw__process p; + int i; + + p.data = data; + p.w = w; + p.h = h; + p.stride = stride_in_bytes; + p.ts = 0; + p.c = c; + + if (c->is_corner) { + p.process_h_rect = stbhw__corner_process_h_rect; + p.process_v_rect = stbhw__corner_process_v_rect; + } else { + p.process_h_rect = stbhw__edge_process_h_rect; + p.process_v_rect = stbhw__edge_process_v_rect; + } + + for (i=0; i < p.h; ++i) + memset(p.data + i*p.stride, 255, 3*p.w); + + if (!stbhw__process_template(&p)) + return 0; + + if (c->is_corner) { + // write out binary information in first line of image + for (i=0; i < 4; ++i) + data[w*3-1-i] = c->num_color[i]; + data[w*3-1-i] = c->num_vary_x; + data[w*3-2-i] = c->num_vary_y; + data[w*3-3-i] = c->short_side_len; + data[w*3-4-i] = 0xc0; + } else { + for (i=0; i < 6; ++i) + data[w*3-1-i] = c->num_color[i]; + data[w*3-1-i] = c->num_vary_x; + data[w*3-2-i] = c->num_vary_y; + data[w*3-3-i] = c->short_side_len; + } + + // make it more obvious it encodes actual data + for (i=0; i < 9; ++i) + p.data[p.w*3 - 1 - i] ^= i*55; + + return 1; +} +#endif // STB_HBWANG_IMPLEMENTATION diff --git a/tests/data/c/stb/stb_hexwave.h b/tests/data/c/stb/stb_hexwave.h new file mode 100644 index 000000000..480ab1b2a --- /dev/null +++ b/tests/data/c/stb/stb_hexwave.h @@ -0,0 +1,680 @@ +// stb_hexwave - v0.5 - public domain, initial release 2021-04-01 +// +// A flexible anti-aliased (bandlimited) digital audio oscillator. +// +// This library generates waveforms of a variety of shapes made of +// line segments. It does not do envelopes, LFO effects, etc.; it +// merely tries to solve the problem of generating an artifact-free +// morphable digital waveform with a variety of spectra, and leaves +// it to the user to rescale the waveform and mix multiple voices, etc. +// +// Compiling: +// +// In one C/C++ file that #includes this file, do +// +// #define STB_HEXWAVE_IMPLEMENTATION +// #include "stb_hexwave.h" +// +// Optionally, #define STB_HEXWAVE_STATIC before including +// the header to cause the definitions to be private to the +// implementation file (i.e. to be "static" instead of "extern"). +// +// Notes: +// +// Optionally performs memory allocation during initialization, +// never allocates otherwise. +// +// License: +// +// See end of file for license information. +// +// Usage: +// +// Initialization: +// +// hexwave_init(32,16,NULL); // read "header section" for alternatives +// +// Create oscillator: +// +// HexWave *osc = malloc(sizeof(*osc)); // or "new HexWave", or declare globally or on stack +// hexwave_create(osc, reflect_flag, peak_time, half_height, zero_wait); +// see "Waveform shapes" below for the meaning of these parameters +// +// Generate audio: +// +// hexwave_generate_samples(output, number_of_samples, osc, oscillator_freq) +// where: +// output is a buffer where the library will store floating point audio samples +// number_of_samples is the number of audio samples to generate +// osc is a pointer to a Hexwave +// oscillator_freq is the frequency of the oscillator divided by the sample rate +// +// The output samples will continue from where the samples generated by the +// previous hexwave_generate_samples() on this oscillator ended. +// +// Change oscillator waveform: +// +// hexwave_change(osc, reflect_flag, peak_time, half_height, zero_wait); +// can call in between calls to hexwave_generate_samples +// +// Waveform shapes: +// +// All waveforms generated by hexwave are constructed from six line segments +// characterized by 3 parameters. +// +// See demonstration: https://www.youtube.com/watch?v=hsUCrAsDN-M +// +// reflect=0 reflect=1 +// +// 0-----P---1 0-----P---1 peak_time = P +// . 1 . 1 +// /\_ : /\_ : +// / \_ : / \_ : +// / \.H / \.H half_height = H +// / | : / | : +// _____/ |_:___ _____/ | : _____ +// . : \ | . | : / +// . : \ | . | : / +// . : \ _/ . \_: / +// . : \ _/ . :_ / +// . -1 \/ . -1 \/ +// 0 - Z - - - - 1 0 - Z - - - - 1 zero_wait = Z +// +// Classic waveforms: +// peak half zero +// reflect time height wait +// Sawtooth 1 0 0 0 +// Square 1 0 1 0 +// Triangle 1 0.5 0 0 +// +// Some waveforms can be produced in multiple ways, which is useful when morphing +// into other waveforms, and there are a few more notable shapes: +// +// peak half zero +// reflect time height wait +// Sawtooth 1 1 any 0 +// Sawtooth (8va) 1 0 -1 0 +// Triangle 1 0.5 0 0 +// Square 1 0 1 0 +// Square 0 0 1 0 +// Triangle 0 0.5 0 0 +// Triangle 0 0 -1 0 +// AlternatingSaw 0 0 0 0 +// AlternatingSaw 0 1 any 0 +// Stairs 0 0 1 0.5 +// +// The "Sawtooth (8va)" waveform is identical to a sawtooth wave with 2x the +// frequency, but when morphed with other values, it becomes an overtone of +// the base frequency. +// +// Morphing waveforms: +// +// Sweeping peak_time morphs the waveform while producing various spectra. +// Sweeping half_height effectively crossfades between two waveforms; useful, but less exciting. +// Sweeping zero_wait produces a similar effect no matter the reset of the waveform, +// a sort of high-pass/PWM effect where the wave becomes silent at zero_wait=1. +// +// You can trivially morph between any two waveforms from the above table +// which only differ in one column. +// +// Crossfade between classic waveforms: +// peak half zero +// Start End reflect time height wait +// ----- --- ------- ---- ------ ---- +// Triangle Square 0 0 -1..1 0 +// Saw Square 1 0 0..1 0 +// Triangle Saw 1 0.5 0..2 0 +// +// The last morph uses uses half-height values larger than 1, which means it will +// be louder and the output should be scaled down by half to compensate, or better +// by dynamically tracking the morph: volume_scale = 1 - half_height/4 +// +// Non-crossfade morph between classic waveforms, most require changing +// two parameters at the same time: +// peak half zero +// Start End reflect time height wait +// ----- --- ------- ---- ------ ---- +// Square Triangle any 0..0.5 1..0 0 +// Square Saw 1 0..1 1..any 0 +// Triangle Saw 1 0.5..1 0..-1 0 +// +// Other noteworthy morphs between simple shapes: +// peak half zero +// Start Halfway End reflect time height wait +// ----- --------- --- ------- ---- ------ ---- +// Saw (8va,neg) Saw (pos) 1 0..1 -1 0 +// Saw (neg) Saw (pos) 1 0..1 0 0 +// Triangle AlternatingSaw 0 0..1 -1 0 +// AlternatingSaw Triangle AlternatingSaw 0 0..1 0 0 +// Square AlternatingSaw 0 0..1 1 0 +// Triangle Triangle AlternatingSaw 0 0..1 -1..1 0 +// Square AlternatingSaw 0 0..1 1..0 0 +// Saw (8va) Triangle Saw 1 0..1 -1..1 0 +// Saw (neg) Saw (pos) 1 0..1 0..1 0 +// AlternatingSaw AlternatingSaw 0 0..1 0..any 0 +// +// The last entry is noteworthy because the morph from the halfway point to either +// endpoint sounds very different. For example, an LFO sweeping back and forth over +// the whole range will morph between the middle timbre and the AlternatingSaw +// timbre in two different ways, alternating. +// +// Entries with "any" for half_height are whole families of morphs, as you can pick +// any value you want as the endpoint for half_height. +// +// You can always morph between any two waveforms with the same value of 'reflect' +// by just sweeping the parameters simultaneously. There will never be artifacts +// and the result will always be useful, if not necessarily what you want. +// +// You can vary the sound of two-parameter morphs by ramping them differently, +// e.g. if the morph goes from t=0..1, then square-to-triangle looks like: +// peak_time = lerp(t, 0, 0.5) +// half_height = lerp(t, 1, 0 ) +// but you can also do things like: +// peak_time = lerp(smoothstep(t), 0, 0.5) +// half_height = cos(PI/2 * t) +// +// How it works: +// +// hexwave use BLEP to bandlimit discontinuities and BLAMP +// to bandlimit C1 discontinuities. This is not polyBLEP +// (polynomial BLEP), it is table-driven BLEP. It is +// also not minBLEP (minimum-phase BLEP), as that complicates +// things for little benefit once BLAMP is involved. +// +// The previous oscillator frequency is remembered, and when +// the frequency changes, a BLAMP is generated to remove the +// C1 discontinuity, which reduces artifacts for sweeps/LFO. +// +// Changes to an oscillator timbre using hexwave_change() actually +// wait until the oscillator finishes its current cycle. All +// waveforms with non-zero "zero_wait" settings pass through 0 +// and have 0-slope at the start of a cycle, which means changing +// the settings is artifact free at that time. (If zero_wait is 0, +// the code still treats it as passing through 0 with 0-slope; it'll +// apply the necessary fixups to make it artifact free as if it does +// transition to 0 with 0-slope vs. the waveform at the end of +// the cycle, then adds the fixups for a non-0 and non-0 slope +// at the start of the cycle, which cancels out if zero_wait is 0, +// and still does the right thing if zero_wait is 0 when the +// settings are updated.) +// +// BLEP/BLAMP normally requires overlapping buffers, but this +// is hidden from the user by generating the waveform to a +// temporary buffer and saving the overlap regions internally +// between calls. (It is slightly more complicated; see code.) +// +// By design all shapes have 0 DC offset; this is one reason +// hexwave uses zero_wait instead of standard PWM. +// +// The internals of hexwave could support any arbitrary shape +// made of line segments, but I chose not to expose this +// generality in favor of a simple, easy-to-use API. + +#ifndef STB_INCLUDE_STB_HEXWAVE_H +#define STB_INCLUDE_STB_HEXWAVE_H + +#ifndef STB_HEXWAVE_MAX_BLEP_LENGTH +#define STB_HEXWAVE_MAX_BLEP_LENGTH 64 // good enough for anybody +#endif + +#ifdef STB_HEXWAVE_STATIC +#define STB_HEXWAVE_DEF static +#else +#define STB_HEXWAVE_DEF extern +#endif + +typedef struct HexWave HexWave; + +STB_HEXWAVE_DEF void hexwave_init(int width, int oversample, float *user_buffer); +// width: size of BLEP, from 4..64, larger is slower & more memory but less aliasing +// oversample: 2+, number of subsample positions, larger uses more memory but less noise +// user_buffer: optional, if provided the library will perform no allocations. +// 16*width*(oversample+1) bytes, must stay allocated as long as library is used +// technically it only needs: 8*( width * (oversample + 1)) +// + 8*((width * oversample) + 1) bytes +// +// width can be larger than 64 if you define STB_HEXWAVE_MAX_BLEP_LENGTH to a larger value + +STB_HEXWAVE_DEF void hexwave_shutdown(float *user_buffer); +// user_buffer: pass in same parameter as passed to hexwave_init + +STB_HEXWAVE_DEF void hexwave_create(HexWave *hex, int reflect, float peak_time, float half_height, float zero_wait); +// see docs above for description +// +// reflect is tested as 0 or non-zero +// peak_time is clamped to 0..1 +// half_height is not clamped +// zero_wait is clamped to 0..1 + +STB_HEXWAVE_DEF void hexwave_change(HexWave *hex, int reflect, float peak_time, float half_height, float zero_wait); +// see docs + +STB_HEXWAVE_DEF void hexwave_generate_samples(float *output, int num_samples, HexWave *hex, float freq); +// output: buffer where the library will store generated floating point audio samples +// number_of_samples: the number of audio samples to generate +// osc: pointer to a Hexwave initialized with 'hexwave_create' +// oscillator_freq: frequency of the oscillator divided by the sample rate + +// private: +typedef struct +{ + int reflect; + float peak_time; + float zero_wait; + float half_height; +} HexWaveParameters; + +struct HexWave +{ + float t, prev_dt; + HexWaveParameters current, pending; + int have_pending; + float buffer[STB_HEXWAVE_MAX_BLEP_LENGTH]; +}; +#endif + +#ifdef STB_HEXWAVE_IMPLEMENTATION + +#ifndef STB_HEXWAVE_NO_ALLOCATION +#include // malloc,free +#endif + +#include // memset,memcpy,memmove +#include // sin,cos,fabs + +#define hexwave_clamp(v,a,b) ((v) < (a) ? (a) : (v) > (b) ? (b) : (v)) + +STB_HEXWAVE_DEF void hexwave_change(HexWave *hex, int reflect, float peak_time, float half_height, float zero_wait) +{ + hex->pending.reflect = reflect; + hex->pending.peak_time = hexwave_clamp(peak_time,0,1); + hex->pending.half_height = half_height; + hex->pending.zero_wait = hexwave_clamp(zero_wait,0,1); + // put a barrier here to allow changing from a different thread than the generator + hex->have_pending = 1; +} + +STB_HEXWAVE_DEF void hexwave_create(HexWave *hex, int reflect, float peak_time, float half_height, float zero_wait) +{ + memset(hex, 0, sizeof(*hex)); + hexwave_change(hex, reflect, peak_time, half_height, zero_wait); + hex->current = hex->pending; + hex->have_pending = 0; + hex->t = 0; + hex->prev_dt = 0; +} + +static struct +{ + int width; // width of fixup in samples + int oversample; // number of oversampled versions (there's actually one more to allow lerpign) + float *blep; + float *blamp; +} hexblep; + +static void hex_add_oversampled_bleplike(float *output, float time_since_transition, float scale, float *data) +{ + float *d1,*d2; + float lerpweight; + int i, bw = hexblep.width; + + int slot = (int) (time_since_transition * hexblep.oversample); + if (slot >= hexblep.oversample) + slot = hexblep.oversample-1; // clamp in case the floats overshoot + + d1 = &data[ slot *bw]; + d2 = &data[(slot+1)*bw]; + + lerpweight = time_since_transition * hexblep.oversample - slot; + for (i=0; i < bw; ++i) + output[i] += scale * (d1[i] + (d2[i]-d1[i])*lerpweight); +} + +static void hex_blep (float *output, float time_since_transition, float scale) +{ + hex_add_oversampled_bleplike(output, time_since_transition, scale, hexblep.blep); +} + +static void hex_blamp(float *output, float time_since_transition, float scale) +{ + hex_add_oversampled_bleplike(output, time_since_transition, scale, hexblep.blamp); +} + +typedef struct +{ + float t,v,s; // time, value, slope +} hexvert; + +// each half of the waveform needs 4 vertices to represent 3 line +// segments, plus 1 more for wraparound +static void hexwave_generate_linesegs(hexvert vert[9], HexWave *hex, float dt) +{ + int j; + float min_len = dt / 256.0f; + + vert[0].t = 0; + vert[0].v = 0; + vert[1].t = hex->current.zero_wait*0.5f; + vert[1].v = 0; + vert[2].t = 0.5f*hex->current.peak_time + vert[1].t*(1-hex->current.peak_time); + vert[2].v = 1; + vert[3].t = 0.5f; + vert[3].v = hex->current.half_height; + + if (hex->current.reflect) { + for (j=4; j <= 7; ++j) { + vert[j].t = 1 - vert[7-j].t; + vert[j].v = - vert[7-j].v; + } + } else { + for (j=4; j <= 7; ++j) { + vert[j].t = 0.5f + vert[j-4].t; + vert[j].v = - vert[j-4].v; + } + } + vert[8].t = 1; + vert[8].v = 0; + + for (j=0; j < 8; ++j) { + if (vert[j+1].t <= vert[j].t + min_len) { + // if change takes place over less than a fraction of a sample treat as discontinuity + // + // otherwise the slope computation can blow up to arbitrarily large and we + // try to generate a huge BLAMP and the result is wrong. + // + // why does this happen if the math is right? i believe if done perfectly, + // the two BLAMPs on either side of the slope would cancel out, but our + // BLAMPs have only limited sub-sample precision and limited integration + // accuracy. or maybe it's just the math blowing up w/ floating point precision + // limits as we try to make x * (1/x) cancel out + // + // min_len verified artifact-free even near nyquist with only oversample=4 + vert[j+1].t = vert[j].t; + } + } + + if (vert[8].t != 1.0f) { + // if the above fixup moved the endpoint away from 1.0, move it back, + // along with any other vertices that got moved to the same time + float t = vert[8].t; + for (j=5; j <= 8; ++j) + if (vert[j].t == t) + vert[j].t = 1.0f; + } + + // compute the exact slopes from the final fixed-up positions + for (j=0; j < 8; ++j) + if (vert[j+1].t == vert[j].t) + vert[j].s = 0; + else + vert[j].s = (vert[j+1].v - vert[j].v) / (vert[j+1].t - vert[j].t); + + // wraparound at end + vert[8].t = 1; + vert[8].v = vert[0].v; + vert[8].s = vert[0].s; +} + +STB_HEXWAVE_DEF void hexwave_generate_samples(float *output, int num_samples, HexWave *hex, float freq) +{ + hexvert vert[9]; + int pass,i,j; + float t = hex->t; + float temp_output[2*STB_HEXWAVE_MAX_BLEP_LENGTH]; + int buffered_length = sizeof(float)*hexblep.width; + float dt = (float) fabs(freq); + float recip_dt = (dt == 0.0f) ? 0.0f : 1.0f / dt; + + int halfw = hexblep.width/2; + // all sample times are biased by halfw to leave room for BLEP/BLAMP to go back in time + + if (num_samples <= 0) + return; + + // convert parameters to times and slopes + hexwave_generate_linesegs(vert, hex, dt); + + if (hex->prev_dt != dt) { + // if frequency changes, add a fixup at the derivative discontinuity starting at now + float slope; + for (j=1; j < 6; ++j) + if (t < vert[j].t) + break; + slope = vert[j].s; + if (slope != 0) + hex_blamp(output, 0, (dt - hex->prev_dt)*slope); + hex->prev_dt = dt; + } + + // copy the buffered data from last call and clear the rest of the output array + memset(output, 0, sizeof(float)*num_samples); + memset(temp_output, 0, 2*hexblep.width*sizeof(float)); + + if (num_samples >= hexblep.width) { + memcpy(output, hex->buffer, buffered_length); + } else { + // if the output is shorter than hexblep.width, we do all synthesis to temp_output + memcpy(temp_output, hex->buffer, buffered_length); + } + + for (pass=0; pass < 2; ++pass) { + int i0,i1; + float *out; + + // we want to simulate having one buffer that is num_output + hexblep.width + // samples long, without putting that requirement on the user, and without + // allocating a temp buffer that's as long as the whole thing. so we use two + // overlapping buffers, one the user's buffer and one a fixed-length temp + // buffer. + + if (pass == 0) { + if (num_samples < hexblep.width) + continue; + // run as far as we can without overwriting the end of the user's buffer + out = output; + i0 = 0; + i1 = num_samples - hexblep.width; + } else { + // generate the rest into a temp buffer + out = temp_output; + i0 = 0; + if (num_samples >= hexblep.width) + i1 = hexblep.width; + else + i1 = num_samples; + } + + // determine current segment + for (j=0; j < 8; ++j) + if (t < vert[j+1].t) + break; + + i = i0; + for(;;) { + while (t < vert[j+1].t) { + if (i == i1) + goto done; + out[i+halfw] += vert[j].v + vert[j].s*(t - vert[j].t); + t += dt; + ++i; + } + // transition from lineseg starting at j to lineseg starting at j+1 + + if (vert[j].t == vert[j+1].t) + hex_blep(out+i, recip_dt*(t-vert[j+1].t), (vert[j+1].v - vert[j].v)); + hex_blamp(out+i, recip_dt*(t-vert[j+1].t), dt*(vert[j+1].s - vert[j].s)); + ++j; + + if (j == 8) { + // change to different waveform if there's a change pending + j = 0; + t -= 1.0; // t was >= 1.f if j==8 + if (hex->have_pending) { + float prev_s0 = vert[j].s; + float prev_v0 = vert[j].v; + hex->current = hex->pending; + hex->have_pending = 0; + hexwave_generate_linesegs(vert, hex, dt); + // the following never occurs with this oscillator, but it makes + // the code work in more general cases + if (vert[j].v != prev_v0) + hex_blep (out+i, recip_dt*t, (vert[j].v - prev_v0)); + if (vert[j].s != prev_s0) + hex_blamp(out+i, recip_dt*t, dt*(vert[j].s - prev_s0)); + } + } + } + done: + ; + } + + // at this point, we've written output[] and temp_output[] + if (num_samples >= hexblep.width) { + // the first half of temp[] overlaps the end of output, the second half will be the new start overlap + for (i=0; i < hexblep.width; ++i) + output[num_samples-hexblep.width + i] += temp_output[i]; + memcpy(hex->buffer, temp_output+hexblep.width, buffered_length); + } else { + for (i=0; i < num_samples; ++i) + output[i] = temp_output[i]; + memcpy(hex->buffer, temp_output+num_samples, buffered_length); + } + + hex->t = t; +} + +STB_HEXWAVE_DEF void hexwave_shutdown(float *user_buffer) +{ + #ifndef STB_HEXWAVE_NO_ALLOCATION + if (user_buffer != 0) { + free(hexblep.blep); + free(hexblep.blamp); + } + #endif +} + +// buffer should be NULL or must be 4*(width*(oversample+1)*2 + +STB_HEXWAVE_DEF void hexwave_init(int width, int oversample, float *user_buffer) +{ + int halfwidth = width/2; + int half = halfwidth*oversample; + int blep_buffer_count = width*(oversample+1); + int n = 2*half+1; +#ifdef STB_HEXWAVE_NO_ALLOCATION + float *buffers = user_buffer; +#else + float *buffers = user_buffer ? user_buffer : (float *) malloc(sizeof(float) * n * 2); +#endif + float *step = buffers+0*n; + float *ramp = buffers+1*n; + float *blep_buffer, *blamp_buffer; + double integrate_impulse=0, integrate_step=0; + int i,j; + + if (width > STB_HEXWAVE_MAX_BLEP_LENGTH) + width = STB_HEXWAVE_MAX_BLEP_LENGTH; + + if (user_buffer == 0) { + #ifndef STB_HEXWAVE_NO_ALLOCATION + blep_buffer = (float *) malloc(sizeof(float)*blep_buffer_count); + blamp_buffer = (float *) malloc(sizeof(float)*blep_buffer_count); + #endif + } else { + blep_buffer = ramp+n; + blamp_buffer = blep_buffer + blep_buffer_count; + } + + // compute BLEP and BLAMP by integerating windowed sinc + for (i=0; i < n; ++i) { + for (j=0; j < 16; ++j) { + float sinc_t = 3.141592f* (i-half) / oversample; + float sinc = (i==half) ? 1.0f : (float) sin(sinc_t) / (sinc_t); + float wt = 2.0f*3.1415926f * i / (n-1); + float window = (float) (0.355768 - 0.487396*cos(wt) + 0.144232*cos(2*wt) - 0.012604*cos(3*wt)); // Nuttall + double value = window * sinc; + integrate_impulse += value/16; + integrate_step += integrate_impulse/16; + } + step[i] = (float) integrate_impulse; + ramp[i] = (float) integrate_step; + } + + // renormalize + for (i=0; i < n; ++i) { + step[i] = step[i] * (float) (1.0 / step[n-1]); // step needs to reach to 1.0 + ramp[i] = ramp[i] * (float) (halfwidth / ramp[n-1]); // ramp needs to become a slope of 1.0 after oversampling + } + + // deinterleave to allow efficient interpolation e.g. w/SIMD + for (j=0; j <= oversample; ++j) { + for (i=0; i < width; ++i) { + blep_buffer [j*width+i] = step[j+i*oversample]; + blamp_buffer[j*width+i] = ramp[j+i*oversample]; + } + } + + // subtract out the naive waveform; note we can't do this to the raw data + // above, because we want the discontinuity to be in a different locations + // for j=0 and j=oversample (which exists to provide something to interpolate against) + for (j=0; j <= oversample; ++j) { + // subtract step + for (i=halfwidth; i < width; ++i) + blep_buffer [j*width+i] -= 1.0f; + // subtract ramp + for (i=halfwidth; i < width; ++i) + blamp_buffer[j*width+i] -= (j+i*oversample-half)*(1.0f/oversample); + } + + hexblep.blep = blep_buffer; + hexblep.blamp = blamp_buffer; + hexblep.width = width; + hexblep.oversample = oversample; + + #ifndef STB_HEXWAVE_NO_ALLOCATION + if (user_buffer == 0) + free(buffers); + #endif +} +#endif // STB_HEXWAVE_IMPLEMENTATION + +/* +------------------------------------------------------------------------------ +This software is available under 2 licenses -- choose whichever you prefer. +------------------------------------------------------------------------------ +ALTERNATIVE A - MIT License +Copyright (c) 2017 Sean Barrett +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is furnished to do +so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +------------------------------------------------------------------------------ +ALTERNATIVE B - Public Domain (www.unlicense.org) +This is free and unencumbered software released into the public domain. +Anyone is free to copy, modify, publish, use, compile, sell, or distribute this +software, either in source code form or as a compiled binary, for any purpose, +commercial or non-commercial, and by any means. +In jurisdictions that recognize copyright laws, the author or authors of this +software dedicate any and all copyright interest in the software to the public +domain. We make this dedication for the benefit of the public at large and to +the detriment of our heirs and successors. We intend this dedication to be an +overt act of relinquishment in perpetuity of all present and future rights to +this software under copyright law. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN +ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +------------------------------------------------------------------------------ +*/ diff --git a/tests/data/c/stb/stb_image.h b/tests/data/c/stb/stb_image.h new file mode 100644 index 000000000..9eedabedc --- /dev/null +++ b/tests/data/c/stb/stb_image.h @@ -0,0 +1,7988 @@ +/* stb_image - v2.30 - public domain image loader - http://nothings.org/stb + no warranty implied; use at your own risk + + Do this: + #define STB_IMAGE_IMPLEMENTATION + before you include this file in *one* C or C++ file to create the implementation. + + // i.e. it should look like this: + #include ... + #include ... + #include ... + #define STB_IMAGE_IMPLEMENTATION + #include "stb_image.h" + + You can #define STBI_ASSERT(x) before the #include to avoid using assert.h. + And #define STBI_MALLOC, STBI_REALLOC, and STBI_FREE to avoid using malloc,realloc,free + + + QUICK NOTES: + Primarily of interest to game developers and other people who can + avoid problematic images and only need the trivial interface + + JPEG baseline & progressive (12 bpc/arithmetic not supported, same as stock IJG lib) + PNG 1/2/4/8/16-bit-per-channel + + TGA (not sure what subset, if a subset) + BMP non-1bpp, non-RLE + PSD (composited view only, no extra channels, 8/16 bit-per-channel) + + GIF (*comp always reports as 4-channel) + HDR (radiance rgbE format) + PIC (Softimage PIC) + PNM (PPM and PGM binary only) + + Animated GIF still needs a proper API, but here's one way to do it: + http://gist.github.com/urraka/685d9a6340b26b830d49 + + - decode from memory or through FILE (define STBI_NO_STDIO to remove code) + - decode from arbitrary I/O callbacks + - SIMD acceleration on x86/x64 (SSE2) and ARM (NEON) + + Full documentation under "DOCUMENTATION" below. + + +LICENSE + + See end of file for license information. + +RECENT REVISION HISTORY: + + 2.30 (2024-05-31) avoid erroneous gcc warning + 2.29 (2023-05-xx) optimizations + 2.28 (2023-01-29) many error fixes, security errors, just tons of stuff + 2.27 (2021-07-11) document stbi_info better, 16-bit PNM support, bug fixes + 2.26 (2020-07-13) many minor fixes + 2.25 (2020-02-02) fix warnings + 2.24 (2020-02-02) fix warnings; thread-local failure_reason and flip_vertically + 2.23 (2019-08-11) fix clang static analysis warning + 2.22 (2019-03-04) gif fixes, fix warnings + 2.21 (2019-02-25) fix typo in comment + 2.20 (2019-02-07) support utf8 filenames in Windows; fix warnings and platform ifdefs + 2.19 (2018-02-11) fix warning + 2.18 (2018-01-30) fix warnings + 2.17 (2018-01-29) bugfix, 1-bit BMP, 16-bitness query, fix warnings + 2.16 (2017-07-23) all functions have 16-bit variants; optimizations; bugfixes + 2.15 (2017-03-18) fix png-1,2,4; all Imagenet JPGs; no runtime SSE detection on GCC + 2.14 (2017-03-03) remove deprecated STBI_JPEG_OLD; fixes for Imagenet JPGs + 2.13 (2016-12-04) experimental 16-bit API, only for PNG so far; fixes + 2.12 (2016-04-02) fix typo in 2.11 PSD fix that caused crashes + 2.11 (2016-04-02) 16-bit PNGS; enable SSE2 in non-gcc x64 + RGB-format JPEG; remove white matting in PSD; + allocate large structures on the stack; + correct channel count for PNG & BMP + 2.10 (2016-01-22) avoid warning introduced in 2.09 + 2.09 (2016-01-16) 16-bit TGA; comments in PNM files; STBI_REALLOC_SIZED + + See end of file for full revision history. + + + ============================ Contributors ========================= + + Image formats Extensions, features + Sean Barrett (jpeg, png, bmp) Jetro Lauha (stbi_info) + Nicolas Schulz (hdr, psd) Martin "SpartanJ" Golini (stbi_info) + Jonathan Dummer (tga) James "moose2000" Brown (iPhone PNG) + Jean-Marc Lienher (gif) Ben "Disch" Wenger (io callbacks) + Tom Seddon (pic) Omar Cornut (1/2/4-bit PNG) + Thatcher Ulrich (psd) Nicolas Guillemot (vertical flip) + Ken Miller (pgm, ppm) Richard Mitton (16-bit PSD) + github:urraka (animated gif) Junggon Kim (PNM comments) + Christopher Forseth (animated gif) Daniel Gibson (16-bit TGA) + socks-the-fox (16-bit PNG) + Jeremy Sawicki (handle all ImageNet JPGs) + Optimizations & bugfixes Mikhail Morozov (1-bit BMP) + Fabian "ryg" Giesen Anael Seghezzi (is-16-bit query) + Arseny Kapoulkine Simon Breuss (16-bit PNM) + John-Mark Allen + Carmelo J Fdez-Aguera + + Bug & warning fixes + Marc LeBlanc David Woo Guillaume George Martins Mozeiko + Christpher Lloyd Jerry Jansson Joseph Thomson Blazej Dariusz Roszkowski + Phil Jordan Dave Moore Roy Eltham + Hayaki Saito Nathan Reed Won Chun + Luke Graham Johan Duparc Nick Verigakis the Horde3D community + Thomas Ruf Ronny Chevalier github:rlyeh + Janez Zemva John Bartholomew Michal Cichon github:romigrou + Jonathan Blow Ken Hamada Tero Hanninen github:svdijk + Eugene Golushkov Laurent Gomila Cort Stratton github:snagar + Aruelien Pocheville Sergio Gonzalez Thibault Reuille github:Zelex + Cass Everitt Ryamond Barbiero github:grim210 + Paul Du Bois Engin Manap Aldo Culquicondor github:sammyhw + Philipp Wiesemann Dale Weiler Oriol Ferrer Mesia github:phprus + Josh Tobin Neil Bickford Matthew Gregan github:poppolopoppo + Julian Raschke Gregory Mullen Christian Floisand github:darealshinji + Baldur Karlsson Kevin Schmidt JR Smith github:Michaelangel007 + Brad Weinberger Matvey Cherevko github:mosra + Luca Sas Alexander Veselov Zack Middleton [reserved] + Ryan C. Gordon [reserved] [reserved] + DO NOT ADD YOUR NAME HERE + + Jacko Dirks + + To add your name to the credits, pick a random blank space in the middle and fill it. + 80% of merge conflicts on stb PRs are due to people adding their name at the end + of the credits. +*/ + +#ifndef STBI_INCLUDE_STB_IMAGE_H +#define STBI_INCLUDE_STB_IMAGE_H + +// DOCUMENTATION +// +// Limitations: +// - no 12-bit-per-channel JPEG +// - no JPEGs with arithmetic coding +// - GIF always returns *comp=4 +// +// Basic usage (see HDR discussion below for HDR usage): +// int x,y,n; +// unsigned char *data = stbi_load(filename, &x, &y, &n, 0); +// // ... process data if not NULL ... +// // ... x = width, y = height, n = # 8-bit components per pixel ... +// // ... replace '0' with '1'..'4' to force that many components per pixel +// // ... but 'n' will always be the number that it would have been if you said 0 +// stbi_image_free(data); +// +// Standard parameters: +// int *x -- outputs image width in pixels +// int *y -- outputs image height in pixels +// int *channels_in_file -- outputs # of image components in image file +// int desired_channels -- if non-zero, # of image components requested in result +// +// The return value from an image loader is an 'unsigned char *' which points +// to the pixel data, or NULL on an allocation failure or if the image is +// corrupt or invalid. The pixel data consists of *y scanlines of *x pixels, +// with each pixel consisting of N interleaved 8-bit components; the first +// pixel pointed to is top-left-most in the image. There is no padding between +// image scanlines or between pixels, regardless of format. The number of +// components N is 'desired_channels' if desired_channels is non-zero, or +// *channels_in_file otherwise. If desired_channels is non-zero, +// *channels_in_file has the number of components that _would_ have been +// output otherwise. E.g. if you set desired_channels to 4, you will always +// get RGBA output, but you can check *channels_in_file to see if it's trivially +// opaque because e.g. there were only 3 channels in the source image. +// +// An output image with N components has the following components interleaved +// in this order in each pixel: +// +// N=#comp components +// 1 grey +// 2 grey, alpha +// 3 red, green, blue +// 4 red, green, blue, alpha +// +// If image loading fails for any reason, the return value will be NULL, +// and *x, *y, *channels_in_file will be unchanged. The function +// stbi_failure_reason() can be queried for an extremely brief, end-user +// unfriendly explanation of why the load failed. Define STBI_NO_FAILURE_STRINGS +// to avoid compiling these strings at all, and STBI_FAILURE_USERMSG to get slightly +// more user-friendly ones. +// +// Paletted PNG, BMP, GIF, and PIC images are automatically depalettized. +// +// To query the width, height and component count of an image without having to +// decode the full file, you can use the stbi_info family of functions: +// +// int x,y,n,ok; +// ok = stbi_info(filename, &x, &y, &n); +// // returns ok=1 and sets x, y, n if image is a supported format, +// // 0 otherwise. +// +// Note that stb_image pervasively uses ints in its public API for sizes, +// including sizes of memory buffers. This is now part of the API and thus +// hard to change without causing breakage. As a result, the various image +// loaders all have certain limits on image size; these differ somewhat +// by format but generally boil down to either just under 2GB or just under +// 1GB. When the decoded image would be larger than this, stb_image decoding +// will fail. +// +// Additionally, stb_image will reject image files that have any of their +// dimensions set to a larger value than the configurable STBI_MAX_DIMENSIONS, +// which defaults to 2**24 = 16777216 pixels. Due to the above memory limit, +// the only way to have an image with such dimensions load correctly +// is for it to have a rather extreme aspect ratio. Either way, the +// assumption here is that such larger images are likely to be malformed +// or malicious. If you do need to load an image with individual dimensions +// larger than that, and it still fits in the overall size limit, you can +// #define STBI_MAX_DIMENSIONS on your own to be something larger. +// +// =========================================================================== +// +// UNICODE: +// +// If compiling for Windows and you wish to use Unicode filenames, compile +// with +// #define STBI_WINDOWS_UTF8 +// and pass utf8-encoded filenames. Call stbi_convert_wchar_to_utf8 to convert +// Windows wchar_t filenames to utf8. +// +// =========================================================================== +// +// Philosophy +// +// stb libraries are designed with the following priorities: +// +// 1. easy to use +// 2. easy to maintain +// 3. good performance +// +// Sometimes I let "good performance" creep up in priority over "easy to maintain", +// and for best performance I may provide less-easy-to-use APIs that give higher +// performance, in addition to the easy-to-use ones. Nevertheless, it's important +// to keep in mind that from the standpoint of you, a client of this library, +// all you care about is #1 and #3, and stb libraries DO NOT emphasize #3 above all. +// +// Some secondary priorities arise directly from the first two, some of which +// provide more explicit reasons why performance can't be emphasized. +// +// - Portable ("ease of use") +// - Small source code footprint ("easy to maintain") +// - No dependencies ("ease of use") +// +// =========================================================================== +// +// I/O callbacks +// +// I/O callbacks allow you to read from arbitrary sources, like packaged +// files or some other source. Data read from callbacks are processed +// through a small internal buffer (currently 128 bytes) to try to reduce +// overhead. +// +// The three functions you must define are "read" (reads some bytes of data), +// "skip" (skips some bytes of data), "eof" (reports if the stream is at the end). +// +// =========================================================================== +// +// SIMD support +// +// The JPEG decoder will try to automatically use SIMD kernels on x86 when +// supported by the compiler. For ARM Neon support, you must explicitly +// request it. +// +// (The old do-it-yourself SIMD API is no longer supported in the current +// code.) +// +// On x86, SSE2 will automatically be used when available based on a run-time +// test; if not, the generic C versions are used as a fall-back. On ARM targets, +// the typical path is to have separate builds for NEON and non-NEON devices +// (at least this is true for iOS and Android). Therefore, the NEON support is +// toggled by a build flag: define STBI_NEON to get NEON loops. +// +// If for some reason you do not want to use any of SIMD code, or if +// you have issues compiling it, you can disable it entirely by +// defining STBI_NO_SIMD. +// +// =========================================================================== +// +// HDR image support (disable by defining STBI_NO_HDR) +// +// stb_image supports loading HDR images in general, and currently the Radiance +// .HDR file format specifically. You can still load any file through the existing +// interface; if you attempt to load an HDR file, it will be automatically remapped +// to LDR, assuming gamma 2.2 and an arbitrary scale factor defaulting to 1; +// both of these constants can be reconfigured through this interface: +// +// stbi_hdr_to_ldr_gamma(2.2f); +// stbi_hdr_to_ldr_scale(1.0f); +// +// (note, do not use _inverse_ constants; stbi_image will invert them +// appropriately). +// +// Additionally, there is a new, parallel interface for loading files as +// (linear) floats to preserve the full dynamic range: +// +// float *data = stbi_loadf(filename, &x, &y, &n, 0); +// +// If you load LDR images through this interface, those images will +// be promoted to floating point values, run through the inverse of +// constants corresponding to the above: +// +// stbi_ldr_to_hdr_scale(1.0f); +// stbi_ldr_to_hdr_gamma(2.2f); +// +// Finally, given a filename (or an open file or memory block--see header +// file for details) containing image data, you can query for the "most +// appropriate" interface to use (that is, whether the image is HDR or +// not), using: +// +// stbi_is_hdr(char *filename); +// +// =========================================================================== +// +// iPhone PNG support: +// +// We optionally support converting iPhone-formatted PNGs (which store +// premultiplied BGRA) back to RGB, even though they're internally encoded +// differently. To enable this conversion, call +// stbi_convert_iphone_png_to_rgb(1). +// +// Call stbi_set_unpremultiply_on_load(1) as well to force a divide per +// pixel to remove any premultiplied alpha *only* if the image file explicitly +// says there's premultiplied data (currently only happens in iPhone images, +// and only if iPhone convert-to-rgb processing is on). +// +// =========================================================================== +// +// ADDITIONAL CONFIGURATION +// +// - You can suppress implementation of any of the decoders to reduce +// your code footprint by #defining one or more of the following +// symbols before creating the implementation. +// +// STBI_NO_JPEG +// STBI_NO_PNG +// STBI_NO_BMP +// STBI_NO_PSD +// STBI_NO_TGA +// STBI_NO_GIF +// STBI_NO_HDR +// STBI_NO_PIC +// STBI_NO_PNM (.ppm and .pgm) +// +// - You can request *only* certain decoders and suppress all other ones +// (this will be more forward-compatible, as addition of new decoders +// doesn't require you to disable them explicitly): +// +// STBI_ONLY_JPEG +// STBI_ONLY_PNG +// STBI_ONLY_BMP +// STBI_ONLY_PSD +// STBI_ONLY_TGA +// STBI_ONLY_GIF +// STBI_ONLY_HDR +// STBI_ONLY_PIC +// STBI_ONLY_PNM (.ppm and .pgm) +// +// - If you use STBI_NO_PNG (or _ONLY_ without PNG), and you still +// want the zlib decoder to be available, #define STBI_SUPPORT_ZLIB +// +// - If you define STBI_MAX_DIMENSIONS, stb_image will reject images greater +// than that size (in either width or height) without further processing. +// This is to let programs in the wild set an upper bound to prevent +// denial-of-service attacks on untrusted data, as one could generate a +// valid image of gigantic dimensions and force stb_image to allocate a +// huge block of memory and spend disproportionate time decoding it. By +// default this is set to (1 << 24), which is 16777216, but that's still +// very big. + +#ifndef STBI_NO_STDIO +#include +#endif // STBI_NO_STDIO + +#define STBI_VERSION 1 + +enum +{ + STBI_default = 0, // only used for desired_channels + + STBI_grey = 1, + STBI_grey_alpha = 2, + STBI_rgb = 3, + STBI_rgb_alpha = 4 +}; + +#include +typedef unsigned char stbi_uc; +typedef unsigned short stbi_us; + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef STBIDEF +#ifdef STB_IMAGE_STATIC +#define STBIDEF static +#else +#define STBIDEF extern +#endif +#endif + +////////////////////////////////////////////////////////////////////////////// +// +// PRIMARY API - works on images of any type +// + +// +// load image by filename, open file, or memory buffer +// + +typedef struct +{ + int (*read) (void *user,char *data,int size); // fill 'data' with 'size' bytes. return number of bytes actually read + void (*skip) (void *user,int n); // skip the next 'n' bytes, or 'unget' the last -n bytes if negative + int (*eof) (void *user); // returns nonzero if we are at end of file/data +} stbi_io_callbacks; + +//////////////////////////////////// +// +// 8-bits-per-channel interface +// + +STBIDEF stbi_uc *stbi_load_from_memory (stbi_uc const *buffer, int len , int *x, int *y, int *channels_in_file, int desired_channels); +STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk , void *user, int *x, int *y, int *channels_in_file, int desired_channels); + +#ifndef STBI_NO_STDIO +STBIDEF stbi_uc *stbi_load (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels); +STBIDEF stbi_uc *stbi_load_from_file (FILE *f, int *x, int *y, int *channels_in_file, int desired_channels); +// for stbi_load_from_file, file pointer is left pointing immediately after image +#endif + +#ifndef STBI_NO_GIF +STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp); +#endif + +#ifdef STBI_WINDOWS_UTF8 +STBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input); +#endif + +//////////////////////////////////// +// +// 16-bits-per-channel interface +// + +STBIDEF stbi_us *stbi_load_16_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels); +STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels); + +#ifndef STBI_NO_STDIO +STBIDEF stbi_us *stbi_load_16 (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels); +STBIDEF stbi_us *stbi_load_from_file_16(FILE *f, int *x, int *y, int *channels_in_file, int desired_channels); +#endif + +//////////////////////////////////// +// +// float-per-channel interface +// +#ifndef STBI_NO_LINEAR + STBIDEF float *stbi_loadf_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels); + STBIDEF float *stbi_loadf_from_callbacks (stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels); + + #ifndef STBI_NO_STDIO + STBIDEF float *stbi_loadf (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels); + STBIDEF float *stbi_loadf_from_file (FILE *f, int *x, int *y, int *channels_in_file, int desired_channels); + #endif +#endif + +#ifndef STBI_NO_HDR + STBIDEF void stbi_hdr_to_ldr_gamma(float gamma); + STBIDEF void stbi_hdr_to_ldr_scale(float scale); +#endif // STBI_NO_HDR + +#ifndef STBI_NO_LINEAR + STBIDEF void stbi_ldr_to_hdr_gamma(float gamma); + STBIDEF void stbi_ldr_to_hdr_scale(float scale); +#endif // STBI_NO_LINEAR + +// stbi_is_hdr is always defined, but always returns false if STBI_NO_HDR +STBIDEF int stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user); +STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len); +#ifndef STBI_NO_STDIO +STBIDEF int stbi_is_hdr (char const *filename); +STBIDEF int stbi_is_hdr_from_file(FILE *f); +#endif // STBI_NO_STDIO + + +// get a VERY brief reason for failure +// on most compilers (and ALL modern mainstream compilers) this is threadsafe +STBIDEF const char *stbi_failure_reason (void); + +// free the loaded image -- this is just free() +STBIDEF void stbi_image_free (void *retval_from_stbi_load); + +// get image dimensions & components without fully decoding +STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp); +STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp); +STBIDEF int stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len); +STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *clbk, void *user); + +#ifndef STBI_NO_STDIO +STBIDEF int stbi_info (char const *filename, int *x, int *y, int *comp); +STBIDEF int stbi_info_from_file (FILE *f, int *x, int *y, int *comp); +STBIDEF int stbi_is_16_bit (char const *filename); +STBIDEF int stbi_is_16_bit_from_file(FILE *f); +#endif + + + +// for image formats that explicitly notate that they have premultiplied alpha, +// we just return the colors as stored in the file. set this flag to force +// unpremultiplication. results are undefined if the unpremultiply overflow. +STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply); + +// indicate whether we should process iphone images back to canonical format, +// or just pass them through "as-is" +STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert); + +// flip the image vertically, so the first pixel in the output array is the bottom left +STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip); + +// as above, but only applies to images loaded on the thread that calls the function +// this function is only available if your compiler supports thread-local variables; +// calling it will fail to link if your compiler doesn't +STBIDEF void stbi_set_unpremultiply_on_load_thread(int flag_true_if_should_unpremultiply); +STBIDEF void stbi_convert_iphone_png_to_rgb_thread(int flag_true_if_should_convert); +STBIDEF void stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_flip); + +// ZLIB client - used by PNG, available for other purposes + +STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen); +STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header); +STBIDEF char *stbi_zlib_decode_malloc(const char *buffer, int len, int *outlen); +STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, const char *ibuffer, int ilen); + +STBIDEF char *stbi_zlib_decode_noheader_malloc(const char *buffer, int len, int *outlen); +STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen); + + +#ifdef __cplusplus +} +#endif + +// +// +//// end header file ///////////////////////////////////////////////////// +#endif // STBI_INCLUDE_STB_IMAGE_H + +#ifdef STB_IMAGE_IMPLEMENTATION + +#if defined(STBI_ONLY_JPEG) || defined(STBI_ONLY_PNG) || defined(STBI_ONLY_BMP) \ + || defined(STBI_ONLY_TGA) || defined(STBI_ONLY_GIF) || defined(STBI_ONLY_PSD) \ + || defined(STBI_ONLY_HDR) || defined(STBI_ONLY_PIC) || defined(STBI_ONLY_PNM) \ + || defined(STBI_ONLY_ZLIB) + #ifndef STBI_ONLY_JPEG + #define STBI_NO_JPEG + #endif + #ifndef STBI_ONLY_PNG + #define STBI_NO_PNG + #endif + #ifndef STBI_ONLY_BMP + #define STBI_NO_BMP + #endif + #ifndef STBI_ONLY_PSD + #define STBI_NO_PSD + #endif + #ifndef STBI_ONLY_TGA + #define STBI_NO_TGA + #endif + #ifndef STBI_ONLY_GIF + #define STBI_NO_GIF + #endif + #ifndef STBI_ONLY_HDR + #define STBI_NO_HDR + #endif + #ifndef STBI_ONLY_PIC + #define STBI_NO_PIC + #endif + #ifndef STBI_ONLY_PNM + #define STBI_NO_PNM + #endif +#endif + +#if defined(STBI_NO_PNG) && !defined(STBI_SUPPORT_ZLIB) && !defined(STBI_NO_ZLIB) +#define STBI_NO_ZLIB +#endif + + +#include +#include // ptrdiff_t on osx +#include +#include +#include + +#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) +#include // ldexp, pow +#endif + +#ifndef STBI_NO_STDIO +#include +#endif + +#ifndef STBI_ASSERT +#include +#define STBI_ASSERT(x) assert(x) +#endif + +#ifdef __cplusplus +#define STBI_EXTERN extern "C" +#else +#define STBI_EXTERN extern +#endif + + +#ifndef _MSC_VER + #ifdef __cplusplus + #define stbi_inline inline + #else + #define stbi_inline + #endif +#else + #define stbi_inline __forceinline +#endif + +#ifndef STBI_NO_THREAD_LOCALS + #if defined(__cplusplus) && __cplusplus >= 201103L + #define STBI_THREAD_LOCAL thread_local + #elif defined(__GNUC__) && __GNUC__ < 5 + #define STBI_THREAD_LOCAL __thread + #elif defined(_MSC_VER) + #define STBI_THREAD_LOCAL __declspec(thread) + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L && !defined(__STDC_NO_THREADS__) + #define STBI_THREAD_LOCAL _Thread_local + #endif + + #ifndef STBI_THREAD_LOCAL + #if defined(__GNUC__) + #define STBI_THREAD_LOCAL __thread + #endif + #endif +#endif + +#if defined(_MSC_VER) || defined(__SYMBIAN32__) +typedef unsigned short stbi__uint16; +typedef signed short stbi__int16; +typedef unsigned int stbi__uint32; +typedef signed int stbi__int32; +#else +#include +typedef uint16_t stbi__uint16; +typedef int16_t stbi__int16; +typedef uint32_t stbi__uint32; +typedef int32_t stbi__int32; +#endif + +// should produce compiler error if size is wrong +typedef unsigned char validate_uint32[sizeof(stbi__uint32)==4 ? 1 : -1]; + +#ifdef _MSC_VER +#define STBI_NOTUSED(v) (void)(v) +#else +#define STBI_NOTUSED(v) (void)sizeof(v) +#endif + +#ifdef _MSC_VER +#define STBI_HAS_LROTL +#endif + +#ifdef STBI_HAS_LROTL + #define stbi_lrot(x,y) _lrotl(x,y) +#else + #define stbi_lrot(x,y) (((x) << (y)) | ((x) >> (-(y) & 31))) +#endif + +#if defined(STBI_MALLOC) && defined(STBI_FREE) && (defined(STBI_REALLOC) || defined(STBI_REALLOC_SIZED)) +// ok +#elif !defined(STBI_MALLOC) && !defined(STBI_FREE) && !defined(STBI_REALLOC) && !defined(STBI_REALLOC_SIZED) +// ok +#else +#error "Must define all or none of STBI_MALLOC, STBI_FREE, and STBI_REALLOC (or STBI_REALLOC_SIZED)." +#endif + +#ifndef STBI_MALLOC +#define STBI_MALLOC(sz) malloc(sz) +#define STBI_REALLOC(p,newsz) realloc(p,newsz) +#define STBI_FREE(p) free(p) +#endif + +#ifndef STBI_REALLOC_SIZED +#define STBI_REALLOC_SIZED(p,oldsz,newsz) STBI_REALLOC(p,newsz) +#endif + +// x86/x64 detection +#if defined(__x86_64__) || defined(_M_X64) +#define STBI__X64_TARGET +#elif defined(__i386) || defined(_M_IX86) +#define STBI__X86_TARGET +#endif + +#if defined(__GNUC__) && defined(STBI__X86_TARGET) && !defined(__SSE2__) && !defined(STBI_NO_SIMD) +// gcc doesn't support sse2 intrinsics unless you compile with -msse2, +// which in turn means it gets to use SSE2 everywhere. This is unfortunate, +// but previous attempts to provide the SSE2 functions with runtime +// detection caused numerous issues. The way architecture extensions are +// exposed in GCC/Clang is, sadly, not really suited for one-file libs. +// New behavior: if compiled with -msse2, we use SSE2 without any +// detection; if not, we don't use it at all. +#define STBI_NO_SIMD +#endif + +#if defined(__MINGW32__) && defined(STBI__X86_TARGET) && !defined(STBI_MINGW_ENABLE_SSE2) && !defined(STBI_NO_SIMD) +// Note that __MINGW32__ doesn't actually mean 32-bit, so we have to avoid STBI__X64_TARGET +// +// 32-bit MinGW wants ESP to be 16-byte aligned, but this is not in the +// Windows ABI and VC++ as well as Windows DLLs don't maintain that invariant. +// As a result, enabling SSE2 on 32-bit MinGW is dangerous when not +// simultaneously enabling "-mstackrealign". +// +// See https://github.com/nothings/stb/issues/81 for more information. +// +// So default to no SSE2 on 32-bit MinGW. If you've read this far and added +// -mstackrealign to your build settings, feel free to #define STBI_MINGW_ENABLE_SSE2. +#define STBI_NO_SIMD +#endif + +#if !defined(STBI_NO_SIMD) && (defined(STBI__X86_TARGET) || defined(STBI__X64_TARGET)) +#define STBI_SSE2 +#include + +#ifdef _MSC_VER + +#if _MSC_VER >= 1400 // not VC6 +#include // __cpuid +static int stbi__cpuid3(void) +{ + int info[4]; + __cpuid(info,1); + return info[3]; +} +#else +static int stbi__cpuid3(void) +{ + int res; + __asm { + mov eax,1 + cpuid + mov res,edx + } + return res; +} +#endif + +#define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name + +#if !defined(STBI_NO_JPEG) && defined(STBI_SSE2) +static int stbi__sse2_available(void) +{ + int info3 = stbi__cpuid3(); + return ((info3 >> 26) & 1) != 0; +} +#endif + +#else // assume GCC-style if not VC++ +#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16))) + +#if !defined(STBI_NO_JPEG) && defined(STBI_SSE2) +static int stbi__sse2_available(void) +{ + // If we're even attempting to compile this on GCC/Clang, that means + // -msse2 is on, which means the compiler is allowed to use SSE2 + // instructions at will, and so are we. + return 1; +} +#endif + +#endif +#endif + +// ARM NEON +#if defined(STBI_NO_SIMD) && defined(STBI_NEON) +#undef STBI_NEON +#endif + +#ifdef STBI_NEON +#include +#ifdef _MSC_VER +#define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name +#else +#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16))) +#endif +#endif + +#ifndef STBI_SIMD_ALIGN +#define STBI_SIMD_ALIGN(type, name) type name +#endif + +#ifndef STBI_MAX_DIMENSIONS +#define STBI_MAX_DIMENSIONS (1 << 24) +#endif + +/////////////////////////////////////////////// +// +// stbi__context struct and start_xxx functions + +// stbi__context structure is our basic context used by all images, so it +// contains all the IO context, plus some basic image information +typedef struct +{ + stbi__uint32 img_x, img_y; + int img_n, img_out_n; + + stbi_io_callbacks io; + void *io_user_data; + + int read_from_callbacks; + int buflen; + stbi_uc buffer_start[128]; + int callback_already_read; + + stbi_uc *img_buffer, *img_buffer_end; + stbi_uc *img_buffer_original, *img_buffer_original_end; +} stbi__context; + + +static void stbi__refill_buffer(stbi__context *s); + +// initialize a memory-decode context +static void stbi__start_mem(stbi__context *s, stbi_uc const *buffer, int len) +{ + s->io.read = NULL; + s->read_from_callbacks = 0; + s->callback_already_read = 0; + s->img_buffer = s->img_buffer_original = (stbi_uc *) buffer; + s->img_buffer_end = s->img_buffer_original_end = (stbi_uc *) buffer+len; +} + +// initialize a callback-based context +static void stbi__start_callbacks(stbi__context *s, stbi_io_callbacks *c, void *user) +{ + s->io = *c; + s->io_user_data = user; + s->buflen = sizeof(s->buffer_start); + s->read_from_callbacks = 1; + s->callback_already_read = 0; + s->img_buffer = s->img_buffer_original = s->buffer_start; + stbi__refill_buffer(s); + s->img_buffer_original_end = s->img_buffer_end; +} + +#ifndef STBI_NO_STDIO + +static int stbi__stdio_read(void *user, char *data, int size) +{ + return (int) fread(data,1,size,(FILE*) user); +} + +static void stbi__stdio_skip(void *user, int n) +{ + int ch; + fseek((FILE*) user, n, SEEK_CUR); + ch = fgetc((FILE*) user); /* have to read a byte to reset feof()'s flag */ + if (ch != EOF) { + ungetc(ch, (FILE *) user); /* push byte back onto stream if valid. */ + } +} + +static int stbi__stdio_eof(void *user) +{ + return feof((FILE*) user) || ferror((FILE *) user); +} + +static stbi_io_callbacks stbi__stdio_callbacks = +{ + stbi__stdio_read, + stbi__stdio_skip, + stbi__stdio_eof, +}; + +static void stbi__start_file(stbi__context *s, FILE *f) +{ + stbi__start_callbacks(s, &stbi__stdio_callbacks, (void *) f); +} + +//static void stop_file(stbi__context *s) { } + +#endif // !STBI_NO_STDIO + +static void stbi__rewind(stbi__context *s) +{ + // conceptually rewind SHOULD rewind to the beginning of the stream, + // but we just rewind to the beginning of the initial buffer, because + // we only use it after doing 'test', which only ever looks at at most 92 bytes + s->img_buffer = s->img_buffer_original; + s->img_buffer_end = s->img_buffer_original_end; +} + +enum +{ + STBI_ORDER_RGB, + STBI_ORDER_BGR +}; + +typedef struct +{ + int bits_per_channel; + int num_channels; + int channel_order; +} stbi__result_info; + +#ifndef STBI_NO_JPEG +static int stbi__jpeg_test(stbi__context *s); +static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PNG +static int stbi__png_test(stbi__context *s); +static void *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp); +static int stbi__png_is16(stbi__context *s); +#endif + +#ifndef STBI_NO_BMP +static int stbi__bmp_test(stbi__context *s); +static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_TGA +static int stbi__tga_test(stbi__context *s); +static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PSD +static int stbi__psd_test(stbi__context *s); +static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc); +static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp); +static int stbi__psd_is16(stbi__context *s); +#endif + +#ifndef STBI_NO_HDR +static int stbi__hdr_test(stbi__context *s); +static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PIC +static int stbi__pic_test(stbi__context *s); +static void *stbi__pic_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_GIF +static int stbi__gif_test(stbi__context *s); +static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, int req_comp); +static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PNM +static int stbi__pnm_test(stbi__context *s); +static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp); +static int stbi__pnm_is16(stbi__context *s); +#endif + +static +#ifdef STBI_THREAD_LOCAL +STBI_THREAD_LOCAL +#endif +const char *stbi__g_failure_reason; + +STBIDEF const char *stbi_failure_reason(void) +{ + return stbi__g_failure_reason; +} + +#ifndef STBI_NO_FAILURE_STRINGS +static int stbi__err(const char *str) +{ + stbi__g_failure_reason = str; + return 0; +} +#endif + +static void *stbi__malloc(size_t size) +{ + return STBI_MALLOC(size); +} + +// stb_image uses ints pervasively, including for offset calculations. +// therefore the largest decoded image size we can support with the +// current code, even on 64-bit targets, is INT_MAX. this is not a +// significant limitation for the intended use case. +// +// we do, however, need to make sure our size calculations don't +// overflow. hence a few helper functions for size calculations that +// multiply integers together, making sure that they're non-negative +// and no overflow occurs. + +// return 1 if the sum is valid, 0 on overflow. +// negative terms are considered invalid. +static int stbi__addsizes_valid(int a, int b) +{ + if (b < 0) return 0; + // now 0 <= b <= INT_MAX, hence also + // 0 <= INT_MAX - b <= INTMAX. + // And "a + b <= INT_MAX" (which might overflow) is the + // same as a <= INT_MAX - b (no overflow) + return a <= INT_MAX - b; +} + +// returns 1 if the product is valid, 0 on overflow. +// negative factors are considered invalid. +static int stbi__mul2sizes_valid(int a, int b) +{ + if (a < 0 || b < 0) return 0; + if (b == 0) return 1; // mul-by-0 is always safe + // portable way to check for no overflows in a*b + return a <= INT_MAX/b; +} + +#if !defined(STBI_NO_JPEG) || !defined(STBI_NO_PNG) || !defined(STBI_NO_TGA) || !defined(STBI_NO_HDR) +// returns 1 if "a*b + add" has no negative terms/factors and doesn't overflow +static int stbi__mad2sizes_valid(int a, int b, int add) +{ + return stbi__mul2sizes_valid(a, b) && stbi__addsizes_valid(a*b, add); +} +#endif + +// returns 1 if "a*b*c + add" has no negative terms/factors and doesn't overflow +static int stbi__mad3sizes_valid(int a, int b, int c, int add) +{ + return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) && + stbi__addsizes_valid(a*b*c, add); +} + +// returns 1 if "a*b*c*d + add" has no negative terms/factors and doesn't overflow +#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) || !defined(STBI_NO_PNM) +static int stbi__mad4sizes_valid(int a, int b, int c, int d, int add) +{ + return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) && + stbi__mul2sizes_valid(a*b*c, d) && stbi__addsizes_valid(a*b*c*d, add); +} +#endif + +#if !defined(STBI_NO_JPEG) || !defined(STBI_NO_PNG) || !defined(STBI_NO_TGA) || !defined(STBI_NO_HDR) +// mallocs with size overflow checking +static void *stbi__malloc_mad2(int a, int b, int add) +{ + if (!stbi__mad2sizes_valid(a, b, add)) return NULL; + return stbi__malloc(a*b + add); +} +#endif + +static void *stbi__malloc_mad3(int a, int b, int c, int add) +{ + if (!stbi__mad3sizes_valid(a, b, c, add)) return NULL; + return stbi__malloc(a*b*c + add); +} + +#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) || !defined(STBI_NO_PNM) +static void *stbi__malloc_mad4(int a, int b, int c, int d, int add) +{ + if (!stbi__mad4sizes_valid(a, b, c, d, add)) return NULL; + return stbi__malloc(a*b*c*d + add); +} +#endif + +// returns 1 if the sum of two signed ints is valid (between -2^31 and 2^31-1 inclusive), 0 on overflow. +static int stbi__addints_valid(int a, int b) +{ + if ((a >= 0) != (b >= 0)) return 1; // a and b have different signs, so no overflow + if (a < 0 && b < 0) return a >= INT_MIN - b; // same as a + b >= INT_MIN; INT_MIN - b cannot overflow since b < 0. + return a <= INT_MAX - b; +} + +// returns 1 if the product of two ints fits in a signed short, 0 on overflow. +static int stbi__mul2shorts_valid(int a, int b) +{ + if (b == 0 || b == -1) return 1; // multiplication by 0 is always 0; check for -1 so SHRT_MIN/b doesn't overflow + if ((a >= 0) == (b >= 0)) return a <= SHRT_MAX/b; // product is positive, so similar to mul2sizes_valid + if (b < 0) return a <= SHRT_MIN / b; // same as a * b >= SHRT_MIN + return a >= SHRT_MIN / b; +} + +// stbi__err - error +// stbi__errpf - error returning pointer to float +// stbi__errpuc - error returning pointer to unsigned char + +#ifdef STBI_NO_FAILURE_STRINGS + #define stbi__err(x,y) 0 +#elif defined(STBI_FAILURE_USERMSG) + #define stbi__err(x,y) stbi__err(y) +#else + #define stbi__err(x,y) stbi__err(x) +#endif + +#define stbi__errpf(x,y) ((float *)(size_t) (stbi__err(x,y)?NULL:NULL)) +#define stbi__errpuc(x,y) ((unsigned char *)(size_t) (stbi__err(x,y)?NULL:NULL)) + +STBIDEF void stbi_image_free(void *retval_from_stbi_load) +{ + STBI_FREE(retval_from_stbi_load); +} + +#ifndef STBI_NO_LINEAR +static float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp); +#endif + +#ifndef STBI_NO_HDR +static stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp); +#endif + +static int stbi__vertically_flip_on_load_global = 0; + +STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip) +{ + stbi__vertically_flip_on_load_global = flag_true_if_should_flip; +} + +#ifndef STBI_THREAD_LOCAL +#define stbi__vertically_flip_on_load stbi__vertically_flip_on_load_global +#else +static STBI_THREAD_LOCAL int stbi__vertically_flip_on_load_local, stbi__vertically_flip_on_load_set; + +STBIDEF void stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_flip) +{ + stbi__vertically_flip_on_load_local = flag_true_if_should_flip; + stbi__vertically_flip_on_load_set = 1; +} + +#define stbi__vertically_flip_on_load (stbi__vertically_flip_on_load_set \ + ? stbi__vertically_flip_on_load_local \ + : stbi__vertically_flip_on_load_global) +#endif // STBI_THREAD_LOCAL + +static void *stbi__load_main(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc) +{ + memset(ri, 0, sizeof(*ri)); // make sure it's initialized if we add new fields + ri->bits_per_channel = 8; // default is 8 so most paths don't have to be changed + ri->channel_order = STBI_ORDER_RGB; // all current input & output are this, but this is here so we can add BGR order + ri->num_channels = 0; + + // test the formats with a very explicit header first (at least a FOURCC + // or distinctive magic number first) + #ifndef STBI_NO_PNG + if (stbi__png_test(s)) return stbi__png_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_BMP + if (stbi__bmp_test(s)) return stbi__bmp_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_GIF + if (stbi__gif_test(s)) return stbi__gif_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_PSD + if (stbi__psd_test(s)) return stbi__psd_load(s,x,y,comp,req_comp, ri, bpc); + #else + STBI_NOTUSED(bpc); + #endif + #ifndef STBI_NO_PIC + if (stbi__pic_test(s)) return stbi__pic_load(s,x,y,comp,req_comp, ri); + #endif + + // then the formats that can end up attempting to load with just 1 or 2 + // bytes matching expectations; these are prone to false positives, so + // try them later + #ifndef STBI_NO_JPEG + if (stbi__jpeg_test(s)) return stbi__jpeg_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_PNM + if (stbi__pnm_test(s)) return stbi__pnm_load(s,x,y,comp,req_comp, ri); + #endif + + #ifndef STBI_NO_HDR + if (stbi__hdr_test(s)) { + float *hdr = stbi__hdr_load(s, x,y,comp,req_comp, ri); + return stbi__hdr_to_ldr(hdr, *x, *y, req_comp ? req_comp : *comp); + } + #endif + + #ifndef STBI_NO_TGA + // test tga last because it's a crappy test! + if (stbi__tga_test(s)) + return stbi__tga_load(s,x,y,comp,req_comp, ri); + #endif + + return stbi__errpuc("unknown image type", "Image not of any known type, or corrupt"); +} + +static stbi_uc *stbi__convert_16_to_8(stbi__uint16 *orig, int w, int h, int channels) +{ + int i; + int img_len = w * h * channels; + stbi_uc *reduced; + + reduced = (stbi_uc *) stbi__malloc(img_len); + if (reduced == NULL) return stbi__errpuc("outofmem", "Out of memory"); + + for (i = 0; i < img_len; ++i) + reduced[i] = (stbi_uc)((orig[i] >> 8) & 0xFF); // top half of each byte is sufficient approx of 16->8 bit scaling + + STBI_FREE(orig); + return reduced; +} + +static stbi__uint16 *stbi__convert_8_to_16(stbi_uc *orig, int w, int h, int channels) +{ + int i; + int img_len = w * h * channels; + stbi__uint16 *enlarged; + + enlarged = (stbi__uint16 *) stbi__malloc(img_len*2); + if (enlarged == NULL) return (stbi__uint16 *) stbi__errpuc("outofmem", "Out of memory"); + + for (i = 0; i < img_len; ++i) + enlarged[i] = (stbi__uint16)((orig[i] << 8) + orig[i]); // replicate to high and low byte, maps 0->0, 255->0xffff + + STBI_FREE(orig); + return enlarged; +} + +static void stbi__vertical_flip(void *image, int w, int h, int bytes_per_pixel) +{ + int row; + size_t bytes_per_row = (size_t)w * bytes_per_pixel; + stbi_uc temp[2048]; + stbi_uc *bytes = (stbi_uc *)image; + + for (row = 0; row < (h>>1); row++) { + stbi_uc *row0 = bytes + row*bytes_per_row; + stbi_uc *row1 = bytes + (h - row - 1)*bytes_per_row; + // swap row0 with row1 + size_t bytes_left = bytes_per_row; + while (bytes_left) { + size_t bytes_copy = (bytes_left < sizeof(temp)) ? bytes_left : sizeof(temp); + memcpy(temp, row0, bytes_copy); + memcpy(row0, row1, bytes_copy); + memcpy(row1, temp, bytes_copy); + row0 += bytes_copy; + row1 += bytes_copy; + bytes_left -= bytes_copy; + } + } +} + +#ifndef STBI_NO_GIF +static void stbi__vertical_flip_slices(void *image, int w, int h, int z, int bytes_per_pixel) +{ + int slice; + int slice_size = w * h * bytes_per_pixel; + + stbi_uc *bytes = (stbi_uc *)image; + for (slice = 0; slice < z; ++slice) { + stbi__vertical_flip(bytes, w, h, bytes_per_pixel); + bytes += slice_size; + } +} +#endif + +static unsigned char *stbi__load_and_postprocess_8bit(stbi__context *s, int *x, int *y, int *comp, int req_comp) +{ + stbi__result_info ri; + void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 8); + + if (result == NULL) + return NULL; + + // it is the responsibility of the loaders to make sure we get either 8 or 16 bit. + STBI_ASSERT(ri.bits_per_channel == 8 || ri.bits_per_channel == 16); + + if (ri.bits_per_channel != 8) { + result = stbi__convert_16_to_8((stbi__uint16 *) result, *x, *y, req_comp == 0 ? *comp : req_comp); + ri.bits_per_channel = 8; + } + + // @TODO: move stbi__convert_format to here + + if (stbi__vertically_flip_on_load) { + int channels = req_comp ? req_comp : *comp; + stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi_uc)); + } + + return (unsigned char *) result; +} + +static stbi__uint16 *stbi__load_and_postprocess_16bit(stbi__context *s, int *x, int *y, int *comp, int req_comp) +{ + stbi__result_info ri; + void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 16); + + if (result == NULL) + return NULL; + + // it is the responsibility of the loaders to make sure we get either 8 or 16 bit. + STBI_ASSERT(ri.bits_per_channel == 8 || ri.bits_per_channel == 16); + + if (ri.bits_per_channel != 16) { + result = stbi__convert_8_to_16((stbi_uc *) result, *x, *y, req_comp == 0 ? *comp : req_comp); + ri.bits_per_channel = 16; + } + + // @TODO: move stbi__convert_format16 to here + // @TODO: special case RGB-to-Y (and RGBA-to-YA) for 8-bit-to-16-bit case to keep more precision + + if (stbi__vertically_flip_on_load) { + int channels = req_comp ? req_comp : *comp; + stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi__uint16)); + } + + return (stbi__uint16 *) result; +} + +#if !defined(STBI_NO_HDR) && !defined(STBI_NO_LINEAR) +static void stbi__float_postprocess(float *result, int *x, int *y, int *comp, int req_comp) +{ + if (stbi__vertically_flip_on_load && result != NULL) { + int channels = req_comp ? req_comp : *comp; + stbi__vertical_flip(result, *x, *y, channels * sizeof(float)); + } +} +#endif + +#ifndef STBI_NO_STDIO + +#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8) +STBI_EXTERN __declspec(dllimport) int __stdcall MultiByteToWideChar(unsigned int cp, unsigned long flags, const char *str, int cbmb, wchar_t *widestr, int cchwide); +STBI_EXTERN __declspec(dllimport) int __stdcall WideCharToMultiByte(unsigned int cp, unsigned long flags, const wchar_t *widestr, int cchwide, char *str, int cbmb, const char *defchar, int *used_default); +#endif + +#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8) +STBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input) +{ + return WideCharToMultiByte(65001 /* UTF8 */, 0, input, -1, buffer, (int) bufferlen, NULL, NULL); +} +#endif + +static FILE *stbi__fopen(char const *filename, char const *mode) +{ + FILE *f; +#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8) + wchar_t wMode[64]; + wchar_t wFilename[1024]; + if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, filename, -1, wFilename, sizeof(wFilename)/sizeof(*wFilename))) + return 0; + + if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, mode, -1, wMode, sizeof(wMode)/sizeof(*wMode))) + return 0; + +#if defined(_MSC_VER) && _MSC_VER >= 1400 + if (0 != _wfopen_s(&f, wFilename, wMode)) + f = 0; +#else + f = _wfopen(wFilename, wMode); +#endif + +#elif defined(_MSC_VER) && _MSC_VER >= 1400 + if (0 != fopen_s(&f, filename, mode)) + f=0; +#else + f = fopen(filename, mode); +#endif + return f; +} + + +STBIDEF stbi_uc *stbi_load(char const *filename, int *x, int *y, int *comp, int req_comp) +{ + FILE *f = stbi__fopen(filename, "rb"); + unsigned char *result; + if (!f) return stbi__errpuc("can't fopen", "Unable to open file"); + result = stbi_load_from_file(f,x,y,comp,req_comp); + fclose(f); + return result; +} + +STBIDEF stbi_uc *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp) +{ + unsigned char *result; + stbi__context s; + stbi__start_file(&s,f); + result = stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp); + if (result) { + // need to 'unget' all the characters in the IO buffer + fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR); + } + return result; +} + +STBIDEF stbi__uint16 *stbi_load_from_file_16(FILE *f, int *x, int *y, int *comp, int req_comp) +{ + stbi__uint16 *result; + stbi__context s; + stbi__start_file(&s,f); + result = stbi__load_and_postprocess_16bit(&s,x,y,comp,req_comp); + if (result) { + // need to 'unget' all the characters in the IO buffer + fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR); + } + return result; +} + +STBIDEF stbi_us *stbi_load_16(char const *filename, int *x, int *y, int *comp, int req_comp) +{ + FILE *f = stbi__fopen(filename, "rb"); + stbi__uint16 *result; + if (!f) return (stbi_us *) stbi__errpuc("can't fopen", "Unable to open file"); + result = stbi_load_from_file_16(f,x,y,comp,req_comp); + fclose(f); + return result; +} + + +#endif //!STBI_NO_STDIO + +STBIDEF stbi_us *stbi_load_16_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels); +} + +STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *)clbk, user); + return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels); +} + +STBIDEF stbi_uc *stbi_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp); +} + +STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user); + return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp); +} + +#ifndef STBI_NO_GIF +STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp) +{ + unsigned char *result; + stbi__context s; + stbi__start_mem(&s,buffer,len); + + result = (unsigned char*) stbi__load_gif_main(&s, delays, x, y, z, comp, req_comp); + if (stbi__vertically_flip_on_load) { + stbi__vertical_flip_slices( result, *x, *y, *z, *comp ); + } + + return result; +} +#endif + +#ifndef STBI_NO_LINEAR +static float *stbi__loadf_main(stbi__context *s, int *x, int *y, int *comp, int req_comp) +{ + unsigned char *data; + #ifndef STBI_NO_HDR + if (stbi__hdr_test(s)) { + stbi__result_info ri; + float *hdr_data = stbi__hdr_load(s,x,y,comp,req_comp, &ri); + if (hdr_data) + stbi__float_postprocess(hdr_data,x,y,comp,req_comp); + return hdr_data; + } + #endif + data = stbi__load_and_postprocess_8bit(s, x, y, comp, req_comp); + if (data) + return stbi__ldr_to_hdr(data, *x, *y, req_comp ? req_comp : *comp); + return stbi__errpf("unknown image type", "Image not of any known type, or corrupt"); +} + +STBIDEF float *stbi_loadf_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__loadf_main(&s,x,y,comp,req_comp); +} + +STBIDEF float *stbi_loadf_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user); + return stbi__loadf_main(&s,x,y,comp,req_comp); +} + +#ifndef STBI_NO_STDIO +STBIDEF float *stbi_loadf(char const *filename, int *x, int *y, int *comp, int req_comp) +{ + float *result; + FILE *f = stbi__fopen(filename, "rb"); + if (!f) return stbi__errpf("can't fopen", "Unable to open file"); + result = stbi_loadf_from_file(f,x,y,comp,req_comp); + fclose(f); + return result; +} + +STBIDEF float *stbi_loadf_from_file(FILE *f, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_file(&s,f); + return stbi__loadf_main(&s,x,y,comp,req_comp); +} +#endif // !STBI_NO_STDIO + +#endif // !STBI_NO_LINEAR + +// these is-hdr-or-not is defined independent of whether STBI_NO_LINEAR is +// defined, for API simplicity; if STBI_NO_LINEAR is defined, it always +// reports false! + +STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len) +{ + #ifndef STBI_NO_HDR + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__hdr_test(&s); + #else + STBI_NOTUSED(buffer); + STBI_NOTUSED(len); + return 0; + #endif +} + +#ifndef STBI_NO_STDIO +STBIDEF int stbi_is_hdr (char const *filename) +{ + FILE *f = stbi__fopen(filename, "rb"); + int result=0; + if (f) { + result = stbi_is_hdr_from_file(f); + fclose(f); + } + return result; +} + +STBIDEF int stbi_is_hdr_from_file(FILE *f) +{ + #ifndef STBI_NO_HDR + long pos = ftell(f); + int res; + stbi__context s; + stbi__start_file(&s,f); + res = stbi__hdr_test(&s); + fseek(f, pos, SEEK_SET); + return res; + #else + STBI_NOTUSED(f); + return 0; + #endif +} +#endif // !STBI_NO_STDIO + +STBIDEF int stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user) +{ + #ifndef STBI_NO_HDR + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user); + return stbi__hdr_test(&s); + #else + STBI_NOTUSED(clbk); + STBI_NOTUSED(user); + return 0; + #endif +} + +#ifndef STBI_NO_LINEAR +static float stbi__l2h_gamma=2.2f, stbi__l2h_scale=1.0f; + +STBIDEF void stbi_ldr_to_hdr_gamma(float gamma) { stbi__l2h_gamma = gamma; } +STBIDEF void stbi_ldr_to_hdr_scale(float scale) { stbi__l2h_scale = scale; } +#endif + +static float stbi__h2l_gamma_i=1.0f/2.2f, stbi__h2l_scale_i=1.0f; + +STBIDEF void stbi_hdr_to_ldr_gamma(float gamma) { stbi__h2l_gamma_i = 1/gamma; } +STBIDEF void stbi_hdr_to_ldr_scale(float scale) { stbi__h2l_scale_i = 1/scale; } + + +////////////////////////////////////////////////////////////////////////////// +// +// Common code used by all image loaders +// + +enum +{ + STBI__SCAN_load=0, + STBI__SCAN_type, + STBI__SCAN_header +}; + +static void stbi__refill_buffer(stbi__context *s) +{ + int n = (s->io.read)(s->io_user_data,(char*)s->buffer_start,s->buflen); + s->callback_already_read += (int) (s->img_buffer - s->img_buffer_original); + if (n == 0) { + // at end of file, treat same as if from memory, but need to handle case + // where s->img_buffer isn't pointing to safe memory, e.g. 0-byte file + s->read_from_callbacks = 0; + s->img_buffer = s->buffer_start; + s->img_buffer_end = s->buffer_start+1; + *s->img_buffer = 0; + } else { + s->img_buffer = s->buffer_start; + s->img_buffer_end = s->buffer_start + n; + } +} + +stbi_inline static stbi_uc stbi__get8(stbi__context *s) +{ + if (s->img_buffer < s->img_buffer_end) + return *s->img_buffer++; + if (s->read_from_callbacks) { + stbi__refill_buffer(s); + return *s->img_buffer++; + } + return 0; +} + +#if defined(STBI_NO_JPEG) && defined(STBI_NO_HDR) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM) +// nothing +#else +stbi_inline static int stbi__at_eof(stbi__context *s) +{ + if (s->io.read) { + if (!(s->io.eof)(s->io_user_data)) return 0; + // if feof() is true, check if buffer = end + // special case: we've only got the special 0 character at the end + if (s->read_from_callbacks == 0) return 1; + } + + return s->img_buffer >= s->img_buffer_end; +} +#endif + +#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) +// nothing +#else +static void stbi__skip(stbi__context *s, int n) +{ + if (n == 0) return; // already there! + if (n < 0) { + s->img_buffer = s->img_buffer_end; + return; + } + if (s->io.read) { + int blen = (int) (s->img_buffer_end - s->img_buffer); + if (blen < n) { + s->img_buffer = s->img_buffer_end; + (s->io.skip)(s->io_user_data, n - blen); + return; + } + } + s->img_buffer += n; +} +#endif + +#if defined(STBI_NO_PNG) && defined(STBI_NO_TGA) && defined(STBI_NO_HDR) && defined(STBI_NO_PNM) +// nothing +#else +static int stbi__getn(stbi__context *s, stbi_uc *buffer, int n) +{ + if (s->io.read) { + int blen = (int) (s->img_buffer_end - s->img_buffer); + if (blen < n) { + int res, count; + + memcpy(buffer, s->img_buffer, blen); + + count = (s->io.read)(s->io_user_data, (char*) buffer + blen, n - blen); + res = (count == (n-blen)); + s->img_buffer = s->img_buffer_end; + return res; + } + } + + if (s->img_buffer+n <= s->img_buffer_end) { + memcpy(buffer, s->img_buffer, n); + s->img_buffer += n; + return 1; + } else + return 0; +} +#endif + +#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_PSD) && defined(STBI_NO_PIC) +// nothing +#else +static int stbi__get16be(stbi__context *s) +{ + int z = stbi__get8(s); + return (z << 8) + stbi__get8(s); +} +#endif + +#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD) && defined(STBI_NO_PIC) +// nothing +#else +static stbi__uint32 stbi__get32be(stbi__context *s) +{ + stbi__uint32 z = stbi__get16be(s); + return (z << 16) + stbi__get16be(s); +} +#endif + +#if defined(STBI_NO_BMP) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) +// nothing +#else +static int stbi__get16le(stbi__context *s) +{ + int z = stbi__get8(s); + return z + (stbi__get8(s) << 8); +} +#endif + +#ifndef STBI_NO_BMP +static stbi__uint32 stbi__get32le(stbi__context *s) +{ + stbi__uint32 z = stbi__get16le(s); + z += (stbi__uint32)stbi__get16le(s) << 16; + return z; +} +#endif + +#define STBI__BYTECAST(x) ((stbi_uc) ((x) & 255)) // truncate int to byte without warnings + +#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM) +// nothing +#else +////////////////////////////////////////////////////////////////////////////// +// +// generic converter from built-in img_n to req_comp +// individual types do this automatically as much as possible (e.g. jpeg +// does all cases internally since it needs to colorspace convert anyway, +// and it never has alpha, so very few cases ). png can automatically +// interleave an alpha=255 channel, but falls back to this for other cases +// +// assume data buffer is malloced, so malloc a new one and free that one +// only failure mode is malloc failing + +static stbi_uc stbi__compute_y(int r, int g, int b) +{ + return (stbi_uc) (((r*77) + (g*150) + (29*b)) >> 8); +} +#endif + +#if defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM) +// nothing +#else +static unsigned char *stbi__convert_format(unsigned char *data, int img_n, int req_comp, unsigned int x, unsigned int y) +{ + int i,j; + unsigned char *good; + + if (req_comp == img_n) return data; + STBI_ASSERT(req_comp >= 1 && req_comp <= 4); + + good = (unsigned char *) stbi__malloc_mad3(req_comp, x, y, 0); + if (good == NULL) { + STBI_FREE(data); + return stbi__errpuc("outofmem", "Out of memory"); + } + + for (j=0; j < (int) y; ++j) { + unsigned char *src = data + j * x * img_n ; + unsigned char *dest = good + j * x * req_comp; + + #define STBI__COMBO(a,b) ((a)*8+(b)) + #define STBI__CASE(a,b) case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b) + // convert source image with img_n components to one with req_comp components; + // avoid switch per pixel, so use switch per scanline and massive macros + switch (STBI__COMBO(img_n, req_comp)) { + STBI__CASE(1,2) { dest[0]=src[0]; dest[1]=255; } break; + STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; + STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=255; } break; + STBI__CASE(2,1) { dest[0]=src[0]; } break; + STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; + STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=src[1]; } break; + STBI__CASE(3,4) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];dest[3]=255; } break; + STBI__CASE(3,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); } break; + STBI__CASE(3,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); dest[1] = 255; } break; + STBI__CASE(4,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); } break; + STBI__CASE(4,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); dest[1] = src[3]; } break; + STBI__CASE(4,3) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2]; } break; + default: STBI_ASSERT(0); STBI_FREE(data); STBI_FREE(good); return stbi__errpuc("unsupported", "Unsupported format conversion"); + } + #undef STBI__CASE + } + + STBI_FREE(data); + return good; +} +#endif + +#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD) +// nothing +#else +static stbi__uint16 stbi__compute_y_16(int r, int g, int b) +{ + return (stbi__uint16) (((r*77) + (g*150) + (29*b)) >> 8); +} +#endif + +#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD) +// nothing +#else +static stbi__uint16 *stbi__convert_format16(stbi__uint16 *data, int img_n, int req_comp, unsigned int x, unsigned int y) +{ + int i,j; + stbi__uint16 *good; + + if (req_comp == img_n) return data; + STBI_ASSERT(req_comp >= 1 && req_comp <= 4); + + good = (stbi__uint16 *) stbi__malloc(req_comp * x * y * 2); + if (good == NULL) { + STBI_FREE(data); + return (stbi__uint16 *) stbi__errpuc("outofmem", "Out of memory"); + } + + for (j=0; j < (int) y; ++j) { + stbi__uint16 *src = data + j * x * img_n ; + stbi__uint16 *dest = good + j * x * req_comp; + + #define STBI__COMBO(a,b) ((a)*8+(b)) + #define STBI__CASE(a,b) case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b) + // convert source image with img_n components to one with req_comp components; + // avoid switch per pixel, so use switch per scanline and massive macros + switch (STBI__COMBO(img_n, req_comp)) { + STBI__CASE(1,2) { dest[0]=src[0]; dest[1]=0xffff; } break; + STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; + STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=0xffff; } break; + STBI__CASE(2,1) { dest[0]=src[0]; } break; + STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; + STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=src[1]; } break; + STBI__CASE(3,4) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];dest[3]=0xffff; } break; + STBI__CASE(3,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); } break; + STBI__CASE(3,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); dest[1] = 0xffff; } break; + STBI__CASE(4,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); } break; + STBI__CASE(4,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); dest[1] = src[3]; } break; + STBI__CASE(4,3) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2]; } break; + default: STBI_ASSERT(0); STBI_FREE(data); STBI_FREE(good); return (stbi__uint16*) stbi__errpuc("unsupported", "Unsupported format conversion"); + } + #undef STBI__CASE + } + + STBI_FREE(data); + return good; +} +#endif + +#ifndef STBI_NO_LINEAR +static float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp) +{ + int i,k,n; + float *output; + if (!data) return NULL; + output = (float *) stbi__malloc_mad4(x, y, comp, sizeof(float), 0); + if (output == NULL) { STBI_FREE(data); return stbi__errpf("outofmem", "Out of memory"); } + // compute number of non-alpha components + if (comp & 1) n = comp; else n = comp-1; + for (i=0; i < x*y; ++i) { + for (k=0; k < n; ++k) { + output[i*comp + k] = (float) (pow(data[i*comp+k]/255.0f, stbi__l2h_gamma) * stbi__l2h_scale); + } + } + if (n < comp) { + for (i=0; i < x*y; ++i) { + output[i*comp + n] = data[i*comp + n]/255.0f; + } + } + STBI_FREE(data); + return output; +} +#endif + +#ifndef STBI_NO_HDR +#define stbi__float2int(x) ((int) (x)) +static stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp) +{ + int i,k,n; + stbi_uc *output; + if (!data) return NULL; + output = (stbi_uc *) stbi__malloc_mad3(x, y, comp, 0); + if (output == NULL) { STBI_FREE(data); return stbi__errpuc("outofmem", "Out of memory"); } + // compute number of non-alpha components + if (comp & 1) n = comp; else n = comp-1; + for (i=0; i < x*y; ++i) { + for (k=0; k < n; ++k) { + float z = (float) pow(data[i*comp+k]*stbi__h2l_scale_i, stbi__h2l_gamma_i) * 255 + 0.5f; + if (z < 0) z = 0; + if (z > 255) z = 255; + output[i*comp + k] = (stbi_uc) stbi__float2int(z); + } + if (k < comp) { + float z = data[i*comp+k] * 255 + 0.5f; + if (z < 0) z = 0; + if (z > 255) z = 255; + output[i*comp + k] = (stbi_uc) stbi__float2int(z); + } + } + STBI_FREE(data); + return output; +} +#endif + +////////////////////////////////////////////////////////////////////////////// +// +// "baseline" JPEG/JFIF decoder +// +// simple implementation +// - doesn't support delayed output of y-dimension +// - simple interface (only one output format: 8-bit interleaved RGB) +// - doesn't try to recover corrupt jpegs +// - doesn't allow partial loading, loading multiple at once +// - still fast on x86 (copying globals into locals doesn't help x86) +// - allocates lots of intermediate memory (full size of all components) +// - non-interleaved case requires this anyway +// - allows good upsampling (see next) +// high-quality +// - upsampled channels are bilinearly interpolated, even across blocks +// - quality integer IDCT derived from IJG's 'slow' +// performance +// - fast huffman; reasonable integer IDCT +// - some SIMD kernels for common paths on targets with SSE2/NEON +// - uses a lot of intermediate memory, could cache poorly + +#ifndef STBI_NO_JPEG + +// huffman decoding acceleration +#define FAST_BITS 9 // larger handles more cases; smaller stomps less cache + +typedef struct +{ + stbi_uc fast[1 << FAST_BITS]; + // weirdly, repacking this into AoS is a 10% speed loss, instead of a win + stbi__uint16 code[256]; + stbi_uc values[256]; + stbi_uc size[257]; + unsigned int maxcode[18]; + int delta[17]; // old 'firstsymbol' - old 'firstcode' +} stbi__huffman; + +typedef struct +{ + stbi__context *s; + stbi__huffman huff_dc[4]; + stbi__huffman huff_ac[4]; + stbi__uint16 dequant[4][64]; + stbi__int16 fast_ac[4][1 << FAST_BITS]; + +// sizes for components, interleaved MCUs + int img_h_max, img_v_max; + int img_mcu_x, img_mcu_y; + int img_mcu_w, img_mcu_h; + +// definition of jpeg image component + struct + { + int id; + int h,v; + int tq; + int hd,ha; + int dc_pred; + + int x,y,w2,h2; + stbi_uc *data; + void *raw_data, *raw_coeff; + stbi_uc *linebuf; + short *coeff; // progressive only + int coeff_w, coeff_h; // number of 8x8 coefficient blocks + } img_comp[4]; + + stbi__uint32 code_buffer; // jpeg entropy-coded buffer + int code_bits; // number of valid bits + unsigned char marker; // marker seen while filling entropy buffer + int nomore; // flag if we saw a marker so must stop + + int progressive; + int spec_start; + int spec_end; + int succ_high; + int succ_low; + int eob_run; + int jfif; + int app14_color_transform; // Adobe APP14 tag + int rgb; + + int scan_n, order[4]; + int restart_interval, todo; + +// kernels + void (*idct_block_kernel)(stbi_uc *out, int out_stride, short data[64]); + void (*YCbCr_to_RGB_kernel)(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step); + stbi_uc *(*resample_row_hv_2_kernel)(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs); +} stbi__jpeg; + +static int stbi__build_huffman(stbi__huffman *h, int *count) +{ + int i,j,k=0; + unsigned int code; + // build size list for each symbol (from JPEG spec) + for (i=0; i < 16; ++i) { + for (j=0; j < count[i]; ++j) { + h->size[k++] = (stbi_uc) (i+1); + if(k >= 257) return stbi__err("bad size list","Corrupt JPEG"); + } + } + h->size[k] = 0; + + // compute actual symbols (from jpeg spec) + code = 0; + k = 0; + for(j=1; j <= 16; ++j) { + // compute delta to add to code to compute symbol id + h->delta[j] = k - code; + if (h->size[k] == j) { + while (h->size[k] == j) + h->code[k++] = (stbi__uint16) (code++); + if (code-1 >= (1u << j)) return stbi__err("bad code lengths","Corrupt JPEG"); + } + // compute largest code + 1 for this size, preshifted as needed later + h->maxcode[j] = code << (16-j); + code <<= 1; + } + h->maxcode[j] = 0xffffffff; + + // build non-spec acceleration table; 255 is flag for not-accelerated + memset(h->fast, 255, 1 << FAST_BITS); + for (i=0; i < k; ++i) { + int s = h->size[i]; + if (s <= FAST_BITS) { + int c = h->code[i] << (FAST_BITS-s); + int m = 1 << (FAST_BITS-s); + for (j=0; j < m; ++j) { + h->fast[c+j] = (stbi_uc) i; + } + } + } + return 1; +} + +// build a table that decodes both magnitude and value of small ACs in +// one go. +static void stbi__build_fast_ac(stbi__int16 *fast_ac, stbi__huffman *h) +{ + int i; + for (i=0; i < (1 << FAST_BITS); ++i) { + stbi_uc fast = h->fast[i]; + fast_ac[i] = 0; + if (fast < 255) { + int rs = h->values[fast]; + int run = (rs >> 4) & 15; + int magbits = rs & 15; + int len = h->size[fast]; + + if (magbits && len + magbits <= FAST_BITS) { + // magnitude code followed by receive_extend code + int k = ((i << len) & ((1 << FAST_BITS) - 1)) >> (FAST_BITS - magbits); + int m = 1 << (magbits - 1); + if (k < m) k += (~0U << magbits) + 1; + // if the result is small enough, we can fit it in fast_ac table + if (k >= -128 && k <= 127) + fast_ac[i] = (stbi__int16) ((k * 256) + (run * 16) + (len + magbits)); + } + } + } +} + +static void stbi__grow_buffer_unsafe(stbi__jpeg *j) +{ + do { + unsigned int b = j->nomore ? 0 : stbi__get8(j->s); + if (b == 0xff) { + int c = stbi__get8(j->s); + while (c == 0xff) c = stbi__get8(j->s); // consume fill bytes + if (c != 0) { + j->marker = (unsigned char) c; + j->nomore = 1; + return; + } + } + j->code_buffer |= b << (24 - j->code_bits); + j->code_bits += 8; + } while (j->code_bits <= 24); +} + +// (1 << n) - 1 +static const stbi__uint32 stbi__bmask[17]={0,1,3,7,15,31,63,127,255,511,1023,2047,4095,8191,16383,32767,65535}; + +// decode a jpeg huffman value from the bitstream +stbi_inline static int stbi__jpeg_huff_decode(stbi__jpeg *j, stbi__huffman *h) +{ + unsigned int temp; + int c,k; + + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + + // look at the top FAST_BITS and determine what symbol ID it is, + // if the code is <= FAST_BITS + c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1); + k = h->fast[c]; + if (k < 255) { + int s = h->size[k]; + if (s > j->code_bits) + return -1; + j->code_buffer <<= s; + j->code_bits -= s; + return h->values[k]; + } + + // naive test is to shift the code_buffer down so k bits are + // valid, then test against maxcode. To speed this up, we've + // preshifted maxcode left so that it has (16-k) 0s at the + // end; in other words, regardless of the number of bits, it + // wants to be compared against something shifted to have 16; + // that way we don't need to shift inside the loop. + temp = j->code_buffer >> 16; + for (k=FAST_BITS+1 ; ; ++k) + if (temp < h->maxcode[k]) + break; + if (k == 17) { + // error! code not found + j->code_bits -= 16; + return -1; + } + + if (k > j->code_bits) + return -1; + + // convert the huffman code to the symbol id + c = ((j->code_buffer >> (32 - k)) & stbi__bmask[k]) + h->delta[k]; + if(c < 0 || c >= 256) // symbol id out of bounds! + return -1; + STBI_ASSERT((((j->code_buffer) >> (32 - h->size[c])) & stbi__bmask[h->size[c]]) == h->code[c]); + + // convert the id to a symbol + j->code_bits -= k; + j->code_buffer <<= k; + return h->values[c]; +} + +// bias[n] = (-1<code_bits < n) stbi__grow_buffer_unsafe(j); + if (j->code_bits < n) return 0; // ran out of bits from stream, return 0s intead of continuing + + sgn = j->code_buffer >> 31; // sign bit always in MSB; 0 if MSB clear (positive), 1 if MSB set (negative) + k = stbi_lrot(j->code_buffer, n); + j->code_buffer = k & ~stbi__bmask[n]; + k &= stbi__bmask[n]; + j->code_bits -= n; + return k + (stbi__jbias[n] & (sgn - 1)); +} + +// get some unsigned bits +stbi_inline static int stbi__jpeg_get_bits(stbi__jpeg *j, int n) +{ + unsigned int k; + if (j->code_bits < n) stbi__grow_buffer_unsafe(j); + if (j->code_bits < n) return 0; // ran out of bits from stream, return 0s intead of continuing + k = stbi_lrot(j->code_buffer, n); + j->code_buffer = k & ~stbi__bmask[n]; + k &= stbi__bmask[n]; + j->code_bits -= n; + return k; +} + +stbi_inline static int stbi__jpeg_get_bit(stbi__jpeg *j) +{ + unsigned int k; + if (j->code_bits < 1) stbi__grow_buffer_unsafe(j); + if (j->code_bits < 1) return 0; // ran out of bits from stream, return 0s intead of continuing + k = j->code_buffer; + j->code_buffer <<= 1; + --j->code_bits; + return k & 0x80000000; +} + +// given a value that's at position X in the zigzag stream, +// where does it appear in the 8x8 matrix coded as row-major? +static const stbi_uc stbi__jpeg_dezigzag[64+15] = +{ + 0, 1, 8, 16, 9, 2, 3, 10, + 17, 24, 32, 25, 18, 11, 4, 5, + 12, 19, 26, 33, 40, 48, 41, 34, + 27, 20, 13, 6, 7, 14, 21, 28, + 35, 42, 49, 56, 57, 50, 43, 36, + 29, 22, 15, 23, 30, 37, 44, 51, + 58, 59, 52, 45, 38, 31, 39, 46, + 53, 60, 61, 54, 47, 55, 62, 63, + // let corrupt input sample past end + 63, 63, 63, 63, 63, 63, 63, 63, + 63, 63, 63, 63, 63, 63, 63 +}; + +// decode one 64-entry block-- +static int stbi__jpeg_decode_block(stbi__jpeg *j, short data[64], stbi__huffman *hdc, stbi__huffman *hac, stbi__int16 *fac, int b, stbi__uint16 *dequant) +{ + int diff,dc,k; + int t; + + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + t = stbi__jpeg_huff_decode(j, hdc); + if (t < 0 || t > 15) return stbi__err("bad huffman code","Corrupt JPEG"); + + // 0 all the ac values now so we can do it 32-bits at a time + memset(data,0,64*sizeof(data[0])); + + diff = t ? stbi__extend_receive(j, t) : 0; + if (!stbi__addints_valid(j->img_comp[b].dc_pred, diff)) return stbi__err("bad delta","Corrupt JPEG"); + dc = j->img_comp[b].dc_pred + diff; + j->img_comp[b].dc_pred = dc; + if (!stbi__mul2shorts_valid(dc, dequant[0])) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + data[0] = (short) (dc * dequant[0]); + + // decode AC components, see JPEG spec + k = 1; + do { + unsigned int zig; + int c,r,s; + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1); + r = fac[c]; + if (r) { // fast-AC path + k += (r >> 4) & 15; // run + s = r & 15; // combined length + if (s > j->code_bits) return stbi__err("bad huffman code", "Combined length longer than code bits available"); + j->code_buffer <<= s; + j->code_bits -= s; + // decode into unzigzag'd location + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) ((r >> 8) * dequant[zig]); + } else { + int rs = stbi__jpeg_huff_decode(j, hac); + if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG"); + s = rs & 15; + r = rs >> 4; + if (s == 0) { + if (rs != 0xf0) break; // end block + k += 16; + } else { + k += r; + // decode into unzigzag'd location + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) (stbi__extend_receive(j,s) * dequant[zig]); + } + } + } while (k < 64); + return 1; +} + +static int stbi__jpeg_decode_block_prog_dc(stbi__jpeg *j, short data[64], stbi__huffman *hdc, int b) +{ + int diff,dc; + int t; + if (j->spec_end != 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + + if (j->succ_high == 0) { + // first scan for DC coefficient, must be first + memset(data,0,64*sizeof(data[0])); // 0 all the ac values now + t = stbi__jpeg_huff_decode(j, hdc); + if (t < 0 || t > 15) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + diff = t ? stbi__extend_receive(j, t) : 0; + + if (!stbi__addints_valid(j->img_comp[b].dc_pred, diff)) return stbi__err("bad delta", "Corrupt JPEG"); + dc = j->img_comp[b].dc_pred + diff; + j->img_comp[b].dc_pred = dc; + if (!stbi__mul2shorts_valid(dc, 1 << j->succ_low)) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + data[0] = (short) (dc * (1 << j->succ_low)); + } else { + // refinement scan for DC coefficient + if (stbi__jpeg_get_bit(j)) + data[0] += (short) (1 << j->succ_low); + } + return 1; +} + +// @OPTIMIZE: store non-zigzagged during the decode passes, +// and only de-zigzag when dequantizing +static int stbi__jpeg_decode_block_prog_ac(stbi__jpeg *j, short data[64], stbi__huffman *hac, stbi__int16 *fac) +{ + int k; + if (j->spec_start == 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + + if (j->succ_high == 0) { + int shift = j->succ_low; + + if (j->eob_run) { + --j->eob_run; + return 1; + } + + k = j->spec_start; + do { + unsigned int zig; + int c,r,s; + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1); + r = fac[c]; + if (r) { // fast-AC path + k += (r >> 4) & 15; // run + s = r & 15; // combined length + if (s > j->code_bits) return stbi__err("bad huffman code", "Combined length longer than code bits available"); + j->code_buffer <<= s; + j->code_bits -= s; + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) ((r >> 8) * (1 << shift)); + } else { + int rs = stbi__jpeg_huff_decode(j, hac); + if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG"); + s = rs & 15; + r = rs >> 4; + if (s == 0) { + if (r < 15) { + j->eob_run = (1 << r); + if (r) + j->eob_run += stbi__jpeg_get_bits(j, r); + --j->eob_run; + break; + } + k += 16; + } else { + k += r; + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) (stbi__extend_receive(j,s) * (1 << shift)); + } + } + } while (k <= j->spec_end); + } else { + // refinement scan for these AC coefficients + + short bit = (short) (1 << j->succ_low); + + if (j->eob_run) { + --j->eob_run; + for (k = j->spec_start; k <= j->spec_end; ++k) { + short *p = &data[stbi__jpeg_dezigzag[k]]; + if (*p != 0) + if (stbi__jpeg_get_bit(j)) + if ((*p & bit)==0) { + if (*p > 0) + *p += bit; + else + *p -= bit; + } + } + } else { + k = j->spec_start; + do { + int r,s; + int rs = stbi__jpeg_huff_decode(j, hac); // @OPTIMIZE see if we can use the fast path here, advance-by-r is so slow, eh + if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG"); + s = rs & 15; + r = rs >> 4; + if (s == 0) { + if (r < 15) { + j->eob_run = (1 << r) - 1; + if (r) + j->eob_run += stbi__jpeg_get_bits(j, r); + r = 64; // force end of block + } else { + // r=15 s=0 should write 16 0s, so we just do + // a run of 15 0s and then write s (which is 0), + // so we don't have to do anything special here + } + } else { + if (s != 1) return stbi__err("bad huffman code", "Corrupt JPEG"); + // sign bit + if (stbi__jpeg_get_bit(j)) + s = bit; + else + s = -bit; + } + + // advance by r + while (k <= j->spec_end) { + short *p = &data[stbi__jpeg_dezigzag[k++]]; + if (*p != 0) { + if (stbi__jpeg_get_bit(j)) + if ((*p & bit)==0) { + if (*p > 0) + *p += bit; + else + *p -= bit; + } + } else { + if (r == 0) { + *p = (short) s; + break; + } + --r; + } + } + } while (k <= j->spec_end); + } + } + return 1; +} + +// take a -128..127 value and stbi__clamp it and convert to 0..255 +stbi_inline static stbi_uc stbi__clamp(int x) +{ + // trick to use a single test to catch both cases + if ((unsigned int) x > 255) { + if (x < 0) return 0; + if (x > 255) return 255; + } + return (stbi_uc) x; +} + +#define stbi__f2f(x) ((int) (((x) * 4096 + 0.5))) +#define stbi__fsh(x) ((x) * 4096) + +// derived from jidctint -- DCT_ISLOW +#define STBI__IDCT_1D(s0,s1,s2,s3,s4,s5,s6,s7) \ + int t0,t1,t2,t3,p1,p2,p3,p4,p5,x0,x1,x2,x3; \ + p2 = s2; \ + p3 = s6; \ + p1 = (p2+p3) * stbi__f2f(0.5411961f); \ + t2 = p1 + p3*stbi__f2f(-1.847759065f); \ + t3 = p1 + p2*stbi__f2f( 0.765366865f); \ + p2 = s0; \ + p3 = s4; \ + t0 = stbi__fsh(p2+p3); \ + t1 = stbi__fsh(p2-p3); \ + x0 = t0+t3; \ + x3 = t0-t3; \ + x1 = t1+t2; \ + x2 = t1-t2; \ + t0 = s7; \ + t1 = s5; \ + t2 = s3; \ + t3 = s1; \ + p3 = t0+t2; \ + p4 = t1+t3; \ + p1 = t0+t3; \ + p2 = t1+t2; \ + p5 = (p3+p4)*stbi__f2f( 1.175875602f); \ + t0 = t0*stbi__f2f( 0.298631336f); \ + t1 = t1*stbi__f2f( 2.053119869f); \ + t2 = t2*stbi__f2f( 3.072711026f); \ + t3 = t3*stbi__f2f( 1.501321110f); \ + p1 = p5 + p1*stbi__f2f(-0.899976223f); \ + p2 = p5 + p2*stbi__f2f(-2.562915447f); \ + p3 = p3*stbi__f2f(-1.961570560f); \ + p4 = p4*stbi__f2f(-0.390180644f); \ + t3 += p1+p4; \ + t2 += p2+p3; \ + t1 += p2+p4; \ + t0 += p1+p3; + +static void stbi__idct_block(stbi_uc *out, int out_stride, short data[64]) +{ + int i,val[64],*v=val; + stbi_uc *o; + short *d = data; + + // columns + for (i=0; i < 8; ++i,++d, ++v) { + // if all zeroes, shortcut -- this avoids dequantizing 0s and IDCTing + if (d[ 8]==0 && d[16]==0 && d[24]==0 && d[32]==0 + && d[40]==0 && d[48]==0 && d[56]==0) { + // no shortcut 0 seconds + // (1|2|3|4|5|6|7)==0 0 seconds + // all separate -0.047 seconds + // 1 && 2|3 && 4|5 && 6|7: -0.047 seconds + int dcterm = d[0]*4; + v[0] = v[8] = v[16] = v[24] = v[32] = v[40] = v[48] = v[56] = dcterm; + } else { + STBI__IDCT_1D(d[ 0],d[ 8],d[16],d[24],d[32],d[40],d[48],d[56]) + // constants scaled things up by 1<<12; let's bring them back + // down, but keep 2 extra bits of precision + x0 += 512; x1 += 512; x2 += 512; x3 += 512; + v[ 0] = (x0+t3) >> 10; + v[56] = (x0-t3) >> 10; + v[ 8] = (x1+t2) >> 10; + v[48] = (x1-t2) >> 10; + v[16] = (x2+t1) >> 10; + v[40] = (x2-t1) >> 10; + v[24] = (x3+t0) >> 10; + v[32] = (x3-t0) >> 10; + } + } + + for (i=0, v=val, o=out; i < 8; ++i,v+=8,o+=out_stride) { + // no fast case since the first 1D IDCT spread components out + STBI__IDCT_1D(v[0],v[1],v[2],v[3],v[4],v[5],v[6],v[7]) + // constants scaled things up by 1<<12, plus we had 1<<2 from first + // loop, plus horizontal and vertical each scale by sqrt(8) so together + // we've got an extra 1<<3, so 1<<17 total we need to remove. + // so we want to round that, which means adding 0.5 * 1<<17, + // aka 65536. Also, we'll end up with -128 to 127 that we want + // to encode as 0..255 by adding 128, so we'll add that before the shift + x0 += 65536 + (128<<17); + x1 += 65536 + (128<<17); + x2 += 65536 + (128<<17); + x3 += 65536 + (128<<17); + // tried computing the shifts into temps, or'ing the temps to see + // if any were out of range, but that was slower + o[0] = stbi__clamp((x0+t3) >> 17); + o[7] = stbi__clamp((x0-t3) >> 17); + o[1] = stbi__clamp((x1+t2) >> 17); + o[6] = stbi__clamp((x1-t2) >> 17); + o[2] = stbi__clamp((x2+t1) >> 17); + o[5] = stbi__clamp((x2-t1) >> 17); + o[3] = stbi__clamp((x3+t0) >> 17); + o[4] = stbi__clamp((x3-t0) >> 17); + } +} + +#ifdef STBI_SSE2 +// sse2 integer IDCT. not the fastest possible implementation but it +// produces bit-identical results to the generic C version so it's +// fully "transparent". +static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64]) +{ + // This is constructed to match our regular (generic) integer IDCT exactly. + __m128i row0, row1, row2, row3, row4, row5, row6, row7; + __m128i tmp; + + // dot product constant: even elems=x, odd elems=y + #define dct_const(x,y) _mm_setr_epi16((x),(y),(x),(y),(x),(y),(x),(y)) + + // out(0) = c0[even]*x + c0[odd]*y (c0, x, y 16-bit, out 32-bit) + // out(1) = c1[even]*x + c1[odd]*y + #define dct_rot(out0,out1, x,y,c0,c1) \ + __m128i c0##lo = _mm_unpacklo_epi16((x),(y)); \ + __m128i c0##hi = _mm_unpackhi_epi16((x),(y)); \ + __m128i out0##_l = _mm_madd_epi16(c0##lo, c0); \ + __m128i out0##_h = _mm_madd_epi16(c0##hi, c0); \ + __m128i out1##_l = _mm_madd_epi16(c0##lo, c1); \ + __m128i out1##_h = _mm_madd_epi16(c0##hi, c1) + + // out = in << 12 (in 16-bit, out 32-bit) + #define dct_widen(out, in) \ + __m128i out##_l = _mm_srai_epi32(_mm_unpacklo_epi16(_mm_setzero_si128(), (in)), 4); \ + __m128i out##_h = _mm_srai_epi32(_mm_unpackhi_epi16(_mm_setzero_si128(), (in)), 4) + + // wide add + #define dct_wadd(out, a, b) \ + __m128i out##_l = _mm_add_epi32(a##_l, b##_l); \ + __m128i out##_h = _mm_add_epi32(a##_h, b##_h) + + // wide sub + #define dct_wsub(out, a, b) \ + __m128i out##_l = _mm_sub_epi32(a##_l, b##_l); \ + __m128i out##_h = _mm_sub_epi32(a##_h, b##_h) + + // butterfly a/b, add bias, then shift by "s" and pack + #define dct_bfly32o(out0, out1, a,b,bias,s) \ + { \ + __m128i abiased_l = _mm_add_epi32(a##_l, bias); \ + __m128i abiased_h = _mm_add_epi32(a##_h, bias); \ + dct_wadd(sum, abiased, b); \ + dct_wsub(dif, abiased, b); \ + out0 = _mm_packs_epi32(_mm_srai_epi32(sum_l, s), _mm_srai_epi32(sum_h, s)); \ + out1 = _mm_packs_epi32(_mm_srai_epi32(dif_l, s), _mm_srai_epi32(dif_h, s)); \ + } + + // 8-bit interleave step (for transposes) + #define dct_interleave8(a, b) \ + tmp = a; \ + a = _mm_unpacklo_epi8(a, b); \ + b = _mm_unpackhi_epi8(tmp, b) + + // 16-bit interleave step (for transposes) + #define dct_interleave16(a, b) \ + tmp = a; \ + a = _mm_unpacklo_epi16(a, b); \ + b = _mm_unpackhi_epi16(tmp, b) + + #define dct_pass(bias,shift) \ + { \ + /* even part */ \ + dct_rot(t2e,t3e, row2,row6, rot0_0,rot0_1); \ + __m128i sum04 = _mm_add_epi16(row0, row4); \ + __m128i dif04 = _mm_sub_epi16(row0, row4); \ + dct_widen(t0e, sum04); \ + dct_widen(t1e, dif04); \ + dct_wadd(x0, t0e, t3e); \ + dct_wsub(x3, t0e, t3e); \ + dct_wadd(x1, t1e, t2e); \ + dct_wsub(x2, t1e, t2e); \ + /* odd part */ \ + dct_rot(y0o,y2o, row7,row3, rot2_0,rot2_1); \ + dct_rot(y1o,y3o, row5,row1, rot3_0,rot3_1); \ + __m128i sum17 = _mm_add_epi16(row1, row7); \ + __m128i sum35 = _mm_add_epi16(row3, row5); \ + dct_rot(y4o,y5o, sum17,sum35, rot1_0,rot1_1); \ + dct_wadd(x4, y0o, y4o); \ + dct_wadd(x5, y1o, y5o); \ + dct_wadd(x6, y2o, y5o); \ + dct_wadd(x7, y3o, y4o); \ + dct_bfly32o(row0,row7, x0,x7,bias,shift); \ + dct_bfly32o(row1,row6, x1,x6,bias,shift); \ + dct_bfly32o(row2,row5, x2,x5,bias,shift); \ + dct_bfly32o(row3,row4, x3,x4,bias,shift); \ + } + + __m128i rot0_0 = dct_const(stbi__f2f(0.5411961f), stbi__f2f(0.5411961f) + stbi__f2f(-1.847759065f)); + __m128i rot0_1 = dct_const(stbi__f2f(0.5411961f) + stbi__f2f( 0.765366865f), stbi__f2f(0.5411961f)); + __m128i rot1_0 = dct_const(stbi__f2f(1.175875602f) + stbi__f2f(-0.899976223f), stbi__f2f(1.175875602f)); + __m128i rot1_1 = dct_const(stbi__f2f(1.175875602f), stbi__f2f(1.175875602f) + stbi__f2f(-2.562915447f)); + __m128i rot2_0 = dct_const(stbi__f2f(-1.961570560f) + stbi__f2f( 0.298631336f), stbi__f2f(-1.961570560f)); + __m128i rot2_1 = dct_const(stbi__f2f(-1.961570560f), stbi__f2f(-1.961570560f) + stbi__f2f( 3.072711026f)); + __m128i rot3_0 = dct_const(stbi__f2f(-0.390180644f) + stbi__f2f( 2.053119869f), stbi__f2f(-0.390180644f)); + __m128i rot3_1 = dct_const(stbi__f2f(-0.390180644f), stbi__f2f(-0.390180644f) + stbi__f2f( 1.501321110f)); + + // rounding biases in column/row passes, see stbi__idct_block for explanation. + __m128i bias_0 = _mm_set1_epi32(512); + __m128i bias_1 = _mm_set1_epi32(65536 + (128<<17)); + + // load + row0 = _mm_load_si128((const __m128i *) (data + 0*8)); + row1 = _mm_load_si128((const __m128i *) (data + 1*8)); + row2 = _mm_load_si128((const __m128i *) (data + 2*8)); + row3 = _mm_load_si128((const __m128i *) (data + 3*8)); + row4 = _mm_load_si128((const __m128i *) (data + 4*8)); + row5 = _mm_load_si128((const __m128i *) (data + 5*8)); + row6 = _mm_load_si128((const __m128i *) (data + 6*8)); + row7 = _mm_load_si128((const __m128i *) (data + 7*8)); + + // column pass + dct_pass(bias_0, 10); + + { + // 16bit 8x8 transpose pass 1 + dct_interleave16(row0, row4); + dct_interleave16(row1, row5); + dct_interleave16(row2, row6); + dct_interleave16(row3, row7); + + // transpose pass 2 + dct_interleave16(row0, row2); + dct_interleave16(row1, row3); + dct_interleave16(row4, row6); + dct_interleave16(row5, row7); + + // transpose pass 3 + dct_interleave16(row0, row1); + dct_interleave16(row2, row3); + dct_interleave16(row4, row5); + dct_interleave16(row6, row7); + } + + // row pass + dct_pass(bias_1, 17); + + { + // pack + __m128i p0 = _mm_packus_epi16(row0, row1); // a0a1a2a3...a7b0b1b2b3...b7 + __m128i p1 = _mm_packus_epi16(row2, row3); + __m128i p2 = _mm_packus_epi16(row4, row5); + __m128i p3 = _mm_packus_epi16(row6, row7); + + // 8bit 8x8 transpose pass 1 + dct_interleave8(p0, p2); // a0e0a1e1... + dct_interleave8(p1, p3); // c0g0c1g1... + + // transpose pass 2 + dct_interleave8(p0, p1); // a0c0e0g0... + dct_interleave8(p2, p3); // b0d0f0h0... + + // transpose pass 3 + dct_interleave8(p0, p2); // a0b0c0d0... + dct_interleave8(p1, p3); // a4b4c4d4... + + // store + _mm_storel_epi64((__m128i *) out, p0); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p0, 0x4e)); out += out_stride; + _mm_storel_epi64((__m128i *) out, p2); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p2, 0x4e)); out += out_stride; + _mm_storel_epi64((__m128i *) out, p1); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p1, 0x4e)); out += out_stride; + _mm_storel_epi64((__m128i *) out, p3); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p3, 0x4e)); + } + +#undef dct_const +#undef dct_rot +#undef dct_widen +#undef dct_wadd +#undef dct_wsub +#undef dct_bfly32o +#undef dct_interleave8 +#undef dct_interleave16 +#undef dct_pass +} + +#endif // STBI_SSE2 + +#ifdef STBI_NEON + +// NEON integer IDCT. should produce bit-identical +// results to the generic C version. +static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64]) +{ + int16x8_t row0, row1, row2, row3, row4, row5, row6, row7; + + int16x4_t rot0_0 = vdup_n_s16(stbi__f2f(0.5411961f)); + int16x4_t rot0_1 = vdup_n_s16(stbi__f2f(-1.847759065f)); + int16x4_t rot0_2 = vdup_n_s16(stbi__f2f( 0.765366865f)); + int16x4_t rot1_0 = vdup_n_s16(stbi__f2f( 1.175875602f)); + int16x4_t rot1_1 = vdup_n_s16(stbi__f2f(-0.899976223f)); + int16x4_t rot1_2 = vdup_n_s16(stbi__f2f(-2.562915447f)); + int16x4_t rot2_0 = vdup_n_s16(stbi__f2f(-1.961570560f)); + int16x4_t rot2_1 = vdup_n_s16(stbi__f2f(-0.390180644f)); + int16x4_t rot3_0 = vdup_n_s16(stbi__f2f( 0.298631336f)); + int16x4_t rot3_1 = vdup_n_s16(stbi__f2f( 2.053119869f)); + int16x4_t rot3_2 = vdup_n_s16(stbi__f2f( 3.072711026f)); + int16x4_t rot3_3 = vdup_n_s16(stbi__f2f( 1.501321110f)); + +#define dct_long_mul(out, inq, coeff) \ + int32x4_t out##_l = vmull_s16(vget_low_s16(inq), coeff); \ + int32x4_t out##_h = vmull_s16(vget_high_s16(inq), coeff) + +#define dct_long_mac(out, acc, inq, coeff) \ + int32x4_t out##_l = vmlal_s16(acc##_l, vget_low_s16(inq), coeff); \ + int32x4_t out##_h = vmlal_s16(acc##_h, vget_high_s16(inq), coeff) + +#define dct_widen(out, inq) \ + int32x4_t out##_l = vshll_n_s16(vget_low_s16(inq), 12); \ + int32x4_t out##_h = vshll_n_s16(vget_high_s16(inq), 12) + +// wide add +#define dct_wadd(out, a, b) \ + int32x4_t out##_l = vaddq_s32(a##_l, b##_l); \ + int32x4_t out##_h = vaddq_s32(a##_h, b##_h) + +// wide sub +#define dct_wsub(out, a, b) \ + int32x4_t out##_l = vsubq_s32(a##_l, b##_l); \ + int32x4_t out##_h = vsubq_s32(a##_h, b##_h) + +// butterfly a/b, then shift using "shiftop" by "s" and pack +#define dct_bfly32o(out0,out1, a,b,shiftop,s) \ + { \ + dct_wadd(sum, a, b); \ + dct_wsub(dif, a, b); \ + out0 = vcombine_s16(shiftop(sum_l, s), shiftop(sum_h, s)); \ + out1 = vcombine_s16(shiftop(dif_l, s), shiftop(dif_h, s)); \ + } + +#define dct_pass(shiftop, shift) \ + { \ + /* even part */ \ + int16x8_t sum26 = vaddq_s16(row2, row6); \ + dct_long_mul(p1e, sum26, rot0_0); \ + dct_long_mac(t2e, p1e, row6, rot0_1); \ + dct_long_mac(t3e, p1e, row2, rot0_2); \ + int16x8_t sum04 = vaddq_s16(row0, row4); \ + int16x8_t dif04 = vsubq_s16(row0, row4); \ + dct_widen(t0e, sum04); \ + dct_widen(t1e, dif04); \ + dct_wadd(x0, t0e, t3e); \ + dct_wsub(x3, t0e, t3e); \ + dct_wadd(x1, t1e, t2e); \ + dct_wsub(x2, t1e, t2e); \ + /* odd part */ \ + int16x8_t sum15 = vaddq_s16(row1, row5); \ + int16x8_t sum17 = vaddq_s16(row1, row7); \ + int16x8_t sum35 = vaddq_s16(row3, row5); \ + int16x8_t sum37 = vaddq_s16(row3, row7); \ + int16x8_t sumodd = vaddq_s16(sum17, sum35); \ + dct_long_mul(p5o, sumodd, rot1_0); \ + dct_long_mac(p1o, p5o, sum17, rot1_1); \ + dct_long_mac(p2o, p5o, sum35, rot1_2); \ + dct_long_mul(p3o, sum37, rot2_0); \ + dct_long_mul(p4o, sum15, rot2_1); \ + dct_wadd(sump13o, p1o, p3o); \ + dct_wadd(sump24o, p2o, p4o); \ + dct_wadd(sump23o, p2o, p3o); \ + dct_wadd(sump14o, p1o, p4o); \ + dct_long_mac(x4, sump13o, row7, rot3_0); \ + dct_long_mac(x5, sump24o, row5, rot3_1); \ + dct_long_mac(x6, sump23o, row3, rot3_2); \ + dct_long_mac(x7, sump14o, row1, rot3_3); \ + dct_bfly32o(row0,row7, x0,x7,shiftop,shift); \ + dct_bfly32o(row1,row6, x1,x6,shiftop,shift); \ + dct_bfly32o(row2,row5, x2,x5,shiftop,shift); \ + dct_bfly32o(row3,row4, x3,x4,shiftop,shift); \ + } + + // load + row0 = vld1q_s16(data + 0*8); + row1 = vld1q_s16(data + 1*8); + row2 = vld1q_s16(data + 2*8); + row3 = vld1q_s16(data + 3*8); + row4 = vld1q_s16(data + 4*8); + row5 = vld1q_s16(data + 5*8); + row6 = vld1q_s16(data + 6*8); + row7 = vld1q_s16(data + 7*8); + + // add DC bias + row0 = vaddq_s16(row0, vsetq_lane_s16(1024, vdupq_n_s16(0), 0)); + + // column pass + dct_pass(vrshrn_n_s32, 10); + + // 16bit 8x8 transpose + { +// these three map to a single VTRN.16, VTRN.32, and VSWP, respectively. +// whether compilers actually get this is another story, sadly. +#define dct_trn16(x, y) { int16x8x2_t t = vtrnq_s16(x, y); x = t.val[0]; y = t.val[1]; } +#define dct_trn32(x, y) { int32x4x2_t t = vtrnq_s32(vreinterpretq_s32_s16(x), vreinterpretq_s32_s16(y)); x = vreinterpretq_s16_s32(t.val[0]); y = vreinterpretq_s16_s32(t.val[1]); } +#define dct_trn64(x, y) { int16x8_t x0 = x; int16x8_t y0 = y; x = vcombine_s16(vget_low_s16(x0), vget_low_s16(y0)); y = vcombine_s16(vget_high_s16(x0), vget_high_s16(y0)); } + + // pass 1 + dct_trn16(row0, row1); // a0b0a2b2a4b4a6b6 + dct_trn16(row2, row3); + dct_trn16(row4, row5); + dct_trn16(row6, row7); + + // pass 2 + dct_trn32(row0, row2); // a0b0c0d0a4b4c4d4 + dct_trn32(row1, row3); + dct_trn32(row4, row6); + dct_trn32(row5, row7); + + // pass 3 + dct_trn64(row0, row4); // a0b0c0d0e0f0g0h0 + dct_trn64(row1, row5); + dct_trn64(row2, row6); + dct_trn64(row3, row7); + +#undef dct_trn16 +#undef dct_trn32 +#undef dct_trn64 + } + + // row pass + // vrshrn_n_s32 only supports shifts up to 16, we need + // 17. so do a non-rounding shift of 16 first then follow + // up with a rounding shift by 1. + dct_pass(vshrn_n_s32, 16); + + { + // pack and round + uint8x8_t p0 = vqrshrun_n_s16(row0, 1); + uint8x8_t p1 = vqrshrun_n_s16(row1, 1); + uint8x8_t p2 = vqrshrun_n_s16(row2, 1); + uint8x8_t p3 = vqrshrun_n_s16(row3, 1); + uint8x8_t p4 = vqrshrun_n_s16(row4, 1); + uint8x8_t p5 = vqrshrun_n_s16(row5, 1); + uint8x8_t p6 = vqrshrun_n_s16(row6, 1); + uint8x8_t p7 = vqrshrun_n_s16(row7, 1); + + // again, these can translate into one instruction, but often don't. +#define dct_trn8_8(x, y) { uint8x8x2_t t = vtrn_u8(x, y); x = t.val[0]; y = t.val[1]; } +#define dct_trn8_16(x, y) { uint16x4x2_t t = vtrn_u16(vreinterpret_u16_u8(x), vreinterpret_u16_u8(y)); x = vreinterpret_u8_u16(t.val[0]); y = vreinterpret_u8_u16(t.val[1]); } +#define dct_trn8_32(x, y) { uint32x2x2_t t = vtrn_u32(vreinterpret_u32_u8(x), vreinterpret_u32_u8(y)); x = vreinterpret_u8_u32(t.val[0]); y = vreinterpret_u8_u32(t.val[1]); } + + // sadly can't use interleaved stores here since we only write + // 8 bytes to each scan line! + + // 8x8 8-bit transpose pass 1 + dct_trn8_8(p0, p1); + dct_trn8_8(p2, p3); + dct_trn8_8(p4, p5); + dct_trn8_8(p6, p7); + + // pass 2 + dct_trn8_16(p0, p2); + dct_trn8_16(p1, p3); + dct_trn8_16(p4, p6); + dct_trn8_16(p5, p7); + + // pass 3 + dct_trn8_32(p0, p4); + dct_trn8_32(p1, p5); + dct_trn8_32(p2, p6); + dct_trn8_32(p3, p7); + + // store + vst1_u8(out, p0); out += out_stride; + vst1_u8(out, p1); out += out_stride; + vst1_u8(out, p2); out += out_stride; + vst1_u8(out, p3); out += out_stride; + vst1_u8(out, p4); out += out_stride; + vst1_u8(out, p5); out += out_stride; + vst1_u8(out, p6); out += out_stride; + vst1_u8(out, p7); + +#undef dct_trn8_8 +#undef dct_trn8_16 +#undef dct_trn8_32 + } + +#undef dct_long_mul +#undef dct_long_mac +#undef dct_widen +#undef dct_wadd +#undef dct_wsub +#undef dct_bfly32o +#undef dct_pass +} + +#endif // STBI_NEON + +#define STBI__MARKER_none 0xff +// if there's a pending marker from the entropy stream, return that +// otherwise, fetch from the stream and get a marker. if there's no +// marker, return 0xff, which is never a valid marker value +static stbi_uc stbi__get_marker(stbi__jpeg *j) +{ + stbi_uc x; + if (j->marker != STBI__MARKER_none) { x = j->marker; j->marker = STBI__MARKER_none; return x; } + x = stbi__get8(j->s); + if (x != 0xff) return STBI__MARKER_none; + while (x == 0xff) + x = stbi__get8(j->s); // consume repeated 0xff fill bytes + return x; +} + +// in each scan, we'll have scan_n components, and the order +// of the components is specified by order[] +#define STBI__RESTART(x) ((x) >= 0xd0 && (x) <= 0xd7) + +// after a restart interval, stbi__jpeg_reset the entropy decoder and +// the dc prediction +static void stbi__jpeg_reset(stbi__jpeg *j) +{ + j->code_bits = 0; + j->code_buffer = 0; + j->nomore = 0; + j->img_comp[0].dc_pred = j->img_comp[1].dc_pred = j->img_comp[2].dc_pred = j->img_comp[3].dc_pred = 0; + j->marker = STBI__MARKER_none; + j->todo = j->restart_interval ? j->restart_interval : 0x7fffffff; + j->eob_run = 0; + // no more than 1<<31 MCUs if no restart_interal? that's plenty safe, + // since we don't even allow 1<<30 pixels +} + +static int stbi__parse_entropy_coded_data(stbi__jpeg *z) +{ + stbi__jpeg_reset(z); + if (!z->progressive) { + if (z->scan_n == 1) { + int i,j; + STBI_SIMD_ALIGN(short, data[64]); + int n = z->order[0]; + // non-interleaved data, we just need to process one block at a time, + // in trivial scanline order + // number of blocks to do just depends on how many actual "pixels" this + // component has, independent of interleaved MCU blocking and such + int w = (z->img_comp[n].x+7) >> 3; + int h = (z->img_comp[n].y+7) >> 3; + for (j=0; j < h; ++j) { + for (i=0; i < w; ++i) { + int ha = z->img_comp[n].ha; + if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+ha, z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq])) return 0; + z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data); + // every data block is an MCU, so countdown the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + // if it's NOT a restart, then just bail, so we get corrupt data + // rather than no data + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } else { // interleaved + int i,j,k,x,y; + STBI_SIMD_ALIGN(short, data[64]); + for (j=0; j < z->img_mcu_y; ++j) { + for (i=0; i < z->img_mcu_x; ++i) { + // scan an interleaved mcu... process scan_n components in order + for (k=0; k < z->scan_n; ++k) { + int n = z->order[k]; + // scan out an mcu's worth of this component; that's just determined + // by the basic H and V specified for the component + for (y=0; y < z->img_comp[n].v; ++y) { + for (x=0; x < z->img_comp[n].h; ++x) { + int x2 = (i*z->img_comp[n].h + x)*8; + int y2 = (j*z->img_comp[n].v + y)*8; + int ha = z->img_comp[n].ha; + if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+ha, z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq])) return 0; + z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*y2+x2, z->img_comp[n].w2, data); + } + } + } + // after all interleaved components, that's an interleaved MCU, + // so now count down the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } + } else { + if (z->scan_n == 1) { + int i,j; + int n = z->order[0]; + // non-interleaved data, we just need to process one block at a time, + // in trivial scanline order + // number of blocks to do just depends on how many actual "pixels" this + // component has, independent of interleaved MCU blocking and such + int w = (z->img_comp[n].x+7) >> 3; + int h = (z->img_comp[n].y+7) >> 3; + for (j=0; j < h; ++j) { + for (i=0; i < w; ++i) { + short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w); + if (z->spec_start == 0) { + if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n)) + return 0; + } else { + int ha = z->img_comp[n].ha; + if (!stbi__jpeg_decode_block_prog_ac(z, data, &z->huff_ac[ha], z->fast_ac[ha])) + return 0; + } + // every data block is an MCU, so countdown the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } else { // interleaved + int i,j,k,x,y; + for (j=0; j < z->img_mcu_y; ++j) { + for (i=0; i < z->img_mcu_x; ++i) { + // scan an interleaved mcu... process scan_n components in order + for (k=0; k < z->scan_n; ++k) { + int n = z->order[k]; + // scan out an mcu's worth of this component; that's just determined + // by the basic H and V specified for the component + for (y=0; y < z->img_comp[n].v; ++y) { + for (x=0; x < z->img_comp[n].h; ++x) { + int x2 = (i*z->img_comp[n].h + x); + int y2 = (j*z->img_comp[n].v + y); + short *data = z->img_comp[n].coeff + 64 * (x2 + y2 * z->img_comp[n].coeff_w); + if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n)) + return 0; + } + } + } + // after all interleaved components, that's an interleaved MCU, + // so now count down the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } + } +} + +static void stbi__jpeg_dequantize(short *data, stbi__uint16 *dequant) +{ + int i; + for (i=0; i < 64; ++i) + data[i] *= dequant[i]; +} + +static void stbi__jpeg_finish(stbi__jpeg *z) +{ + if (z->progressive) { + // dequantize and idct the data + int i,j,n; + for (n=0; n < z->s->img_n; ++n) { + int w = (z->img_comp[n].x+7) >> 3; + int h = (z->img_comp[n].y+7) >> 3; + for (j=0; j < h; ++j) { + for (i=0; i < w; ++i) { + short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w); + stbi__jpeg_dequantize(data, z->dequant[z->img_comp[n].tq]); + z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data); + } + } + } + } +} + +static int stbi__process_marker(stbi__jpeg *z, int m) +{ + int L; + switch (m) { + case STBI__MARKER_none: // no marker found + return stbi__err("expected marker","Corrupt JPEG"); + + case 0xDD: // DRI - specify restart interval + if (stbi__get16be(z->s) != 4) return stbi__err("bad DRI len","Corrupt JPEG"); + z->restart_interval = stbi__get16be(z->s); + return 1; + + case 0xDB: // DQT - define quantization table + L = stbi__get16be(z->s)-2; + while (L > 0) { + int q = stbi__get8(z->s); + int p = q >> 4, sixteen = (p != 0); + int t = q & 15,i; + if (p != 0 && p != 1) return stbi__err("bad DQT type","Corrupt JPEG"); + if (t > 3) return stbi__err("bad DQT table","Corrupt JPEG"); + + for (i=0; i < 64; ++i) + z->dequant[t][stbi__jpeg_dezigzag[i]] = (stbi__uint16)(sixteen ? stbi__get16be(z->s) : stbi__get8(z->s)); + L -= (sixteen ? 129 : 65); + } + return L==0; + + case 0xC4: // DHT - define huffman table + L = stbi__get16be(z->s)-2; + while (L > 0) { + stbi_uc *v; + int sizes[16],i,n=0; + int q = stbi__get8(z->s); + int tc = q >> 4; + int th = q & 15; + if (tc > 1 || th > 3) return stbi__err("bad DHT header","Corrupt JPEG"); + for (i=0; i < 16; ++i) { + sizes[i] = stbi__get8(z->s); + n += sizes[i]; + } + if(n > 256) return stbi__err("bad DHT header","Corrupt JPEG"); // Loop over i < n would write past end of values! + L -= 17; + if (tc == 0) { + if (!stbi__build_huffman(z->huff_dc+th, sizes)) return 0; + v = z->huff_dc[th].values; + } else { + if (!stbi__build_huffman(z->huff_ac+th, sizes)) return 0; + v = z->huff_ac[th].values; + } + for (i=0; i < n; ++i) + v[i] = stbi__get8(z->s); + if (tc != 0) + stbi__build_fast_ac(z->fast_ac[th], z->huff_ac + th); + L -= n; + } + return L==0; + } + + // check for comment block or APP blocks + if ((m >= 0xE0 && m <= 0xEF) || m == 0xFE) { + L = stbi__get16be(z->s); + if (L < 2) { + if (m == 0xFE) + return stbi__err("bad COM len","Corrupt JPEG"); + else + return stbi__err("bad APP len","Corrupt JPEG"); + } + L -= 2; + + if (m == 0xE0 && L >= 5) { // JFIF APP0 segment + static const unsigned char tag[5] = {'J','F','I','F','\0'}; + int ok = 1; + int i; + for (i=0; i < 5; ++i) + if (stbi__get8(z->s) != tag[i]) + ok = 0; + L -= 5; + if (ok) + z->jfif = 1; + } else if (m == 0xEE && L >= 12) { // Adobe APP14 segment + static const unsigned char tag[6] = {'A','d','o','b','e','\0'}; + int ok = 1; + int i; + for (i=0; i < 6; ++i) + if (stbi__get8(z->s) != tag[i]) + ok = 0; + L -= 6; + if (ok) { + stbi__get8(z->s); // version + stbi__get16be(z->s); // flags0 + stbi__get16be(z->s); // flags1 + z->app14_color_transform = stbi__get8(z->s); // color transform + L -= 6; + } + } + + stbi__skip(z->s, L); + return 1; + } + + return stbi__err("unknown marker","Corrupt JPEG"); +} + +// after we see SOS +static int stbi__process_scan_header(stbi__jpeg *z) +{ + int i; + int Ls = stbi__get16be(z->s); + z->scan_n = stbi__get8(z->s); + if (z->scan_n < 1 || z->scan_n > 4 || z->scan_n > (int) z->s->img_n) return stbi__err("bad SOS component count","Corrupt JPEG"); + if (Ls != 6+2*z->scan_n) return stbi__err("bad SOS len","Corrupt JPEG"); + for (i=0; i < z->scan_n; ++i) { + int id = stbi__get8(z->s), which; + int q = stbi__get8(z->s); + for (which = 0; which < z->s->img_n; ++which) + if (z->img_comp[which].id == id) + break; + if (which == z->s->img_n) return 0; // no match + z->img_comp[which].hd = q >> 4; if (z->img_comp[which].hd > 3) return stbi__err("bad DC huff","Corrupt JPEG"); + z->img_comp[which].ha = q & 15; if (z->img_comp[which].ha > 3) return stbi__err("bad AC huff","Corrupt JPEG"); + z->order[i] = which; + } + + { + int aa; + z->spec_start = stbi__get8(z->s); + z->spec_end = stbi__get8(z->s); // should be 63, but might be 0 + aa = stbi__get8(z->s); + z->succ_high = (aa >> 4); + z->succ_low = (aa & 15); + if (z->progressive) { + if (z->spec_start > 63 || z->spec_end > 63 || z->spec_start > z->spec_end || z->succ_high > 13 || z->succ_low > 13) + return stbi__err("bad SOS", "Corrupt JPEG"); + } else { + if (z->spec_start != 0) return stbi__err("bad SOS","Corrupt JPEG"); + if (z->succ_high != 0 || z->succ_low != 0) return stbi__err("bad SOS","Corrupt JPEG"); + z->spec_end = 63; + } + } + + return 1; +} + +static int stbi__free_jpeg_components(stbi__jpeg *z, int ncomp, int why) +{ + int i; + for (i=0; i < ncomp; ++i) { + if (z->img_comp[i].raw_data) { + STBI_FREE(z->img_comp[i].raw_data); + z->img_comp[i].raw_data = NULL; + z->img_comp[i].data = NULL; + } + if (z->img_comp[i].raw_coeff) { + STBI_FREE(z->img_comp[i].raw_coeff); + z->img_comp[i].raw_coeff = 0; + z->img_comp[i].coeff = 0; + } + if (z->img_comp[i].linebuf) { + STBI_FREE(z->img_comp[i].linebuf); + z->img_comp[i].linebuf = NULL; + } + } + return why; +} + +static int stbi__process_frame_header(stbi__jpeg *z, int scan) +{ + stbi__context *s = z->s; + int Lf,p,i,q, h_max=1,v_max=1,c; + Lf = stbi__get16be(s); if (Lf < 11) return stbi__err("bad SOF len","Corrupt JPEG"); // JPEG + p = stbi__get8(s); if (p != 8) return stbi__err("only 8-bit","JPEG format not supported: 8-bit only"); // JPEG baseline + s->img_y = stbi__get16be(s); if (s->img_y == 0) return stbi__err("no header height", "JPEG format not supported: delayed height"); // Legal, but we don't handle it--but neither does IJG + s->img_x = stbi__get16be(s); if (s->img_x == 0) return stbi__err("0 width","Corrupt JPEG"); // JPEG requires + if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + c = stbi__get8(s); + if (c != 3 && c != 1 && c != 4) return stbi__err("bad component count","Corrupt JPEG"); + s->img_n = c; + for (i=0; i < c; ++i) { + z->img_comp[i].data = NULL; + z->img_comp[i].linebuf = NULL; + } + + if (Lf != 8+3*s->img_n) return stbi__err("bad SOF len","Corrupt JPEG"); + + z->rgb = 0; + for (i=0; i < s->img_n; ++i) { + static const unsigned char rgb[3] = { 'R', 'G', 'B' }; + z->img_comp[i].id = stbi__get8(s); + if (s->img_n == 3 && z->img_comp[i].id == rgb[i]) + ++z->rgb; + q = stbi__get8(s); + z->img_comp[i].h = (q >> 4); if (!z->img_comp[i].h || z->img_comp[i].h > 4) return stbi__err("bad H","Corrupt JPEG"); + z->img_comp[i].v = q & 15; if (!z->img_comp[i].v || z->img_comp[i].v > 4) return stbi__err("bad V","Corrupt JPEG"); + z->img_comp[i].tq = stbi__get8(s); if (z->img_comp[i].tq > 3) return stbi__err("bad TQ","Corrupt JPEG"); + } + + if (scan != STBI__SCAN_load) return 1; + + if (!stbi__mad3sizes_valid(s->img_x, s->img_y, s->img_n, 0)) return stbi__err("too large", "Image too large to decode"); + + for (i=0; i < s->img_n; ++i) { + if (z->img_comp[i].h > h_max) h_max = z->img_comp[i].h; + if (z->img_comp[i].v > v_max) v_max = z->img_comp[i].v; + } + + // check that plane subsampling factors are integer ratios; our resamplers can't deal with fractional ratios + // and I've never seen a non-corrupted JPEG file actually use them + for (i=0; i < s->img_n; ++i) { + if (h_max % z->img_comp[i].h != 0) return stbi__err("bad H","Corrupt JPEG"); + if (v_max % z->img_comp[i].v != 0) return stbi__err("bad V","Corrupt JPEG"); + } + + // compute interleaved mcu info + z->img_h_max = h_max; + z->img_v_max = v_max; + z->img_mcu_w = h_max * 8; + z->img_mcu_h = v_max * 8; + // these sizes can't be more than 17 bits + z->img_mcu_x = (s->img_x + z->img_mcu_w-1) / z->img_mcu_w; + z->img_mcu_y = (s->img_y + z->img_mcu_h-1) / z->img_mcu_h; + + for (i=0; i < s->img_n; ++i) { + // number of effective pixels (e.g. for non-interleaved MCU) + z->img_comp[i].x = (s->img_x * z->img_comp[i].h + h_max-1) / h_max; + z->img_comp[i].y = (s->img_y * z->img_comp[i].v + v_max-1) / v_max; + // to simplify generation, we'll allocate enough memory to decode + // the bogus oversized data from using interleaved MCUs and their + // big blocks (e.g. a 16x16 iMCU on an image of width 33); we won't + // discard the extra data until colorspace conversion + // + // img_mcu_x, img_mcu_y: <=17 bits; comp[i].h and .v are <=4 (checked earlier) + // so these muls can't overflow with 32-bit ints (which we require) + z->img_comp[i].w2 = z->img_mcu_x * z->img_comp[i].h * 8; + z->img_comp[i].h2 = z->img_mcu_y * z->img_comp[i].v * 8; + z->img_comp[i].coeff = 0; + z->img_comp[i].raw_coeff = 0; + z->img_comp[i].linebuf = NULL; + z->img_comp[i].raw_data = stbi__malloc_mad2(z->img_comp[i].w2, z->img_comp[i].h2, 15); + if (z->img_comp[i].raw_data == NULL) + return stbi__free_jpeg_components(z, i+1, stbi__err("outofmem", "Out of memory")); + // align blocks for idct using mmx/sse + z->img_comp[i].data = (stbi_uc*) (((size_t) z->img_comp[i].raw_data + 15) & ~15); + if (z->progressive) { + // w2, h2 are multiples of 8 (see above) + z->img_comp[i].coeff_w = z->img_comp[i].w2 / 8; + z->img_comp[i].coeff_h = z->img_comp[i].h2 / 8; + z->img_comp[i].raw_coeff = stbi__malloc_mad3(z->img_comp[i].w2, z->img_comp[i].h2, sizeof(short), 15); + if (z->img_comp[i].raw_coeff == NULL) + return stbi__free_jpeg_components(z, i+1, stbi__err("outofmem", "Out of memory")); + z->img_comp[i].coeff = (short*) (((size_t) z->img_comp[i].raw_coeff + 15) & ~15); + } + } + + return 1; +} + +// use comparisons since in some cases we handle more than one case (e.g. SOF) +#define stbi__DNL(x) ((x) == 0xdc) +#define stbi__SOI(x) ((x) == 0xd8) +#define stbi__EOI(x) ((x) == 0xd9) +#define stbi__SOF(x) ((x) == 0xc0 || (x) == 0xc1 || (x) == 0xc2) +#define stbi__SOS(x) ((x) == 0xda) + +#define stbi__SOF_progressive(x) ((x) == 0xc2) + +static int stbi__decode_jpeg_header(stbi__jpeg *z, int scan) +{ + int m; + z->jfif = 0; + z->app14_color_transform = -1; // valid values are 0,1,2 + z->marker = STBI__MARKER_none; // initialize cached marker to empty + m = stbi__get_marker(z); + if (!stbi__SOI(m)) return stbi__err("no SOI","Corrupt JPEG"); + if (scan == STBI__SCAN_type) return 1; + m = stbi__get_marker(z); + while (!stbi__SOF(m)) { + if (!stbi__process_marker(z,m)) return 0; + m = stbi__get_marker(z); + while (m == STBI__MARKER_none) { + // some files have extra padding after their blocks, so ok, we'll scan + if (stbi__at_eof(z->s)) return stbi__err("no SOF", "Corrupt JPEG"); + m = stbi__get_marker(z); + } + } + z->progressive = stbi__SOF_progressive(m); + if (!stbi__process_frame_header(z, scan)) return 0; + return 1; +} + +static stbi_uc stbi__skip_jpeg_junk_at_end(stbi__jpeg *j) +{ + // some JPEGs have junk at end, skip over it but if we find what looks + // like a valid marker, resume there + while (!stbi__at_eof(j->s)) { + stbi_uc x = stbi__get8(j->s); + while (x == 0xff) { // might be a marker + if (stbi__at_eof(j->s)) return STBI__MARKER_none; + x = stbi__get8(j->s); + if (x != 0x00 && x != 0xff) { + // not a stuffed zero or lead-in to another marker, looks + // like an actual marker, return it + return x; + } + // stuffed zero has x=0 now which ends the loop, meaning we go + // back to regular scan loop. + // repeated 0xff keeps trying to read the next byte of the marker. + } + } + return STBI__MARKER_none; +} + +// decode image to YCbCr format +static int stbi__decode_jpeg_image(stbi__jpeg *j) +{ + int m; + for (m = 0; m < 4; m++) { + j->img_comp[m].raw_data = NULL; + j->img_comp[m].raw_coeff = NULL; + } + j->restart_interval = 0; + if (!stbi__decode_jpeg_header(j, STBI__SCAN_load)) return 0; + m = stbi__get_marker(j); + while (!stbi__EOI(m)) { + if (stbi__SOS(m)) { + if (!stbi__process_scan_header(j)) return 0; + if (!stbi__parse_entropy_coded_data(j)) return 0; + if (j->marker == STBI__MARKER_none ) { + j->marker = stbi__skip_jpeg_junk_at_end(j); + // if we reach eof without hitting a marker, stbi__get_marker() below will fail and we'll eventually return 0 + } + m = stbi__get_marker(j); + if (STBI__RESTART(m)) + m = stbi__get_marker(j); + } else if (stbi__DNL(m)) { + int Ld = stbi__get16be(j->s); + stbi__uint32 NL = stbi__get16be(j->s); + if (Ld != 4) return stbi__err("bad DNL len", "Corrupt JPEG"); + if (NL != j->s->img_y) return stbi__err("bad DNL height", "Corrupt JPEG"); + m = stbi__get_marker(j); + } else { + if (!stbi__process_marker(j, m)) return 1; + m = stbi__get_marker(j); + } + } + if (j->progressive) + stbi__jpeg_finish(j); + return 1; +} + +// static jfif-centered resampling (across block boundaries) + +typedef stbi_uc *(*resample_row_func)(stbi_uc *out, stbi_uc *in0, stbi_uc *in1, + int w, int hs); + +#define stbi__div4(x) ((stbi_uc) ((x) >> 2)) + +static stbi_uc *resample_row_1(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + STBI_NOTUSED(out); + STBI_NOTUSED(in_far); + STBI_NOTUSED(w); + STBI_NOTUSED(hs); + return in_near; +} + +static stbi_uc* stbi__resample_row_v_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate two samples vertically for every one in input + int i; + STBI_NOTUSED(hs); + for (i=0; i < w; ++i) + out[i] = stbi__div4(3*in_near[i] + in_far[i] + 2); + return out; +} + +static stbi_uc* stbi__resample_row_h_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate two samples horizontally for every one in input + int i; + stbi_uc *input = in_near; + + if (w == 1) { + // if only one sample, can't do any interpolation + out[0] = out[1] = input[0]; + return out; + } + + out[0] = input[0]; + out[1] = stbi__div4(input[0]*3 + input[1] + 2); + for (i=1; i < w-1; ++i) { + int n = 3*input[i]+2; + out[i*2+0] = stbi__div4(n+input[i-1]); + out[i*2+1] = stbi__div4(n+input[i+1]); + } + out[i*2+0] = stbi__div4(input[w-2]*3 + input[w-1] + 2); + out[i*2+1] = input[w-1]; + + STBI_NOTUSED(in_far); + STBI_NOTUSED(hs); + + return out; +} + +#define stbi__div16(x) ((stbi_uc) ((x) >> 4)) + +static stbi_uc *stbi__resample_row_hv_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate 2x2 samples for every one in input + int i,t0,t1; + if (w == 1) { + out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2); + return out; + } + + t1 = 3*in_near[0] + in_far[0]; + out[0] = stbi__div4(t1+2); + for (i=1; i < w; ++i) { + t0 = t1; + t1 = 3*in_near[i]+in_far[i]; + out[i*2-1] = stbi__div16(3*t0 + t1 + 8); + out[i*2 ] = stbi__div16(3*t1 + t0 + 8); + } + out[w*2-1] = stbi__div4(t1+2); + + STBI_NOTUSED(hs); + + return out; +} + +#if defined(STBI_SSE2) || defined(STBI_NEON) +static stbi_uc *stbi__resample_row_hv_2_simd(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate 2x2 samples for every one in input + int i=0,t0,t1; + + if (w == 1) { + out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2); + return out; + } + + t1 = 3*in_near[0] + in_far[0]; + // process groups of 8 pixels for as long as we can. + // note we can't handle the last pixel in a row in this loop + // because we need to handle the filter boundary conditions. + for (; i < ((w-1) & ~7); i += 8) { +#if defined(STBI_SSE2) + // load and perform the vertical filtering pass + // this uses 3*x + y = 4*x + (y - x) + __m128i zero = _mm_setzero_si128(); + __m128i farb = _mm_loadl_epi64((__m128i *) (in_far + i)); + __m128i nearb = _mm_loadl_epi64((__m128i *) (in_near + i)); + __m128i farw = _mm_unpacklo_epi8(farb, zero); + __m128i nearw = _mm_unpacklo_epi8(nearb, zero); + __m128i diff = _mm_sub_epi16(farw, nearw); + __m128i nears = _mm_slli_epi16(nearw, 2); + __m128i curr = _mm_add_epi16(nears, diff); // current row + + // horizontal filter works the same based on shifted vers of current + // row. "prev" is current row shifted right by 1 pixel; we need to + // insert the previous pixel value (from t1). + // "next" is current row shifted left by 1 pixel, with first pixel + // of next block of 8 pixels added in. + __m128i prv0 = _mm_slli_si128(curr, 2); + __m128i nxt0 = _mm_srli_si128(curr, 2); + __m128i prev = _mm_insert_epi16(prv0, t1, 0); + __m128i next = _mm_insert_epi16(nxt0, 3*in_near[i+8] + in_far[i+8], 7); + + // horizontal filter, polyphase implementation since it's convenient: + // even pixels = 3*cur + prev = cur*4 + (prev - cur) + // odd pixels = 3*cur + next = cur*4 + (next - cur) + // note the shared term. + __m128i bias = _mm_set1_epi16(8); + __m128i curs = _mm_slli_epi16(curr, 2); + __m128i prvd = _mm_sub_epi16(prev, curr); + __m128i nxtd = _mm_sub_epi16(next, curr); + __m128i curb = _mm_add_epi16(curs, bias); + __m128i even = _mm_add_epi16(prvd, curb); + __m128i odd = _mm_add_epi16(nxtd, curb); + + // interleave even and odd pixels, then undo scaling. + __m128i int0 = _mm_unpacklo_epi16(even, odd); + __m128i int1 = _mm_unpackhi_epi16(even, odd); + __m128i de0 = _mm_srli_epi16(int0, 4); + __m128i de1 = _mm_srli_epi16(int1, 4); + + // pack and write output + __m128i outv = _mm_packus_epi16(de0, de1); + _mm_storeu_si128((__m128i *) (out + i*2), outv); +#elif defined(STBI_NEON) + // load and perform the vertical filtering pass + // this uses 3*x + y = 4*x + (y - x) + uint8x8_t farb = vld1_u8(in_far + i); + uint8x8_t nearb = vld1_u8(in_near + i); + int16x8_t diff = vreinterpretq_s16_u16(vsubl_u8(farb, nearb)); + int16x8_t nears = vreinterpretq_s16_u16(vshll_n_u8(nearb, 2)); + int16x8_t curr = vaddq_s16(nears, diff); // current row + + // horizontal filter works the same based on shifted vers of current + // row. "prev" is current row shifted right by 1 pixel; we need to + // insert the previous pixel value (from t1). + // "next" is current row shifted left by 1 pixel, with first pixel + // of next block of 8 pixels added in. + int16x8_t prv0 = vextq_s16(curr, curr, 7); + int16x8_t nxt0 = vextq_s16(curr, curr, 1); + int16x8_t prev = vsetq_lane_s16(t1, prv0, 0); + int16x8_t next = vsetq_lane_s16(3*in_near[i+8] + in_far[i+8], nxt0, 7); + + // horizontal filter, polyphase implementation since it's convenient: + // even pixels = 3*cur + prev = cur*4 + (prev - cur) + // odd pixels = 3*cur + next = cur*4 + (next - cur) + // note the shared term. + int16x8_t curs = vshlq_n_s16(curr, 2); + int16x8_t prvd = vsubq_s16(prev, curr); + int16x8_t nxtd = vsubq_s16(next, curr); + int16x8_t even = vaddq_s16(curs, prvd); + int16x8_t odd = vaddq_s16(curs, nxtd); + + // undo scaling and round, then store with even/odd phases interleaved + uint8x8x2_t o; + o.val[0] = vqrshrun_n_s16(even, 4); + o.val[1] = vqrshrun_n_s16(odd, 4); + vst2_u8(out + i*2, o); +#endif + + // "previous" value for next iter + t1 = 3*in_near[i+7] + in_far[i+7]; + } + + t0 = t1; + t1 = 3*in_near[i] + in_far[i]; + out[i*2] = stbi__div16(3*t1 + t0 + 8); + + for (++i; i < w; ++i) { + t0 = t1; + t1 = 3*in_near[i]+in_far[i]; + out[i*2-1] = stbi__div16(3*t0 + t1 + 8); + out[i*2 ] = stbi__div16(3*t1 + t0 + 8); + } + out[w*2-1] = stbi__div4(t1+2); + + STBI_NOTUSED(hs); + + return out; +} +#endif + +static stbi_uc *stbi__resample_row_generic(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // resample with nearest-neighbor + int i,j; + STBI_NOTUSED(in_far); + for (i=0; i < w; ++i) + for (j=0; j < hs; ++j) + out[i*hs+j] = in_near[i]; + return out; +} + +// this is a reduced-precision calculation of YCbCr-to-RGB introduced +// to make sure the code produces the same results in both SIMD and scalar +#define stbi__float2fixed(x) (((int) ((x) * 4096.0f + 0.5f)) << 8) +static void stbi__YCbCr_to_RGB_row(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step) +{ + int i; + for (i=0; i < count; ++i) { + int y_fixed = (y[i] << 20) + (1<<19); // rounding + int r,g,b; + int cr = pcr[i] - 128; + int cb = pcb[i] - 128; + r = y_fixed + cr* stbi__float2fixed(1.40200f); + g = y_fixed + (cr*-stbi__float2fixed(0.71414f)) + ((cb*-stbi__float2fixed(0.34414f)) & 0xffff0000); + b = y_fixed + cb* stbi__float2fixed(1.77200f); + r >>= 20; + g >>= 20; + b >>= 20; + if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; } + if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; } + if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; } + out[0] = (stbi_uc)r; + out[1] = (stbi_uc)g; + out[2] = (stbi_uc)b; + out[3] = 255; + out += step; + } +} + +#if defined(STBI_SSE2) || defined(STBI_NEON) +static void stbi__YCbCr_to_RGB_simd(stbi_uc *out, stbi_uc const *y, stbi_uc const *pcb, stbi_uc const *pcr, int count, int step) +{ + int i = 0; + +#ifdef STBI_SSE2 + // step == 3 is pretty ugly on the final interleave, and i'm not convinced + // it's useful in practice (you wouldn't use it for textures, for example). + // so just accelerate step == 4 case. + if (step == 4) { + // this is a fairly straightforward implementation and not super-optimized. + __m128i signflip = _mm_set1_epi8(-0x80); + __m128i cr_const0 = _mm_set1_epi16( (short) ( 1.40200f*4096.0f+0.5f)); + __m128i cr_const1 = _mm_set1_epi16( - (short) ( 0.71414f*4096.0f+0.5f)); + __m128i cb_const0 = _mm_set1_epi16( - (short) ( 0.34414f*4096.0f+0.5f)); + __m128i cb_const1 = _mm_set1_epi16( (short) ( 1.77200f*4096.0f+0.5f)); + __m128i y_bias = _mm_set1_epi8((char) (unsigned char) 128); + __m128i xw = _mm_set1_epi16(255); // alpha channel + + for (; i+7 < count; i += 8) { + // load + __m128i y_bytes = _mm_loadl_epi64((__m128i *) (y+i)); + __m128i cr_bytes = _mm_loadl_epi64((__m128i *) (pcr+i)); + __m128i cb_bytes = _mm_loadl_epi64((__m128i *) (pcb+i)); + __m128i cr_biased = _mm_xor_si128(cr_bytes, signflip); // -128 + __m128i cb_biased = _mm_xor_si128(cb_bytes, signflip); // -128 + + // unpack to short (and left-shift cr, cb by 8) + __m128i yw = _mm_unpacklo_epi8(y_bias, y_bytes); + __m128i crw = _mm_unpacklo_epi8(_mm_setzero_si128(), cr_biased); + __m128i cbw = _mm_unpacklo_epi8(_mm_setzero_si128(), cb_biased); + + // color transform + __m128i yws = _mm_srli_epi16(yw, 4); + __m128i cr0 = _mm_mulhi_epi16(cr_const0, crw); + __m128i cb0 = _mm_mulhi_epi16(cb_const0, cbw); + __m128i cb1 = _mm_mulhi_epi16(cbw, cb_const1); + __m128i cr1 = _mm_mulhi_epi16(crw, cr_const1); + __m128i rws = _mm_add_epi16(cr0, yws); + __m128i gwt = _mm_add_epi16(cb0, yws); + __m128i bws = _mm_add_epi16(yws, cb1); + __m128i gws = _mm_add_epi16(gwt, cr1); + + // descale + __m128i rw = _mm_srai_epi16(rws, 4); + __m128i bw = _mm_srai_epi16(bws, 4); + __m128i gw = _mm_srai_epi16(gws, 4); + + // back to byte, set up for transpose + __m128i brb = _mm_packus_epi16(rw, bw); + __m128i gxb = _mm_packus_epi16(gw, xw); + + // transpose to interleave channels + __m128i t0 = _mm_unpacklo_epi8(brb, gxb); + __m128i t1 = _mm_unpackhi_epi8(brb, gxb); + __m128i o0 = _mm_unpacklo_epi16(t0, t1); + __m128i o1 = _mm_unpackhi_epi16(t0, t1); + + // store + _mm_storeu_si128((__m128i *) (out + 0), o0); + _mm_storeu_si128((__m128i *) (out + 16), o1); + out += 32; + } + } +#endif + +#ifdef STBI_NEON + // in this version, step=3 support would be easy to add. but is there demand? + if (step == 4) { + // this is a fairly straightforward implementation and not super-optimized. + uint8x8_t signflip = vdup_n_u8(0x80); + int16x8_t cr_const0 = vdupq_n_s16( (short) ( 1.40200f*4096.0f+0.5f)); + int16x8_t cr_const1 = vdupq_n_s16( - (short) ( 0.71414f*4096.0f+0.5f)); + int16x8_t cb_const0 = vdupq_n_s16( - (short) ( 0.34414f*4096.0f+0.5f)); + int16x8_t cb_const1 = vdupq_n_s16( (short) ( 1.77200f*4096.0f+0.5f)); + + for (; i+7 < count; i += 8) { + // load + uint8x8_t y_bytes = vld1_u8(y + i); + uint8x8_t cr_bytes = vld1_u8(pcr + i); + uint8x8_t cb_bytes = vld1_u8(pcb + i); + int8x8_t cr_biased = vreinterpret_s8_u8(vsub_u8(cr_bytes, signflip)); + int8x8_t cb_biased = vreinterpret_s8_u8(vsub_u8(cb_bytes, signflip)); + + // expand to s16 + int16x8_t yws = vreinterpretq_s16_u16(vshll_n_u8(y_bytes, 4)); + int16x8_t crw = vshll_n_s8(cr_biased, 7); + int16x8_t cbw = vshll_n_s8(cb_biased, 7); + + // color transform + int16x8_t cr0 = vqdmulhq_s16(crw, cr_const0); + int16x8_t cb0 = vqdmulhq_s16(cbw, cb_const0); + int16x8_t cr1 = vqdmulhq_s16(crw, cr_const1); + int16x8_t cb1 = vqdmulhq_s16(cbw, cb_const1); + int16x8_t rws = vaddq_s16(yws, cr0); + int16x8_t gws = vaddq_s16(vaddq_s16(yws, cb0), cr1); + int16x8_t bws = vaddq_s16(yws, cb1); + + // undo scaling, round, convert to byte + uint8x8x4_t o; + o.val[0] = vqrshrun_n_s16(rws, 4); + o.val[1] = vqrshrun_n_s16(gws, 4); + o.val[2] = vqrshrun_n_s16(bws, 4); + o.val[3] = vdup_n_u8(255); + + // store, interleaving r/g/b/a + vst4_u8(out, o); + out += 8*4; + } + } +#endif + + for (; i < count; ++i) { + int y_fixed = (y[i] << 20) + (1<<19); // rounding + int r,g,b; + int cr = pcr[i] - 128; + int cb = pcb[i] - 128; + r = y_fixed + cr* stbi__float2fixed(1.40200f); + g = y_fixed + cr*-stbi__float2fixed(0.71414f) + ((cb*-stbi__float2fixed(0.34414f)) & 0xffff0000); + b = y_fixed + cb* stbi__float2fixed(1.77200f); + r >>= 20; + g >>= 20; + b >>= 20; + if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; } + if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; } + if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; } + out[0] = (stbi_uc)r; + out[1] = (stbi_uc)g; + out[2] = (stbi_uc)b; + out[3] = 255; + out += step; + } +} +#endif + +// set up the kernels +static void stbi__setup_jpeg(stbi__jpeg *j) +{ + j->idct_block_kernel = stbi__idct_block; + j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_row; + j->resample_row_hv_2_kernel = stbi__resample_row_hv_2; + +#ifdef STBI_SSE2 + if (stbi__sse2_available()) { + j->idct_block_kernel = stbi__idct_simd; + j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd; + j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd; + } +#endif + +#ifdef STBI_NEON + j->idct_block_kernel = stbi__idct_simd; + j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd; + j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd; +#endif +} + +// clean up the temporary component buffers +static void stbi__cleanup_jpeg(stbi__jpeg *j) +{ + stbi__free_jpeg_components(j, j->s->img_n, 0); +} + +typedef struct +{ + resample_row_func resample; + stbi_uc *line0,*line1; + int hs,vs; // expansion factor in each axis + int w_lores; // horizontal pixels pre-expansion + int ystep; // how far through vertical expansion we are + int ypos; // which pre-expansion row we're on +} stbi__resample; + +// fast 0..255 * 0..255 => 0..255 rounded multiplication +static stbi_uc stbi__blinn_8x8(stbi_uc x, stbi_uc y) +{ + unsigned int t = x*y + 128; + return (stbi_uc) ((t + (t >>8)) >> 8); +} + +static stbi_uc *load_jpeg_image(stbi__jpeg *z, int *out_x, int *out_y, int *comp, int req_comp) +{ + int n, decode_n, is_rgb; + z->s->img_n = 0; // make stbi__cleanup_jpeg safe + + // validate req_comp + if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error"); + + // load a jpeg image from whichever source, but leave in YCbCr format + if (!stbi__decode_jpeg_image(z)) { stbi__cleanup_jpeg(z); return NULL; } + + // determine actual number of components to generate + n = req_comp ? req_comp : z->s->img_n >= 3 ? 3 : 1; + + is_rgb = z->s->img_n == 3 && (z->rgb == 3 || (z->app14_color_transform == 0 && !z->jfif)); + + if (z->s->img_n == 3 && n < 3 && !is_rgb) + decode_n = 1; + else + decode_n = z->s->img_n; + + // nothing to do if no components requested; check this now to avoid + // accessing uninitialized coutput[0] later + if (decode_n <= 0) { stbi__cleanup_jpeg(z); return NULL; } + + // resample and color-convert + { + int k; + unsigned int i,j; + stbi_uc *output; + stbi_uc *coutput[4] = { NULL, NULL, NULL, NULL }; + + stbi__resample res_comp[4]; + + for (k=0; k < decode_n; ++k) { + stbi__resample *r = &res_comp[k]; + + // allocate line buffer big enough for upsampling off the edges + // with upsample factor of 4 + z->img_comp[k].linebuf = (stbi_uc *) stbi__malloc(z->s->img_x + 3); + if (!z->img_comp[k].linebuf) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); } + + r->hs = z->img_h_max / z->img_comp[k].h; + r->vs = z->img_v_max / z->img_comp[k].v; + r->ystep = r->vs >> 1; + r->w_lores = (z->s->img_x + r->hs-1) / r->hs; + r->ypos = 0; + r->line0 = r->line1 = z->img_comp[k].data; + + if (r->hs == 1 && r->vs == 1) r->resample = resample_row_1; + else if (r->hs == 1 && r->vs == 2) r->resample = stbi__resample_row_v_2; + else if (r->hs == 2 && r->vs == 1) r->resample = stbi__resample_row_h_2; + else if (r->hs == 2 && r->vs == 2) r->resample = z->resample_row_hv_2_kernel; + else r->resample = stbi__resample_row_generic; + } + + // can't error after this so, this is safe + output = (stbi_uc *) stbi__malloc_mad3(n, z->s->img_x, z->s->img_y, 1); + if (!output) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); } + + // now go ahead and resample + for (j=0; j < z->s->img_y; ++j) { + stbi_uc *out = output + n * z->s->img_x * j; + for (k=0; k < decode_n; ++k) { + stbi__resample *r = &res_comp[k]; + int y_bot = r->ystep >= (r->vs >> 1); + coutput[k] = r->resample(z->img_comp[k].linebuf, + y_bot ? r->line1 : r->line0, + y_bot ? r->line0 : r->line1, + r->w_lores, r->hs); + if (++r->ystep >= r->vs) { + r->ystep = 0; + r->line0 = r->line1; + if (++r->ypos < z->img_comp[k].y) + r->line1 += z->img_comp[k].w2; + } + } + if (n >= 3) { + stbi_uc *y = coutput[0]; + if (z->s->img_n == 3) { + if (is_rgb) { + for (i=0; i < z->s->img_x; ++i) { + out[0] = y[i]; + out[1] = coutput[1][i]; + out[2] = coutput[2][i]; + out[3] = 255; + out += n; + } + } else { + z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n); + } + } else if (z->s->img_n == 4) { + if (z->app14_color_transform == 0) { // CMYK + for (i=0; i < z->s->img_x; ++i) { + stbi_uc m = coutput[3][i]; + out[0] = stbi__blinn_8x8(coutput[0][i], m); + out[1] = stbi__blinn_8x8(coutput[1][i], m); + out[2] = stbi__blinn_8x8(coutput[2][i], m); + out[3] = 255; + out += n; + } + } else if (z->app14_color_transform == 2) { // YCCK + z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n); + for (i=0; i < z->s->img_x; ++i) { + stbi_uc m = coutput[3][i]; + out[0] = stbi__blinn_8x8(255 - out[0], m); + out[1] = stbi__blinn_8x8(255 - out[1], m); + out[2] = stbi__blinn_8x8(255 - out[2], m); + out += n; + } + } else { // YCbCr + alpha? Ignore the fourth channel for now + z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n); + } + } else + for (i=0; i < z->s->img_x; ++i) { + out[0] = out[1] = out[2] = y[i]; + out[3] = 255; // not used if n==3 + out += n; + } + } else { + if (is_rgb) { + if (n == 1) + for (i=0; i < z->s->img_x; ++i) + *out++ = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]); + else { + for (i=0; i < z->s->img_x; ++i, out += 2) { + out[0] = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]); + out[1] = 255; + } + } + } else if (z->s->img_n == 4 && z->app14_color_transform == 0) { + for (i=0; i < z->s->img_x; ++i) { + stbi_uc m = coutput[3][i]; + stbi_uc r = stbi__blinn_8x8(coutput[0][i], m); + stbi_uc g = stbi__blinn_8x8(coutput[1][i], m); + stbi_uc b = stbi__blinn_8x8(coutput[2][i], m); + out[0] = stbi__compute_y(r, g, b); + out[1] = 255; + out += n; + } + } else if (z->s->img_n == 4 && z->app14_color_transform == 2) { + for (i=0; i < z->s->img_x; ++i) { + out[0] = stbi__blinn_8x8(255 - coutput[0][i], coutput[3][i]); + out[1] = 255; + out += n; + } + } else { + stbi_uc *y = coutput[0]; + if (n == 1) + for (i=0; i < z->s->img_x; ++i) out[i] = y[i]; + else + for (i=0; i < z->s->img_x; ++i) { *out++ = y[i]; *out++ = 255; } + } + } + } + stbi__cleanup_jpeg(z); + *out_x = z->s->img_x; + *out_y = z->s->img_y; + if (comp) *comp = z->s->img_n >= 3 ? 3 : 1; // report original components, not output + return output; + } +} + +static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + unsigned char* result; + stbi__jpeg* j = (stbi__jpeg*) stbi__malloc(sizeof(stbi__jpeg)); + if (!j) return stbi__errpuc("outofmem", "Out of memory"); + memset(j, 0, sizeof(stbi__jpeg)); + STBI_NOTUSED(ri); + j->s = s; + stbi__setup_jpeg(j); + result = load_jpeg_image(j, x,y,comp,req_comp); + STBI_FREE(j); + return result; +} + +static int stbi__jpeg_test(stbi__context *s) +{ + int r; + stbi__jpeg* j = (stbi__jpeg*)stbi__malloc(sizeof(stbi__jpeg)); + if (!j) return stbi__err("outofmem", "Out of memory"); + memset(j, 0, sizeof(stbi__jpeg)); + j->s = s; + stbi__setup_jpeg(j); + r = stbi__decode_jpeg_header(j, STBI__SCAN_type); + stbi__rewind(s); + STBI_FREE(j); + return r; +} + +static int stbi__jpeg_info_raw(stbi__jpeg *j, int *x, int *y, int *comp) +{ + if (!stbi__decode_jpeg_header(j, STBI__SCAN_header)) { + stbi__rewind( j->s ); + return 0; + } + if (x) *x = j->s->img_x; + if (y) *y = j->s->img_y; + if (comp) *comp = j->s->img_n >= 3 ? 3 : 1; + return 1; +} + +static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp) +{ + int result; + stbi__jpeg* j = (stbi__jpeg*) (stbi__malloc(sizeof(stbi__jpeg))); + if (!j) return stbi__err("outofmem", "Out of memory"); + memset(j, 0, sizeof(stbi__jpeg)); + j->s = s; + result = stbi__jpeg_info_raw(j, x, y, comp); + STBI_FREE(j); + return result; +} +#endif + +// public domain zlib decode v0.2 Sean Barrett 2006-11-18 +// simple implementation +// - all input must be provided in an upfront buffer +// - all output is written to a single output buffer (can malloc/realloc) +// performance +// - fast huffman + +#ifndef STBI_NO_ZLIB + +// fast-way is faster to check than jpeg huffman, but slow way is slower +#define STBI__ZFAST_BITS 9 // accelerate all cases in default tables +#define STBI__ZFAST_MASK ((1 << STBI__ZFAST_BITS) - 1) +#define STBI__ZNSYMS 288 // number of symbols in literal/length alphabet + +// zlib-style huffman encoding +// (jpegs packs from left, zlib from right, so can't share code) +typedef struct +{ + stbi__uint16 fast[1 << STBI__ZFAST_BITS]; + stbi__uint16 firstcode[16]; + int maxcode[17]; + stbi__uint16 firstsymbol[16]; + stbi_uc size[STBI__ZNSYMS]; + stbi__uint16 value[STBI__ZNSYMS]; +} stbi__zhuffman; + +stbi_inline static int stbi__bitreverse16(int n) +{ + n = ((n & 0xAAAA) >> 1) | ((n & 0x5555) << 1); + n = ((n & 0xCCCC) >> 2) | ((n & 0x3333) << 2); + n = ((n & 0xF0F0) >> 4) | ((n & 0x0F0F) << 4); + n = ((n & 0xFF00) >> 8) | ((n & 0x00FF) << 8); + return n; +} + +stbi_inline static int stbi__bit_reverse(int v, int bits) +{ + STBI_ASSERT(bits <= 16); + // to bit reverse n bits, reverse 16 and shift + // e.g. 11 bits, bit reverse and shift away 5 + return stbi__bitreverse16(v) >> (16-bits); +} + +static int stbi__zbuild_huffman(stbi__zhuffman *z, const stbi_uc *sizelist, int num) +{ + int i,k=0; + int code, next_code[16], sizes[17]; + + // DEFLATE spec for generating codes + memset(sizes, 0, sizeof(sizes)); + memset(z->fast, 0, sizeof(z->fast)); + for (i=0; i < num; ++i) + ++sizes[sizelist[i]]; + sizes[0] = 0; + for (i=1; i < 16; ++i) + if (sizes[i] > (1 << i)) + return stbi__err("bad sizes", "Corrupt PNG"); + code = 0; + for (i=1; i < 16; ++i) { + next_code[i] = code; + z->firstcode[i] = (stbi__uint16) code; + z->firstsymbol[i] = (stbi__uint16) k; + code = (code + sizes[i]); + if (sizes[i]) + if (code-1 >= (1 << i)) return stbi__err("bad codelengths","Corrupt PNG"); + z->maxcode[i] = code << (16-i); // preshift for inner loop + code <<= 1; + k += sizes[i]; + } + z->maxcode[16] = 0x10000; // sentinel + for (i=0; i < num; ++i) { + int s = sizelist[i]; + if (s) { + int c = next_code[s] - z->firstcode[s] + z->firstsymbol[s]; + stbi__uint16 fastv = (stbi__uint16) ((s << 9) | i); + z->size [c] = (stbi_uc ) s; + z->value[c] = (stbi__uint16) i; + if (s <= STBI__ZFAST_BITS) { + int j = stbi__bit_reverse(next_code[s],s); + while (j < (1 << STBI__ZFAST_BITS)) { + z->fast[j] = fastv; + j += (1 << s); + } + } + ++next_code[s]; + } + } + return 1; +} + +// zlib-from-memory implementation for PNG reading +// because PNG allows splitting the zlib stream arbitrarily, +// and it's annoying structurally to have PNG call ZLIB call PNG, +// we require PNG read all the IDATs and combine them into a single +// memory buffer + +typedef struct +{ + stbi_uc *zbuffer, *zbuffer_end; + int num_bits; + int hit_zeof_once; + stbi__uint32 code_buffer; + + char *zout; + char *zout_start; + char *zout_end; + int z_expandable; + + stbi__zhuffman z_length, z_distance; +} stbi__zbuf; + +stbi_inline static int stbi__zeof(stbi__zbuf *z) +{ + return (z->zbuffer >= z->zbuffer_end); +} + +stbi_inline static stbi_uc stbi__zget8(stbi__zbuf *z) +{ + return stbi__zeof(z) ? 0 : *z->zbuffer++; +} + +static void stbi__fill_bits(stbi__zbuf *z) +{ + do { + if (z->code_buffer >= (1U << z->num_bits)) { + z->zbuffer = z->zbuffer_end; /* treat this as EOF so we fail. */ + return; + } + z->code_buffer |= (unsigned int) stbi__zget8(z) << z->num_bits; + z->num_bits += 8; + } while (z->num_bits <= 24); +} + +stbi_inline static unsigned int stbi__zreceive(stbi__zbuf *z, int n) +{ + unsigned int k; + if (z->num_bits < n) stbi__fill_bits(z); + k = z->code_buffer & ((1 << n) - 1); + z->code_buffer >>= n; + z->num_bits -= n; + return k; +} + +static int stbi__zhuffman_decode_slowpath(stbi__zbuf *a, stbi__zhuffman *z) +{ + int b,s,k; + // not resolved by fast table, so compute it the slow way + // use jpeg approach, which requires MSbits at top + k = stbi__bit_reverse(a->code_buffer, 16); + for (s=STBI__ZFAST_BITS+1; ; ++s) + if (k < z->maxcode[s]) + break; + if (s >= 16) return -1; // invalid code! + // code size is s, so: + b = (k >> (16-s)) - z->firstcode[s] + z->firstsymbol[s]; + if (b >= STBI__ZNSYMS) return -1; // some data was corrupt somewhere! + if (z->size[b] != s) return -1; // was originally an assert, but report failure instead. + a->code_buffer >>= s; + a->num_bits -= s; + return z->value[b]; +} + +stbi_inline static int stbi__zhuffman_decode(stbi__zbuf *a, stbi__zhuffman *z) +{ + int b,s; + if (a->num_bits < 16) { + if (stbi__zeof(a)) { + if (!a->hit_zeof_once) { + // This is the first time we hit eof, insert 16 extra padding btis + // to allow us to keep going; if we actually consume any of them + // though, that is invalid data. This is caught later. + a->hit_zeof_once = 1; + a->num_bits += 16; // add 16 implicit zero bits + } else { + // We already inserted our extra 16 padding bits and are again + // out, this stream is actually prematurely terminated. + return -1; + } + } else { + stbi__fill_bits(a); + } + } + b = z->fast[a->code_buffer & STBI__ZFAST_MASK]; + if (b) { + s = b >> 9; + a->code_buffer >>= s; + a->num_bits -= s; + return b & 511; + } + return stbi__zhuffman_decode_slowpath(a, z); +} + +static int stbi__zexpand(stbi__zbuf *z, char *zout, int n) // need to make room for n bytes +{ + char *q; + unsigned int cur, limit, old_limit; + z->zout = zout; + if (!z->z_expandable) return stbi__err("output buffer limit","Corrupt PNG"); + cur = (unsigned int) (z->zout - z->zout_start); + limit = old_limit = (unsigned) (z->zout_end - z->zout_start); + if (UINT_MAX - cur < (unsigned) n) return stbi__err("outofmem", "Out of memory"); + while (cur + n > limit) { + if(limit > UINT_MAX / 2) return stbi__err("outofmem", "Out of memory"); + limit *= 2; + } + q = (char *) STBI_REALLOC_SIZED(z->zout_start, old_limit, limit); + STBI_NOTUSED(old_limit); + if (q == NULL) return stbi__err("outofmem", "Out of memory"); + z->zout_start = q; + z->zout = q + cur; + z->zout_end = q + limit; + return 1; +} + +static const int stbi__zlength_base[31] = { + 3,4,5,6,7,8,9,10,11,13, + 15,17,19,23,27,31,35,43,51,59, + 67,83,99,115,131,163,195,227,258,0,0 }; + +static const int stbi__zlength_extra[31]= +{ 0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0,0,0 }; + +static const int stbi__zdist_base[32] = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193, +257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577,0,0}; + +static const int stbi__zdist_extra[32] = +{ 0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13}; + +static int stbi__parse_huffman_block(stbi__zbuf *a) +{ + char *zout = a->zout; + for(;;) { + int z = stbi__zhuffman_decode(a, &a->z_length); + if (z < 256) { + if (z < 0) return stbi__err("bad huffman code","Corrupt PNG"); // error in huffman codes + if (zout >= a->zout_end) { + if (!stbi__zexpand(a, zout, 1)) return 0; + zout = a->zout; + } + *zout++ = (char) z; + } else { + stbi_uc *p; + int len,dist; + if (z == 256) { + a->zout = zout; + if (a->hit_zeof_once && a->num_bits < 16) { + // The first time we hit zeof, we inserted 16 extra zero bits into our bit + // buffer so the decoder can just do its speculative decoding. But if we + // actually consumed any of those bits (which is the case when num_bits < 16), + // the stream actually read past the end so it is malformed. + return stbi__err("unexpected end","Corrupt PNG"); + } + return 1; + } + if (z >= 286) return stbi__err("bad huffman code","Corrupt PNG"); // per DEFLATE, length codes 286 and 287 must not appear in compressed data + z -= 257; + len = stbi__zlength_base[z]; + if (stbi__zlength_extra[z]) len += stbi__zreceive(a, stbi__zlength_extra[z]); + z = stbi__zhuffman_decode(a, &a->z_distance); + if (z < 0 || z >= 30) return stbi__err("bad huffman code","Corrupt PNG"); // per DEFLATE, distance codes 30 and 31 must not appear in compressed data + dist = stbi__zdist_base[z]; + if (stbi__zdist_extra[z]) dist += stbi__zreceive(a, stbi__zdist_extra[z]); + if (zout - a->zout_start < dist) return stbi__err("bad dist","Corrupt PNG"); + if (len > a->zout_end - zout) { + if (!stbi__zexpand(a, zout, len)) return 0; + zout = a->zout; + } + p = (stbi_uc *) (zout - dist); + if (dist == 1) { // run of one byte; common in images. + stbi_uc v = *p; + if (len) { do *zout++ = v; while (--len); } + } else { + if (len) { do *zout++ = *p++; while (--len); } + } + } + } +} + +static int stbi__compute_huffman_codes(stbi__zbuf *a) +{ + static const stbi_uc length_dezigzag[19] = { 16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15 }; + stbi__zhuffman z_codelength; + stbi_uc lencodes[286+32+137];//padding for maximum single op + stbi_uc codelength_sizes[19]; + int i,n; + + int hlit = stbi__zreceive(a,5) + 257; + int hdist = stbi__zreceive(a,5) + 1; + int hclen = stbi__zreceive(a,4) + 4; + int ntot = hlit + hdist; + + memset(codelength_sizes, 0, sizeof(codelength_sizes)); + for (i=0; i < hclen; ++i) { + int s = stbi__zreceive(a,3); + codelength_sizes[length_dezigzag[i]] = (stbi_uc) s; + } + if (!stbi__zbuild_huffman(&z_codelength, codelength_sizes, 19)) return 0; + + n = 0; + while (n < ntot) { + int c = stbi__zhuffman_decode(a, &z_codelength); + if (c < 0 || c >= 19) return stbi__err("bad codelengths", "Corrupt PNG"); + if (c < 16) + lencodes[n++] = (stbi_uc) c; + else { + stbi_uc fill = 0; + if (c == 16) { + c = stbi__zreceive(a,2)+3; + if (n == 0) return stbi__err("bad codelengths", "Corrupt PNG"); + fill = lencodes[n-1]; + } else if (c == 17) { + c = stbi__zreceive(a,3)+3; + } else if (c == 18) { + c = stbi__zreceive(a,7)+11; + } else { + return stbi__err("bad codelengths", "Corrupt PNG"); + } + if (ntot - n < c) return stbi__err("bad codelengths", "Corrupt PNG"); + memset(lencodes+n, fill, c); + n += c; + } + } + if (n != ntot) return stbi__err("bad codelengths","Corrupt PNG"); + if (!stbi__zbuild_huffman(&a->z_length, lencodes, hlit)) return 0; + if (!stbi__zbuild_huffman(&a->z_distance, lencodes+hlit, hdist)) return 0; + return 1; +} + +static int stbi__parse_uncompressed_block(stbi__zbuf *a) +{ + stbi_uc header[4]; + int len,nlen,k; + if (a->num_bits & 7) + stbi__zreceive(a, a->num_bits & 7); // discard + // drain the bit-packed data into header + k = 0; + while (a->num_bits > 0) { + header[k++] = (stbi_uc) (a->code_buffer & 255); // suppress MSVC run-time check + a->code_buffer >>= 8; + a->num_bits -= 8; + } + if (a->num_bits < 0) return stbi__err("zlib corrupt","Corrupt PNG"); + // now fill header the normal way + while (k < 4) + header[k++] = stbi__zget8(a); + len = header[1] * 256 + header[0]; + nlen = header[3] * 256 + header[2]; + if (nlen != (len ^ 0xffff)) return stbi__err("zlib corrupt","Corrupt PNG"); + if (a->zbuffer + len > a->zbuffer_end) return stbi__err("read past buffer","Corrupt PNG"); + if (a->zout + len > a->zout_end) + if (!stbi__zexpand(a, a->zout, len)) return 0; + memcpy(a->zout, a->zbuffer, len); + a->zbuffer += len; + a->zout += len; + return 1; +} + +static int stbi__parse_zlib_header(stbi__zbuf *a) +{ + int cmf = stbi__zget8(a); + int cm = cmf & 15; + /* int cinfo = cmf >> 4; */ + int flg = stbi__zget8(a); + if (stbi__zeof(a)) return stbi__err("bad zlib header","Corrupt PNG"); // zlib spec + if ((cmf*256+flg) % 31 != 0) return stbi__err("bad zlib header","Corrupt PNG"); // zlib spec + if (flg & 32) return stbi__err("no preset dict","Corrupt PNG"); // preset dictionary not allowed in png + if (cm != 8) return stbi__err("bad compression","Corrupt PNG"); // DEFLATE required for png + // window = 1 << (8 + cinfo)... but who cares, we fully buffer output + return 1; +} + +static const stbi_uc stbi__zdefault_length[STBI__ZNSYMS] = +{ + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, + 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, + 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, + 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, + 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, 7,7,7,7,7,7,7,7,8,8,8,8,8,8,8,8 +}; +static const stbi_uc stbi__zdefault_distance[32] = +{ + 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5 +}; +/* +Init algorithm: +{ + int i; // use <= to match clearly with spec + for (i=0; i <= 143; ++i) stbi__zdefault_length[i] = 8; + for ( ; i <= 255; ++i) stbi__zdefault_length[i] = 9; + for ( ; i <= 279; ++i) stbi__zdefault_length[i] = 7; + for ( ; i <= 287; ++i) stbi__zdefault_length[i] = 8; + + for (i=0; i <= 31; ++i) stbi__zdefault_distance[i] = 5; +} +*/ + +static int stbi__parse_zlib(stbi__zbuf *a, int parse_header) +{ + int final, type; + if (parse_header) + if (!stbi__parse_zlib_header(a)) return 0; + a->num_bits = 0; + a->code_buffer = 0; + a->hit_zeof_once = 0; + do { + final = stbi__zreceive(a,1); + type = stbi__zreceive(a,2); + if (type == 0) { + if (!stbi__parse_uncompressed_block(a)) return 0; + } else if (type == 3) { + return 0; + } else { + if (type == 1) { + // use fixed code lengths + if (!stbi__zbuild_huffman(&a->z_length , stbi__zdefault_length , STBI__ZNSYMS)) return 0; + if (!stbi__zbuild_huffman(&a->z_distance, stbi__zdefault_distance, 32)) return 0; + } else { + if (!stbi__compute_huffman_codes(a)) return 0; + } + if (!stbi__parse_huffman_block(a)) return 0; + } + } while (!final); + return 1; +} + +static int stbi__do_zlib(stbi__zbuf *a, char *obuf, int olen, int exp, int parse_header) +{ + a->zout_start = obuf; + a->zout = obuf; + a->zout_end = obuf + olen; + a->z_expandable = exp; + + return stbi__parse_zlib(a, parse_header); +} + +STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen) +{ + stbi__zbuf a; + char *p = (char *) stbi__malloc(initial_size); + if (p == NULL) return NULL; + a.zbuffer = (stbi_uc *) buffer; + a.zbuffer_end = (stbi_uc *) buffer + len; + if (stbi__do_zlib(&a, p, initial_size, 1, 1)) { + if (outlen) *outlen = (int) (a.zout - a.zout_start); + return a.zout_start; + } else { + STBI_FREE(a.zout_start); + return NULL; + } +} + +STBIDEF char *stbi_zlib_decode_malloc(char const *buffer, int len, int *outlen) +{ + return stbi_zlib_decode_malloc_guesssize(buffer, len, 16384, outlen); +} + +STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header) +{ + stbi__zbuf a; + char *p = (char *) stbi__malloc(initial_size); + if (p == NULL) return NULL; + a.zbuffer = (stbi_uc *) buffer; + a.zbuffer_end = (stbi_uc *) buffer + len; + if (stbi__do_zlib(&a, p, initial_size, 1, parse_header)) { + if (outlen) *outlen = (int) (a.zout - a.zout_start); + return a.zout_start; + } else { + STBI_FREE(a.zout_start); + return NULL; + } +} + +STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, char const *ibuffer, int ilen) +{ + stbi__zbuf a; + a.zbuffer = (stbi_uc *) ibuffer; + a.zbuffer_end = (stbi_uc *) ibuffer + ilen; + if (stbi__do_zlib(&a, obuffer, olen, 0, 1)) + return (int) (a.zout - a.zout_start); + else + return -1; +} + +STBIDEF char *stbi_zlib_decode_noheader_malloc(char const *buffer, int len, int *outlen) +{ + stbi__zbuf a; + char *p = (char *) stbi__malloc(16384); + if (p == NULL) return NULL; + a.zbuffer = (stbi_uc *) buffer; + a.zbuffer_end = (stbi_uc *) buffer+len; + if (stbi__do_zlib(&a, p, 16384, 1, 0)) { + if (outlen) *outlen = (int) (a.zout - a.zout_start); + return a.zout_start; + } else { + STBI_FREE(a.zout_start); + return NULL; + } +} + +STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen) +{ + stbi__zbuf a; + a.zbuffer = (stbi_uc *) ibuffer; + a.zbuffer_end = (stbi_uc *) ibuffer + ilen; + if (stbi__do_zlib(&a, obuffer, olen, 0, 0)) + return (int) (a.zout - a.zout_start); + else + return -1; +} +#endif + +// public domain "baseline" PNG decoder v0.10 Sean Barrett 2006-11-18 +// simple implementation +// - only 8-bit samples +// - no CRC checking +// - allocates lots of intermediate memory +// - avoids problem of streaming data between subsystems +// - avoids explicit window management +// performance +// - uses stb_zlib, a PD zlib implementation with fast huffman decoding + +#ifndef STBI_NO_PNG +typedef struct +{ + stbi__uint32 length; + stbi__uint32 type; +} stbi__pngchunk; + +static stbi__pngchunk stbi__get_chunk_header(stbi__context *s) +{ + stbi__pngchunk c; + c.length = stbi__get32be(s); + c.type = stbi__get32be(s); + return c; +} + +static int stbi__check_png_header(stbi__context *s) +{ + static const stbi_uc png_sig[8] = { 137,80,78,71,13,10,26,10 }; + int i; + for (i=0; i < 8; ++i) + if (stbi__get8(s) != png_sig[i]) return stbi__err("bad png sig","Not a PNG"); + return 1; +} + +typedef struct +{ + stbi__context *s; + stbi_uc *idata, *expanded, *out; + int depth; +} stbi__png; + + +enum { + STBI__F_none=0, + STBI__F_sub=1, + STBI__F_up=2, + STBI__F_avg=3, + STBI__F_paeth=4, + // synthetic filter used for first scanline to avoid needing a dummy row of 0s + STBI__F_avg_first +}; + +static stbi_uc first_row_filter[5] = +{ + STBI__F_none, + STBI__F_sub, + STBI__F_none, + STBI__F_avg_first, + STBI__F_sub // Paeth with b=c=0 turns out to be equivalent to sub +}; + +static int stbi__paeth(int a, int b, int c) +{ + // This formulation looks very different from the reference in the PNG spec, but is + // actually equivalent and has favorable data dependencies and admits straightforward + // generation of branch-free code, which helps performance significantly. + int thresh = c*3 - (a + b); + int lo = a < b ? a : b; + int hi = a < b ? b : a; + int t0 = (hi <= thresh) ? lo : c; + int t1 = (thresh <= lo) ? hi : t0; + return t1; +} + +static const stbi_uc stbi__depth_scale_table[9] = { 0, 0xff, 0x55, 0, 0x11, 0,0,0, 0x01 }; + +// adds an extra all-255 alpha channel +// dest == src is legal +// img_n must be 1 or 3 +static void stbi__create_png_alpha_expand8(stbi_uc *dest, stbi_uc *src, stbi__uint32 x, int img_n) +{ + int i; + // must process data backwards since we allow dest==src + if (img_n == 1) { + for (i=x-1; i >= 0; --i) { + dest[i*2+1] = 255; + dest[i*2+0] = src[i]; + } + } else { + STBI_ASSERT(img_n == 3); + for (i=x-1; i >= 0; --i) { + dest[i*4+3] = 255; + dest[i*4+2] = src[i*3+2]; + dest[i*4+1] = src[i*3+1]; + dest[i*4+0] = src[i*3+0]; + } + } +} + +// create the png data from post-deflated data +static int stbi__create_png_image_raw(stbi__png *a, stbi_uc *raw, stbi__uint32 raw_len, int out_n, stbi__uint32 x, stbi__uint32 y, int depth, int color) +{ + int bytes = (depth == 16 ? 2 : 1); + stbi__context *s = a->s; + stbi__uint32 i,j,stride = x*out_n*bytes; + stbi__uint32 img_len, img_width_bytes; + stbi_uc *filter_buf; + int all_ok = 1; + int k; + int img_n = s->img_n; // copy it into a local for later + + int output_bytes = out_n*bytes; + int filter_bytes = img_n*bytes; + int width = x; + + STBI_ASSERT(out_n == s->img_n || out_n == s->img_n+1); + a->out = (stbi_uc *) stbi__malloc_mad3(x, y, output_bytes, 0); // extra bytes to write off the end into + if (!a->out) return stbi__err("outofmem", "Out of memory"); + + // note: error exits here don't need to clean up a->out individually, + // stbi__do_png always does on error. + if (!stbi__mad3sizes_valid(img_n, x, depth, 7)) return stbi__err("too large", "Corrupt PNG"); + img_width_bytes = (((img_n * x * depth) + 7) >> 3); + if (!stbi__mad2sizes_valid(img_width_bytes, y, img_width_bytes)) return stbi__err("too large", "Corrupt PNG"); + img_len = (img_width_bytes + 1) * y; + + // we used to check for exact match between raw_len and img_len on non-interlaced PNGs, + // but issue #276 reported a PNG in the wild that had extra data at the end (all zeros), + // so just check for raw_len < img_len always. + if (raw_len < img_len) return stbi__err("not enough pixels","Corrupt PNG"); + + // Allocate two scan lines worth of filter workspace buffer. + filter_buf = (stbi_uc *) stbi__malloc_mad2(img_width_bytes, 2, 0); + if (!filter_buf) return stbi__err("outofmem", "Out of memory"); + + // Filtering for low-bit-depth images + if (depth < 8) { + filter_bytes = 1; + width = img_width_bytes; + } + + for (j=0; j < y; ++j) { + // cur/prior filter buffers alternate + stbi_uc *cur = filter_buf + (j & 1)*img_width_bytes; + stbi_uc *prior = filter_buf + (~j & 1)*img_width_bytes; + stbi_uc *dest = a->out + stride*j; + int nk = width * filter_bytes; + int filter = *raw++; + + // check filter type + if (filter > 4) { + all_ok = stbi__err("invalid filter","Corrupt PNG"); + break; + } + + // if first row, use special filter that doesn't sample previous row + if (j == 0) filter = first_row_filter[filter]; + + // perform actual filtering + switch (filter) { + case STBI__F_none: + memcpy(cur, raw, nk); + break; + case STBI__F_sub: + memcpy(cur, raw, filter_bytes); + for (k = filter_bytes; k < nk; ++k) + cur[k] = STBI__BYTECAST(raw[k] + cur[k-filter_bytes]); + break; + case STBI__F_up: + for (k = 0; k < nk; ++k) + cur[k] = STBI__BYTECAST(raw[k] + prior[k]); + break; + case STBI__F_avg: + for (k = 0; k < filter_bytes; ++k) + cur[k] = STBI__BYTECAST(raw[k] + (prior[k]>>1)); + for (k = filter_bytes; k < nk; ++k) + cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k-filter_bytes])>>1)); + break; + case STBI__F_paeth: + for (k = 0; k < filter_bytes; ++k) + cur[k] = STBI__BYTECAST(raw[k] + prior[k]); // prior[k] == stbi__paeth(0,prior[k],0) + for (k = filter_bytes; k < nk; ++k) + cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-filter_bytes], prior[k], prior[k-filter_bytes])); + break; + case STBI__F_avg_first: + memcpy(cur, raw, filter_bytes); + for (k = filter_bytes; k < nk; ++k) + cur[k] = STBI__BYTECAST(raw[k] + (cur[k-filter_bytes] >> 1)); + break; + } + + raw += nk; + + // expand decoded bits in cur to dest, also adding an extra alpha channel if desired + if (depth < 8) { + stbi_uc scale = (color == 0) ? stbi__depth_scale_table[depth] : 1; // scale grayscale values to 0..255 range + stbi_uc *in = cur; + stbi_uc *out = dest; + stbi_uc inb = 0; + stbi__uint32 nsmp = x*img_n; + + // expand bits to bytes first + if (depth == 4) { + for (i=0; i < nsmp; ++i) { + if ((i & 1) == 0) inb = *in++; + *out++ = scale * (inb >> 4); + inb <<= 4; + } + } else if (depth == 2) { + for (i=0; i < nsmp; ++i) { + if ((i & 3) == 0) inb = *in++; + *out++ = scale * (inb >> 6); + inb <<= 2; + } + } else { + STBI_ASSERT(depth == 1); + for (i=0; i < nsmp; ++i) { + if ((i & 7) == 0) inb = *in++; + *out++ = scale * (inb >> 7); + inb <<= 1; + } + } + + // insert alpha=255 values if desired + if (img_n != out_n) + stbi__create_png_alpha_expand8(dest, dest, x, img_n); + } else if (depth == 8) { + if (img_n == out_n) + memcpy(dest, cur, x*img_n); + else + stbi__create_png_alpha_expand8(dest, cur, x, img_n); + } else if (depth == 16) { + // convert the image data from big-endian to platform-native + stbi__uint16 *dest16 = (stbi__uint16*)dest; + stbi__uint32 nsmp = x*img_n; + + if (img_n == out_n) { + for (i = 0; i < nsmp; ++i, ++dest16, cur += 2) + *dest16 = (cur[0] << 8) | cur[1]; + } else { + STBI_ASSERT(img_n+1 == out_n); + if (img_n == 1) { + for (i = 0; i < x; ++i, dest16 += 2, cur += 2) { + dest16[0] = (cur[0] << 8) | cur[1]; + dest16[1] = 0xffff; + } + } else { + STBI_ASSERT(img_n == 3); + for (i = 0; i < x; ++i, dest16 += 4, cur += 6) { + dest16[0] = (cur[0] << 8) | cur[1]; + dest16[1] = (cur[2] << 8) | cur[3]; + dest16[2] = (cur[4] << 8) | cur[5]; + dest16[3] = 0xffff; + } + } + } + } + } + + STBI_FREE(filter_buf); + if (!all_ok) return 0; + + return 1; +} + +static int stbi__create_png_image(stbi__png *a, stbi_uc *image_data, stbi__uint32 image_data_len, int out_n, int depth, int color, int interlaced) +{ + int bytes = (depth == 16 ? 2 : 1); + int out_bytes = out_n * bytes; + stbi_uc *final; + int p; + if (!interlaced) + return stbi__create_png_image_raw(a, image_data, image_data_len, out_n, a->s->img_x, a->s->img_y, depth, color); + + // de-interlacing + final = (stbi_uc *) stbi__malloc_mad3(a->s->img_x, a->s->img_y, out_bytes, 0); + if (!final) return stbi__err("outofmem", "Out of memory"); + for (p=0; p < 7; ++p) { + int xorig[] = { 0,4,0,2,0,1,0 }; + int yorig[] = { 0,0,4,0,2,0,1 }; + int xspc[] = { 8,8,4,4,2,2,1 }; + int yspc[] = { 8,8,8,4,4,2,2 }; + int i,j,x,y; + // pass1_x[4] = 0, pass1_x[5] = 1, pass1_x[12] = 1 + x = (a->s->img_x - xorig[p] + xspc[p]-1) / xspc[p]; + y = (a->s->img_y - yorig[p] + yspc[p]-1) / yspc[p]; + if (x && y) { + stbi__uint32 img_len = ((((a->s->img_n * x * depth) + 7) >> 3) + 1) * y; + if (!stbi__create_png_image_raw(a, image_data, image_data_len, out_n, x, y, depth, color)) { + STBI_FREE(final); + return 0; + } + for (j=0; j < y; ++j) { + for (i=0; i < x; ++i) { + int out_y = j*yspc[p]+yorig[p]; + int out_x = i*xspc[p]+xorig[p]; + memcpy(final + out_y*a->s->img_x*out_bytes + out_x*out_bytes, + a->out + (j*x+i)*out_bytes, out_bytes); + } + } + STBI_FREE(a->out); + image_data += img_len; + image_data_len -= img_len; + } + } + a->out = final; + + return 1; +} + +static int stbi__compute_transparency(stbi__png *z, stbi_uc tc[3], int out_n) +{ + stbi__context *s = z->s; + stbi__uint32 i, pixel_count = s->img_x * s->img_y; + stbi_uc *p = z->out; + + // compute color-based transparency, assuming we've + // already got 255 as the alpha value in the output + STBI_ASSERT(out_n == 2 || out_n == 4); + + if (out_n == 2) { + for (i=0; i < pixel_count; ++i) { + p[1] = (p[0] == tc[0] ? 0 : 255); + p += 2; + } + } else { + for (i=0; i < pixel_count; ++i) { + if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2]) + p[3] = 0; + p += 4; + } + } + return 1; +} + +static int stbi__compute_transparency16(stbi__png *z, stbi__uint16 tc[3], int out_n) +{ + stbi__context *s = z->s; + stbi__uint32 i, pixel_count = s->img_x * s->img_y; + stbi__uint16 *p = (stbi__uint16*) z->out; + + // compute color-based transparency, assuming we've + // already got 65535 as the alpha value in the output + STBI_ASSERT(out_n == 2 || out_n == 4); + + if (out_n == 2) { + for (i = 0; i < pixel_count; ++i) { + p[1] = (p[0] == tc[0] ? 0 : 65535); + p += 2; + } + } else { + for (i = 0; i < pixel_count; ++i) { + if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2]) + p[3] = 0; + p += 4; + } + } + return 1; +} + +static int stbi__expand_png_palette(stbi__png *a, stbi_uc *palette, int len, int pal_img_n) +{ + stbi__uint32 i, pixel_count = a->s->img_x * a->s->img_y; + stbi_uc *p, *temp_out, *orig = a->out; + + p = (stbi_uc *) stbi__malloc_mad2(pixel_count, pal_img_n, 0); + if (p == NULL) return stbi__err("outofmem", "Out of memory"); + + // between here and free(out) below, exitting would leak + temp_out = p; + + if (pal_img_n == 3) { + for (i=0; i < pixel_count; ++i) { + int n = orig[i]*4; + p[0] = palette[n ]; + p[1] = palette[n+1]; + p[2] = palette[n+2]; + p += 3; + } + } else { + for (i=0; i < pixel_count; ++i) { + int n = orig[i]*4; + p[0] = palette[n ]; + p[1] = palette[n+1]; + p[2] = palette[n+2]; + p[3] = palette[n+3]; + p += 4; + } + } + STBI_FREE(a->out); + a->out = temp_out; + + STBI_NOTUSED(len); + + return 1; +} + +static int stbi__unpremultiply_on_load_global = 0; +static int stbi__de_iphone_flag_global = 0; + +STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply) +{ + stbi__unpremultiply_on_load_global = flag_true_if_should_unpremultiply; +} + +STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert) +{ + stbi__de_iphone_flag_global = flag_true_if_should_convert; +} + +#ifndef STBI_THREAD_LOCAL +#define stbi__unpremultiply_on_load stbi__unpremultiply_on_load_global +#define stbi__de_iphone_flag stbi__de_iphone_flag_global +#else +static STBI_THREAD_LOCAL int stbi__unpremultiply_on_load_local, stbi__unpremultiply_on_load_set; +static STBI_THREAD_LOCAL int stbi__de_iphone_flag_local, stbi__de_iphone_flag_set; + +STBIDEF void stbi_set_unpremultiply_on_load_thread(int flag_true_if_should_unpremultiply) +{ + stbi__unpremultiply_on_load_local = flag_true_if_should_unpremultiply; + stbi__unpremultiply_on_load_set = 1; +} + +STBIDEF void stbi_convert_iphone_png_to_rgb_thread(int flag_true_if_should_convert) +{ + stbi__de_iphone_flag_local = flag_true_if_should_convert; + stbi__de_iphone_flag_set = 1; +} + +#define stbi__unpremultiply_on_load (stbi__unpremultiply_on_load_set \ + ? stbi__unpremultiply_on_load_local \ + : stbi__unpremultiply_on_load_global) +#define stbi__de_iphone_flag (stbi__de_iphone_flag_set \ + ? stbi__de_iphone_flag_local \ + : stbi__de_iphone_flag_global) +#endif // STBI_THREAD_LOCAL + +static void stbi__de_iphone(stbi__png *z) +{ + stbi__context *s = z->s; + stbi__uint32 i, pixel_count = s->img_x * s->img_y; + stbi_uc *p = z->out; + + if (s->img_out_n == 3) { // convert bgr to rgb + for (i=0; i < pixel_count; ++i) { + stbi_uc t = p[0]; + p[0] = p[2]; + p[2] = t; + p += 3; + } + } else { + STBI_ASSERT(s->img_out_n == 4); + if (stbi__unpremultiply_on_load) { + // convert bgr to rgb and unpremultiply + for (i=0; i < pixel_count; ++i) { + stbi_uc a = p[3]; + stbi_uc t = p[0]; + if (a) { + stbi_uc half = a / 2; + p[0] = (p[2] * 255 + half) / a; + p[1] = (p[1] * 255 + half) / a; + p[2] = ( t * 255 + half) / a; + } else { + p[0] = p[2]; + p[2] = t; + } + p += 4; + } + } else { + // convert bgr to rgb + for (i=0; i < pixel_count; ++i) { + stbi_uc t = p[0]; + p[0] = p[2]; + p[2] = t; + p += 4; + } + } + } +} + +#define STBI__PNG_TYPE(a,b,c,d) (((unsigned) (a) << 24) + ((unsigned) (b) << 16) + ((unsigned) (c) << 8) + (unsigned) (d)) + +static int stbi__parse_png_file(stbi__png *z, int scan, int req_comp) +{ + stbi_uc palette[1024], pal_img_n=0; + stbi_uc has_trans=0, tc[3]={0}; + stbi__uint16 tc16[3]; + stbi__uint32 ioff=0, idata_limit=0, i, pal_len=0; + int first=1,k,interlace=0, color=0, is_iphone=0; + stbi__context *s = z->s; + + z->expanded = NULL; + z->idata = NULL; + z->out = NULL; + + if (!stbi__check_png_header(s)) return 0; + + if (scan == STBI__SCAN_type) return 1; + + for (;;) { + stbi__pngchunk c = stbi__get_chunk_header(s); + switch (c.type) { + case STBI__PNG_TYPE('C','g','B','I'): + is_iphone = 1; + stbi__skip(s, c.length); + break; + case STBI__PNG_TYPE('I','H','D','R'): { + int comp,filter; + if (!first) return stbi__err("multiple IHDR","Corrupt PNG"); + first = 0; + if (c.length != 13) return stbi__err("bad IHDR len","Corrupt PNG"); + s->img_x = stbi__get32be(s); + s->img_y = stbi__get32be(s); + if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + z->depth = stbi__get8(s); if (z->depth != 1 && z->depth != 2 && z->depth != 4 && z->depth != 8 && z->depth != 16) return stbi__err("1/2/4/8/16-bit only","PNG not supported: 1/2/4/8/16-bit only"); + color = stbi__get8(s); if (color > 6) return stbi__err("bad ctype","Corrupt PNG"); + if (color == 3 && z->depth == 16) return stbi__err("bad ctype","Corrupt PNG"); + if (color == 3) pal_img_n = 3; else if (color & 1) return stbi__err("bad ctype","Corrupt PNG"); + comp = stbi__get8(s); if (comp) return stbi__err("bad comp method","Corrupt PNG"); + filter= stbi__get8(s); if (filter) return stbi__err("bad filter method","Corrupt PNG"); + interlace = stbi__get8(s); if (interlace>1) return stbi__err("bad interlace method","Corrupt PNG"); + if (!s->img_x || !s->img_y) return stbi__err("0-pixel image","Corrupt PNG"); + if (!pal_img_n) { + s->img_n = (color & 2 ? 3 : 1) + (color & 4 ? 1 : 0); + if ((1 << 30) / s->img_x / s->img_n < s->img_y) return stbi__err("too large", "Image too large to decode"); + } else { + // if paletted, then pal_n is our final components, and + // img_n is # components to decompress/filter. + s->img_n = 1; + if ((1 << 30) / s->img_x / 4 < s->img_y) return stbi__err("too large","Corrupt PNG"); + } + // even with SCAN_header, have to scan to see if we have a tRNS + break; + } + + case STBI__PNG_TYPE('P','L','T','E'): { + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (c.length > 256*3) return stbi__err("invalid PLTE","Corrupt PNG"); + pal_len = c.length / 3; + if (pal_len * 3 != c.length) return stbi__err("invalid PLTE","Corrupt PNG"); + for (i=0; i < pal_len; ++i) { + palette[i*4+0] = stbi__get8(s); + palette[i*4+1] = stbi__get8(s); + palette[i*4+2] = stbi__get8(s); + palette[i*4+3] = 255; + } + break; + } + + case STBI__PNG_TYPE('t','R','N','S'): { + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (z->idata) return stbi__err("tRNS after IDAT","Corrupt PNG"); + if (pal_img_n) { + if (scan == STBI__SCAN_header) { s->img_n = 4; return 1; } + if (pal_len == 0) return stbi__err("tRNS before PLTE","Corrupt PNG"); + if (c.length > pal_len) return stbi__err("bad tRNS len","Corrupt PNG"); + pal_img_n = 4; + for (i=0; i < c.length; ++i) + palette[i*4+3] = stbi__get8(s); + } else { + if (!(s->img_n & 1)) return stbi__err("tRNS with alpha","Corrupt PNG"); + if (c.length != (stbi__uint32) s->img_n*2) return stbi__err("bad tRNS len","Corrupt PNG"); + has_trans = 1; + // non-paletted with tRNS = constant alpha. if header-scanning, we can stop now. + if (scan == STBI__SCAN_header) { ++s->img_n; return 1; } + if (z->depth == 16) { + for (k = 0; k < s->img_n && k < 3; ++k) // extra loop test to suppress false GCC warning + tc16[k] = (stbi__uint16)stbi__get16be(s); // copy the values as-is + } else { + for (k = 0; k < s->img_n && k < 3; ++k) + tc[k] = (stbi_uc)(stbi__get16be(s) & 255) * stbi__depth_scale_table[z->depth]; // non 8-bit images will be larger + } + } + break; + } + + case STBI__PNG_TYPE('I','D','A','T'): { + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (pal_img_n && !pal_len) return stbi__err("no PLTE","Corrupt PNG"); + if (scan == STBI__SCAN_header) { + // header scan definitely stops at first IDAT + if (pal_img_n) + s->img_n = pal_img_n; + return 1; + } + if (c.length > (1u << 30)) return stbi__err("IDAT size limit", "IDAT section larger than 2^30 bytes"); + if ((int)(ioff + c.length) < (int)ioff) return 0; + if (ioff + c.length > idata_limit) { + stbi__uint32 idata_limit_old = idata_limit; + stbi_uc *p; + if (idata_limit == 0) idata_limit = c.length > 4096 ? c.length : 4096; + while (ioff + c.length > idata_limit) + idata_limit *= 2; + STBI_NOTUSED(idata_limit_old); + p = (stbi_uc *) STBI_REALLOC_SIZED(z->idata, idata_limit_old, idata_limit); if (p == NULL) return stbi__err("outofmem", "Out of memory"); + z->idata = p; + } + if (!stbi__getn(s, z->idata+ioff,c.length)) return stbi__err("outofdata","Corrupt PNG"); + ioff += c.length; + break; + } + + case STBI__PNG_TYPE('I','E','N','D'): { + stbi__uint32 raw_len, bpl; + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (scan != STBI__SCAN_load) return 1; + if (z->idata == NULL) return stbi__err("no IDAT","Corrupt PNG"); + // initial guess for decoded data size to avoid unnecessary reallocs + bpl = (s->img_x * z->depth + 7) / 8; // bytes per line, per component + raw_len = bpl * s->img_y * s->img_n /* pixels */ + s->img_y /* filter mode per row */; + z->expanded = (stbi_uc *) stbi_zlib_decode_malloc_guesssize_headerflag((char *) z->idata, ioff, raw_len, (int *) &raw_len, !is_iphone); + if (z->expanded == NULL) return 0; // zlib should set error + STBI_FREE(z->idata); z->idata = NULL; + if ((req_comp == s->img_n+1 && req_comp != 3 && !pal_img_n) || has_trans) + s->img_out_n = s->img_n+1; + else + s->img_out_n = s->img_n; + if (!stbi__create_png_image(z, z->expanded, raw_len, s->img_out_n, z->depth, color, interlace)) return 0; + if (has_trans) { + if (z->depth == 16) { + if (!stbi__compute_transparency16(z, tc16, s->img_out_n)) return 0; + } else { + if (!stbi__compute_transparency(z, tc, s->img_out_n)) return 0; + } + } + if (is_iphone && stbi__de_iphone_flag && s->img_out_n > 2) + stbi__de_iphone(z); + if (pal_img_n) { + // pal_img_n == 3 or 4 + s->img_n = pal_img_n; // record the actual colors we had + s->img_out_n = pal_img_n; + if (req_comp >= 3) s->img_out_n = req_comp; + if (!stbi__expand_png_palette(z, palette, pal_len, s->img_out_n)) + return 0; + } else if (has_trans) { + // non-paletted image with tRNS -> source image has (constant) alpha + ++s->img_n; + } + STBI_FREE(z->expanded); z->expanded = NULL; + // end of PNG chunk, read and skip CRC + stbi__get32be(s); + return 1; + } + + default: + // if critical, fail + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if ((c.type & (1 << 29)) == 0) { + #ifndef STBI_NO_FAILURE_STRINGS + // not threadsafe + static char invalid_chunk[] = "XXXX PNG chunk not known"; + invalid_chunk[0] = STBI__BYTECAST(c.type >> 24); + invalid_chunk[1] = STBI__BYTECAST(c.type >> 16); + invalid_chunk[2] = STBI__BYTECAST(c.type >> 8); + invalid_chunk[3] = STBI__BYTECAST(c.type >> 0); + #endif + return stbi__err(invalid_chunk, "PNG not supported: unknown PNG chunk type"); + } + stbi__skip(s, c.length); + break; + } + // end of PNG chunk, read and skip CRC + stbi__get32be(s); + } +} + +static void *stbi__do_png(stbi__png *p, int *x, int *y, int *n, int req_comp, stbi__result_info *ri) +{ + void *result=NULL; + if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error"); + if (stbi__parse_png_file(p, STBI__SCAN_load, req_comp)) { + if (p->depth <= 8) + ri->bits_per_channel = 8; + else if (p->depth == 16) + ri->bits_per_channel = 16; + else + return stbi__errpuc("bad bits_per_channel", "PNG not supported: unsupported color depth"); + result = p->out; + p->out = NULL; + if (req_comp && req_comp != p->s->img_out_n) { + if (ri->bits_per_channel == 8) + result = stbi__convert_format((unsigned char *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y); + else + result = stbi__convert_format16((stbi__uint16 *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y); + p->s->img_out_n = req_comp; + if (result == NULL) return result; + } + *x = p->s->img_x; + *y = p->s->img_y; + if (n) *n = p->s->img_n; + } + STBI_FREE(p->out); p->out = NULL; + STBI_FREE(p->expanded); p->expanded = NULL; + STBI_FREE(p->idata); p->idata = NULL; + + return result; +} + +static void *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + stbi__png p; + p.s = s; + return stbi__do_png(&p, x,y,comp,req_comp, ri); +} + +static int stbi__png_test(stbi__context *s) +{ + int r; + r = stbi__check_png_header(s); + stbi__rewind(s); + return r; +} + +static int stbi__png_info_raw(stbi__png *p, int *x, int *y, int *comp) +{ + if (!stbi__parse_png_file(p, STBI__SCAN_header, 0)) { + stbi__rewind( p->s ); + return 0; + } + if (x) *x = p->s->img_x; + if (y) *y = p->s->img_y; + if (comp) *comp = p->s->img_n; + return 1; +} + +static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp) +{ + stbi__png p; + p.s = s; + return stbi__png_info_raw(&p, x, y, comp); +} + +static int stbi__png_is16(stbi__context *s) +{ + stbi__png p; + p.s = s; + if (!stbi__png_info_raw(&p, NULL, NULL, NULL)) + return 0; + if (p.depth != 16) { + stbi__rewind(p.s); + return 0; + } + return 1; +} +#endif + +// Microsoft/Windows BMP image + +#ifndef STBI_NO_BMP +static int stbi__bmp_test_raw(stbi__context *s) +{ + int r; + int sz; + if (stbi__get8(s) != 'B') return 0; + if (stbi__get8(s) != 'M') return 0; + stbi__get32le(s); // discard filesize + stbi__get16le(s); // discard reserved + stbi__get16le(s); // discard reserved + stbi__get32le(s); // discard data offset + sz = stbi__get32le(s); + r = (sz == 12 || sz == 40 || sz == 56 || sz == 108 || sz == 124); + return r; +} + +static int stbi__bmp_test(stbi__context *s) +{ + int r = stbi__bmp_test_raw(s); + stbi__rewind(s); + return r; +} + + +// returns 0..31 for the highest set bit +static int stbi__high_bit(unsigned int z) +{ + int n=0; + if (z == 0) return -1; + if (z >= 0x10000) { n += 16; z >>= 16; } + if (z >= 0x00100) { n += 8; z >>= 8; } + if (z >= 0x00010) { n += 4; z >>= 4; } + if (z >= 0x00004) { n += 2; z >>= 2; } + if (z >= 0x00002) { n += 1;/* >>= 1;*/ } + return n; +} + +static int stbi__bitcount(unsigned int a) +{ + a = (a & 0x55555555) + ((a >> 1) & 0x55555555); // max 2 + a = (a & 0x33333333) + ((a >> 2) & 0x33333333); // max 4 + a = (a + (a >> 4)) & 0x0f0f0f0f; // max 8 per 4, now 8 bits + a = (a + (a >> 8)); // max 16 per 8 bits + a = (a + (a >> 16)); // max 32 per 8 bits + return a & 0xff; +} + +// extract an arbitrarily-aligned N-bit value (N=bits) +// from v, and then make it 8-bits long and fractionally +// extend it to full full range. +static int stbi__shiftsigned(unsigned int v, int shift, int bits) +{ + static unsigned int mul_table[9] = { + 0, + 0xff/*0b11111111*/, 0x55/*0b01010101*/, 0x49/*0b01001001*/, 0x11/*0b00010001*/, + 0x21/*0b00100001*/, 0x41/*0b01000001*/, 0x81/*0b10000001*/, 0x01/*0b00000001*/, + }; + static unsigned int shift_table[9] = { + 0, 0,0,1,0,2,4,6,0, + }; + if (shift < 0) + v <<= -shift; + else + v >>= shift; + STBI_ASSERT(v < 256); + v >>= (8-bits); + STBI_ASSERT(bits >= 0 && bits <= 8); + return (int) ((unsigned) v * mul_table[bits]) >> shift_table[bits]; +} + +typedef struct +{ + int bpp, offset, hsz; + unsigned int mr,mg,mb,ma, all_a; + int extra_read; +} stbi__bmp_data; + +static int stbi__bmp_set_mask_defaults(stbi__bmp_data *info, int compress) +{ + // BI_BITFIELDS specifies masks explicitly, don't override + if (compress == 3) + return 1; + + if (compress == 0) { + if (info->bpp == 16) { + info->mr = 31u << 10; + info->mg = 31u << 5; + info->mb = 31u << 0; + } else if (info->bpp == 32) { + info->mr = 0xffu << 16; + info->mg = 0xffu << 8; + info->mb = 0xffu << 0; + info->ma = 0xffu << 24; + info->all_a = 0; // if all_a is 0 at end, then we loaded alpha channel but it was all 0 + } else { + // otherwise, use defaults, which is all-0 + info->mr = info->mg = info->mb = info->ma = 0; + } + return 1; + } + return 0; // error +} + +static void *stbi__bmp_parse_header(stbi__context *s, stbi__bmp_data *info) +{ + int hsz; + if (stbi__get8(s) != 'B' || stbi__get8(s) != 'M') return stbi__errpuc("not BMP", "Corrupt BMP"); + stbi__get32le(s); // discard filesize + stbi__get16le(s); // discard reserved + stbi__get16le(s); // discard reserved + info->offset = stbi__get32le(s); + info->hsz = hsz = stbi__get32le(s); + info->mr = info->mg = info->mb = info->ma = 0; + info->extra_read = 14; + + if (info->offset < 0) return stbi__errpuc("bad BMP", "bad BMP"); + + if (hsz != 12 && hsz != 40 && hsz != 56 && hsz != 108 && hsz != 124) return stbi__errpuc("unknown BMP", "BMP type not supported: unknown"); + if (hsz == 12) { + s->img_x = stbi__get16le(s); + s->img_y = stbi__get16le(s); + } else { + s->img_x = stbi__get32le(s); + s->img_y = stbi__get32le(s); + } + if (stbi__get16le(s) != 1) return stbi__errpuc("bad BMP", "bad BMP"); + info->bpp = stbi__get16le(s); + if (hsz != 12) { + int compress = stbi__get32le(s); + if (compress == 1 || compress == 2) return stbi__errpuc("BMP RLE", "BMP type not supported: RLE"); + if (compress >= 4) return stbi__errpuc("BMP JPEG/PNG", "BMP type not supported: unsupported compression"); // this includes PNG/JPEG modes + if (compress == 3 && info->bpp != 16 && info->bpp != 32) return stbi__errpuc("bad BMP", "bad BMP"); // bitfields requires 16 or 32 bits/pixel + stbi__get32le(s); // discard sizeof + stbi__get32le(s); // discard hres + stbi__get32le(s); // discard vres + stbi__get32le(s); // discard colorsused + stbi__get32le(s); // discard max important + if (hsz == 40 || hsz == 56) { + if (hsz == 56) { + stbi__get32le(s); + stbi__get32le(s); + stbi__get32le(s); + stbi__get32le(s); + } + if (info->bpp == 16 || info->bpp == 32) { + if (compress == 0) { + stbi__bmp_set_mask_defaults(info, compress); + } else if (compress == 3) { + info->mr = stbi__get32le(s); + info->mg = stbi__get32le(s); + info->mb = stbi__get32le(s); + info->extra_read += 12; + // not documented, but generated by photoshop and handled by mspaint + if (info->mr == info->mg && info->mg == info->mb) { + // ?!?!? + return stbi__errpuc("bad BMP", "bad BMP"); + } + } else + return stbi__errpuc("bad BMP", "bad BMP"); + } + } else { + // V4/V5 header + int i; + if (hsz != 108 && hsz != 124) + return stbi__errpuc("bad BMP", "bad BMP"); + info->mr = stbi__get32le(s); + info->mg = stbi__get32le(s); + info->mb = stbi__get32le(s); + info->ma = stbi__get32le(s); + if (compress != 3) // override mr/mg/mb unless in BI_BITFIELDS mode, as per docs + stbi__bmp_set_mask_defaults(info, compress); + stbi__get32le(s); // discard color space + for (i=0; i < 12; ++i) + stbi__get32le(s); // discard color space parameters + if (hsz == 124) { + stbi__get32le(s); // discard rendering intent + stbi__get32le(s); // discard offset of profile data + stbi__get32le(s); // discard size of profile data + stbi__get32le(s); // discard reserved + } + } + } + return (void *) 1; +} + + +static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + stbi_uc *out; + unsigned int mr=0,mg=0,mb=0,ma=0, all_a; + stbi_uc pal[256][4]; + int psize=0,i,j,width; + int flip_vertically, pad, target; + stbi__bmp_data info; + STBI_NOTUSED(ri); + + info.all_a = 255; + if (stbi__bmp_parse_header(s, &info) == NULL) + return NULL; // error code already set + + flip_vertically = ((int) s->img_y) > 0; + s->img_y = abs((int) s->img_y); + + if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + + mr = info.mr; + mg = info.mg; + mb = info.mb; + ma = info.ma; + all_a = info.all_a; + + if (info.hsz == 12) { + if (info.bpp < 24) + psize = (info.offset - info.extra_read - 24) / 3; + } else { + if (info.bpp < 16) + psize = (info.offset - info.extra_read - info.hsz) >> 2; + } + if (psize == 0) { + // accept some number of extra bytes after the header, but if the offset points either to before + // the header ends or implies a large amount of extra data, reject the file as malformed + int bytes_read_so_far = s->callback_already_read + (int)(s->img_buffer - s->img_buffer_original); + int header_limit = 1024; // max we actually read is below 256 bytes currently. + int extra_data_limit = 256*4; // what ordinarily goes here is a palette; 256 entries*4 bytes is its max size. + if (bytes_read_so_far <= 0 || bytes_read_so_far > header_limit) { + return stbi__errpuc("bad header", "Corrupt BMP"); + } + // we established that bytes_read_so_far is positive and sensible. + // the first half of this test rejects offsets that are either too small positives, or + // negative, and guarantees that info.offset >= bytes_read_so_far > 0. this in turn + // ensures the number computed in the second half of the test can't overflow. + if (info.offset < bytes_read_so_far || info.offset - bytes_read_so_far > extra_data_limit) { + return stbi__errpuc("bad offset", "Corrupt BMP"); + } else { + stbi__skip(s, info.offset - bytes_read_so_far); + } + } + + if (info.bpp == 24 && ma == 0xff000000) + s->img_n = 3; + else + s->img_n = ma ? 4 : 3; + if (req_comp && req_comp >= 3) // we can directly decode 3 or 4 + target = req_comp; + else + target = s->img_n; // if they want monochrome, we'll post-convert + + // sanity-check size + if (!stbi__mad3sizes_valid(target, s->img_x, s->img_y, 0)) + return stbi__errpuc("too large", "Corrupt BMP"); + + out = (stbi_uc *) stbi__malloc_mad3(target, s->img_x, s->img_y, 0); + if (!out) return stbi__errpuc("outofmem", "Out of memory"); + if (info.bpp < 16) { + int z=0; + if (psize == 0 || psize > 256) { STBI_FREE(out); return stbi__errpuc("invalid", "Corrupt BMP"); } + for (i=0; i < psize; ++i) { + pal[i][2] = stbi__get8(s); + pal[i][1] = stbi__get8(s); + pal[i][0] = stbi__get8(s); + if (info.hsz != 12) stbi__get8(s); + pal[i][3] = 255; + } + stbi__skip(s, info.offset - info.extra_read - info.hsz - psize * (info.hsz == 12 ? 3 : 4)); + if (info.bpp == 1) width = (s->img_x + 7) >> 3; + else if (info.bpp == 4) width = (s->img_x + 1) >> 1; + else if (info.bpp == 8) width = s->img_x; + else { STBI_FREE(out); return stbi__errpuc("bad bpp", "Corrupt BMP"); } + pad = (-width)&3; + if (info.bpp == 1) { + for (j=0; j < (int) s->img_y; ++j) { + int bit_offset = 7, v = stbi__get8(s); + for (i=0; i < (int) s->img_x; ++i) { + int color = (v>>bit_offset)&0x1; + out[z++] = pal[color][0]; + out[z++] = pal[color][1]; + out[z++] = pal[color][2]; + if (target == 4) out[z++] = 255; + if (i+1 == (int) s->img_x) break; + if((--bit_offset) < 0) { + bit_offset = 7; + v = stbi__get8(s); + } + } + stbi__skip(s, pad); + } + } else { + for (j=0; j < (int) s->img_y; ++j) { + for (i=0; i < (int) s->img_x; i += 2) { + int v=stbi__get8(s),v2=0; + if (info.bpp == 4) { + v2 = v & 15; + v >>= 4; + } + out[z++] = pal[v][0]; + out[z++] = pal[v][1]; + out[z++] = pal[v][2]; + if (target == 4) out[z++] = 255; + if (i+1 == (int) s->img_x) break; + v = (info.bpp == 8) ? stbi__get8(s) : v2; + out[z++] = pal[v][0]; + out[z++] = pal[v][1]; + out[z++] = pal[v][2]; + if (target == 4) out[z++] = 255; + } + stbi__skip(s, pad); + } + } + } else { + int rshift=0,gshift=0,bshift=0,ashift=0,rcount=0,gcount=0,bcount=0,acount=0; + int z = 0; + int easy=0; + stbi__skip(s, info.offset - info.extra_read - info.hsz); + if (info.bpp == 24) width = 3 * s->img_x; + else if (info.bpp == 16) width = 2*s->img_x; + else /* bpp = 32 and pad = 0 */ width=0; + pad = (-width) & 3; + if (info.bpp == 24) { + easy = 1; + } else if (info.bpp == 32) { + if (mb == 0xff && mg == 0xff00 && mr == 0x00ff0000 && ma == 0xff000000) + easy = 2; + } + if (!easy) { + if (!mr || !mg || !mb) { STBI_FREE(out); return stbi__errpuc("bad masks", "Corrupt BMP"); } + // right shift amt to put high bit in position #7 + rshift = stbi__high_bit(mr)-7; rcount = stbi__bitcount(mr); + gshift = stbi__high_bit(mg)-7; gcount = stbi__bitcount(mg); + bshift = stbi__high_bit(mb)-7; bcount = stbi__bitcount(mb); + ashift = stbi__high_bit(ma)-7; acount = stbi__bitcount(ma); + if (rcount > 8 || gcount > 8 || bcount > 8 || acount > 8) { STBI_FREE(out); return stbi__errpuc("bad masks", "Corrupt BMP"); } + } + for (j=0; j < (int) s->img_y; ++j) { + if (easy) { + for (i=0; i < (int) s->img_x; ++i) { + unsigned char a; + out[z+2] = stbi__get8(s); + out[z+1] = stbi__get8(s); + out[z+0] = stbi__get8(s); + z += 3; + a = (easy == 2 ? stbi__get8(s) : 255); + all_a |= a; + if (target == 4) out[z++] = a; + } + } else { + int bpp = info.bpp; + for (i=0; i < (int) s->img_x; ++i) { + stbi__uint32 v = (bpp == 16 ? (stbi__uint32) stbi__get16le(s) : stbi__get32le(s)); + unsigned int a; + out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mr, rshift, rcount)); + out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mg, gshift, gcount)); + out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mb, bshift, bcount)); + a = (ma ? stbi__shiftsigned(v & ma, ashift, acount) : 255); + all_a |= a; + if (target == 4) out[z++] = STBI__BYTECAST(a); + } + } + stbi__skip(s, pad); + } + } + + // if alpha channel is all 0s, replace with all 255s + if (target == 4 && all_a == 0) + for (i=4*s->img_x*s->img_y-1; i >= 0; i -= 4) + out[i] = 255; + + if (flip_vertically) { + stbi_uc t; + for (j=0; j < (int) s->img_y>>1; ++j) { + stbi_uc *p1 = out + j *s->img_x*target; + stbi_uc *p2 = out + (s->img_y-1-j)*s->img_x*target; + for (i=0; i < (int) s->img_x*target; ++i) { + t = p1[i]; p1[i] = p2[i]; p2[i] = t; + } + } + } + + if (req_comp && req_comp != target) { + out = stbi__convert_format(out, target, req_comp, s->img_x, s->img_y); + if (out == NULL) return out; // stbi__convert_format frees input on failure + } + + *x = s->img_x; + *y = s->img_y; + if (comp) *comp = s->img_n; + return out; +} +#endif + +// Targa Truevision - TGA +// by Jonathan Dummer +#ifndef STBI_NO_TGA +// returns STBI_rgb or whatever, 0 on error +static int stbi__tga_get_comp(int bits_per_pixel, int is_grey, int* is_rgb16) +{ + // only RGB or RGBA (incl. 16bit) or grey allowed + if (is_rgb16) *is_rgb16 = 0; + switch(bits_per_pixel) { + case 8: return STBI_grey; + case 16: if(is_grey) return STBI_grey_alpha; + // fallthrough + case 15: if(is_rgb16) *is_rgb16 = 1; + return STBI_rgb; + case 24: // fallthrough + case 32: return bits_per_pixel/8; + default: return 0; + } +} + +static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp) +{ + int tga_w, tga_h, tga_comp, tga_image_type, tga_bits_per_pixel, tga_colormap_bpp; + int sz, tga_colormap_type; + stbi__get8(s); // discard Offset + tga_colormap_type = stbi__get8(s); // colormap type + if( tga_colormap_type > 1 ) { + stbi__rewind(s); + return 0; // only RGB or indexed allowed + } + tga_image_type = stbi__get8(s); // image type + if ( tga_colormap_type == 1 ) { // colormapped (paletted) image + if (tga_image_type != 1 && tga_image_type != 9) { + stbi__rewind(s); + return 0; + } + stbi__skip(s,4); // skip index of first colormap entry and number of entries + sz = stbi__get8(s); // check bits per palette color entry + if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) { + stbi__rewind(s); + return 0; + } + stbi__skip(s,4); // skip image x and y origin + tga_colormap_bpp = sz; + } else { // "normal" image w/o colormap - only RGB or grey allowed, +/- RLE + if ( (tga_image_type != 2) && (tga_image_type != 3) && (tga_image_type != 10) && (tga_image_type != 11) ) { + stbi__rewind(s); + return 0; // only RGB or grey allowed, +/- RLE + } + stbi__skip(s,9); // skip colormap specification and image x/y origin + tga_colormap_bpp = 0; + } + tga_w = stbi__get16le(s); + if( tga_w < 1 ) { + stbi__rewind(s); + return 0; // test width + } + tga_h = stbi__get16le(s); + if( tga_h < 1 ) { + stbi__rewind(s); + return 0; // test height + } + tga_bits_per_pixel = stbi__get8(s); // bits per pixel + stbi__get8(s); // ignore alpha bits + if (tga_colormap_bpp != 0) { + if((tga_bits_per_pixel != 8) && (tga_bits_per_pixel != 16)) { + // when using a colormap, tga_bits_per_pixel is the size of the indexes + // I don't think anything but 8 or 16bit indexes makes sense + stbi__rewind(s); + return 0; + } + tga_comp = stbi__tga_get_comp(tga_colormap_bpp, 0, NULL); + } else { + tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3) || (tga_image_type == 11), NULL); + } + if(!tga_comp) { + stbi__rewind(s); + return 0; + } + if (x) *x = tga_w; + if (y) *y = tga_h; + if (comp) *comp = tga_comp; + return 1; // seems to have passed everything +} + +static int stbi__tga_test(stbi__context *s) +{ + int res = 0; + int sz, tga_color_type; + stbi__get8(s); // discard Offset + tga_color_type = stbi__get8(s); // color type + if ( tga_color_type > 1 ) goto errorEnd; // only RGB or indexed allowed + sz = stbi__get8(s); // image type + if ( tga_color_type == 1 ) { // colormapped (paletted) image + if (sz != 1 && sz != 9) goto errorEnd; // colortype 1 demands image type 1 or 9 + stbi__skip(s,4); // skip index of first colormap entry and number of entries + sz = stbi__get8(s); // check bits per palette color entry + if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) goto errorEnd; + stbi__skip(s,4); // skip image x and y origin + } else { // "normal" image w/o colormap + if ( (sz != 2) && (sz != 3) && (sz != 10) && (sz != 11) ) goto errorEnd; // only RGB or grey allowed, +/- RLE + stbi__skip(s,9); // skip colormap specification and image x/y origin + } + if ( stbi__get16le(s) < 1 ) goto errorEnd; // test width + if ( stbi__get16le(s) < 1 ) goto errorEnd; // test height + sz = stbi__get8(s); // bits per pixel + if ( (tga_color_type == 1) && (sz != 8) && (sz != 16) ) goto errorEnd; // for colormapped images, bpp is size of an index + if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) goto errorEnd; + + res = 1; // if we got this far, everything's good and we can return 1 instead of 0 + +errorEnd: + stbi__rewind(s); + return res; +} + +// read 16bit value and convert to 24bit RGB +static void stbi__tga_read_rgb16(stbi__context *s, stbi_uc* out) +{ + stbi__uint16 px = (stbi__uint16)stbi__get16le(s); + stbi__uint16 fiveBitMask = 31; + // we have 3 channels with 5bits each + int r = (px >> 10) & fiveBitMask; + int g = (px >> 5) & fiveBitMask; + int b = px & fiveBitMask; + // Note that this saves the data in RGB(A) order, so it doesn't need to be swapped later + out[0] = (stbi_uc)((r * 255)/31); + out[1] = (stbi_uc)((g * 255)/31); + out[2] = (stbi_uc)((b * 255)/31); + + // some people claim that the most significant bit might be used for alpha + // (possibly if an alpha-bit is set in the "image descriptor byte") + // but that only made 16bit test images completely translucent.. + // so let's treat all 15 and 16bit TGAs as RGB with no alpha. +} + +static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + // read in the TGA header stuff + int tga_offset = stbi__get8(s); + int tga_indexed = stbi__get8(s); + int tga_image_type = stbi__get8(s); + int tga_is_RLE = 0; + int tga_palette_start = stbi__get16le(s); + int tga_palette_len = stbi__get16le(s); + int tga_palette_bits = stbi__get8(s); + int tga_x_origin = stbi__get16le(s); + int tga_y_origin = stbi__get16le(s); + int tga_width = stbi__get16le(s); + int tga_height = stbi__get16le(s); + int tga_bits_per_pixel = stbi__get8(s); + int tga_comp, tga_rgb16=0; + int tga_inverted = stbi__get8(s); + // int tga_alpha_bits = tga_inverted & 15; // the 4 lowest bits - unused (useless?) + // image data + unsigned char *tga_data; + unsigned char *tga_palette = NULL; + int i, j; + unsigned char raw_data[4] = {0}; + int RLE_count = 0; + int RLE_repeating = 0; + int read_next_pixel = 1; + STBI_NOTUSED(ri); + STBI_NOTUSED(tga_x_origin); // @TODO + STBI_NOTUSED(tga_y_origin); // @TODO + + if (tga_height > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + if (tga_width > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + + // do a tiny bit of precessing + if ( tga_image_type >= 8 ) + { + tga_image_type -= 8; + tga_is_RLE = 1; + } + tga_inverted = 1 - ((tga_inverted >> 5) & 1); + + // If I'm paletted, then I'll use the number of bits from the palette + if ( tga_indexed ) tga_comp = stbi__tga_get_comp(tga_palette_bits, 0, &tga_rgb16); + else tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3), &tga_rgb16); + + if(!tga_comp) // shouldn't really happen, stbi__tga_test() should have ensured basic consistency + return stbi__errpuc("bad format", "Can't find out TGA pixelformat"); + + // tga info + *x = tga_width; + *y = tga_height; + if (comp) *comp = tga_comp; + + if (!stbi__mad3sizes_valid(tga_width, tga_height, tga_comp, 0)) + return stbi__errpuc("too large", "Corrupt TGA"); + + tga_data = (unsigned char*)stbi__malloc_mad3(tga_width, tga_height, tga_comp, 0); + if (!tga_data) return stbi__errpuc("outofmem", "Out of memory"); + + // skip to the data's starting position (offset usually = 0) + stbi__skip(s, tga_offset ); + + if ( !tga_indexed && !tga_is_RLE && !tga_rgb16 ) { + for (i=0; i < tga_height; ++i) { + int row = tga_inverted ? tga_height -i - 1 : i; + stbi_uc *tga_row = tga_data + row*tga_width*tga_comp; + stbi__getn(s, tga_row, tga_width * tga_comp); + } + } else { + // do I need to load a palette? + if ( tga_indexed) + { + if (tga_palette_len == 0) { /* you have to have at least one entry! */ + STBI_FREE(tga_data); + return stbi__errpuc("bad palette", "Corrupt TGA"); + } + + // any data to skip? (offset usually = 0) + stbi__skip(s, tga_palette_start ); + // load the palette + tga_palette = (unsigned char*)stbi__malloc_mad2(tga_palette_len, tga_comp, 0); + if (!tga_palette) { + STBI_FREE(tga_data); + return stbi__errpuc("outofmem", "Out of memory"); + } + if (tga_rgb16) { + stbi_uc *pal_entry = tga_palette; + STBI_ASSERT(tga_comp == STBI_rgb); + for (i=0; i < tga_palette_len; ++i) { + stbi__tga_read_rgb16(s, pal_entry); + pal_entry += tga_comp; + } + } else if (!stbi__getn(s, tga_palette, tga_palette_len * tga_comp)) { + STBI_FREE(tga_data); + STBI_FREE(tga_palette); + return stbi__errpuc("bad palette", "Corrupt TGA"); + } + } + // load the data + for (i=0; i < tga_width * tga_height; ++i) + { + // if I'm in RLE mode, do I need to get a RLE stbi__pngchunk? + if ( tga_is_RLE ) + { + if ( RLE_count == 0 ) + { + // yep, get the next byte as a RLE command + int RLE_cmd = stbi__get8(s); + RLE_count = 1 + (RLE_cmd & 127); + RLE_repeating = RLE_cmd >> 7; + read_next_pixel = 1; + } else if ( !RLE_repeating ) + { + read_next_pixel = 1; + } + } else + { + read_next_pixel = 1; + } + // OK, if I need to read a pixel, do it now + if ( read_next_pixel ) + { + // load however much data we did have + if ( tga_indexed ) + { + // read in index, then perform the lookup + int pal_idx = (tga_bits_per_pixel == 8) ? stbi__get8(s) : stbi__get16le(s); + if ( pal_idx >= tga_palette_len ) { + // invalid index + pal_idx = 0; + } + pal_idx *= tga_comp; + for (j = 0; j < tga_comp; ++j) { + raw_data[j] = tga_palette[pal_idx+j]; + } + } else if(tga_rgb16) { + STBI_ASSERT(tga_comp == STBI_rgb); + stbi__tga_read_rgb16(s, raw_data); + } else { + // read in the data raw + for (j = 0; j < tga_comp; ++j) { + raw_data[j] = stbi__get8(s); + } + } + // clear the reading flag for the next pixel + read_next_pixel = 0; + } // end of reading a pixel + + // copy data + for (j = 0; j < tga_comp; ++j) + tga_data[i*tga_comp+j] = raw_data[j]; + + // in case we're in RLE mode, keep counting down + --RLE_count; + } + // do I need to invert the image? + if ( tga_inverted ) + { + for (j = 0; j*2 < tga_height; ++j) + { + int index1 = j * tga_width * tga_comp; + int index2 = (tga_height - 1 - j) * tga_width * tga_comp; + for (i = tga_width * tga_comp; i > 0; --i) + { + unsigned char temp = tga_data[index1]; + tga_data[index1] = tga_data[index2]; + tga_data[index2] = temp; + ++index1; + ++index2; + } + } + } + // clear my palette, if I had one + if ( tga_palette != NULL ) + { + STBI_FREE( tga_palette ); + } + } + + // swap RGB - if the source data was RGB16, it already is in the right order + if (tga_comp >= 3 && !tga_rgb16) + { + unsigned char* tga_pixel = tga_data; + for (i=0; i < tga_width * tga_height; ++i) + { + unsigned char temp = tga_pixel[0]; + tga_pixel[0] = tga_pixel[2]; + tga_pixel[2] = temp; + tga_pixel += tga_comp; + } + } + + // convert to target component count + if (req_comp && req_comp != tga_comp) + tga_data = stbi__convert_format(tga_data, tga_comp, req_comp, tga_width, tga_height); + + // the things I do to get rid of an error message, and yet keep + // Microsoft's C compilers happy... [8^( + tga_palette_start = tga_palette_len = tga_palette_bits = + tga_x_origin = tga_y_origin = 0; + STBI_NOTUSED(tga_palette_start); + // OK, done + return tga_data; +} +#endif + +// ************************************************************************************************* +// Photoshop PSD loader -- PD by Thatcher Ulrich, integration by Nicolas Schulz, tweaked by STB + +#ifndef STBI_NO_PSD +static int stbi__psd_test(stbi__context *s) +{ + int r = (stbi__get32be(s) == 0x38425053); + stbi__rewind(s); + return r; +} + +static int stbi__psd_decode_rle(stbi__context *s, stbi_uc *p, int pixelCount) +{ + int count, nleft, len; + + count = 0; + while ((nleft = pixelCount - count) > 0) { + len = stbi__get8(s); + if (len == 128) { + // No-op. + } else if (len < 128) { + // Copy next len+1 bytes literally. + len++; + if (len > nleft) return 0; // corrupt data + count += len; + while (len) { + *p = stbi__get8(s); + p += 4; + len--; + } + } else if (len > 128) { + stbi_uc val; + // Next -len+1 bytes in the dest are replicated from next source byte. + // (Interpret len as a negative 8-bit int.) + len = 257 - len; + if (len > nleft) return 0; // corrupt data + val = stbi__get8(s); + count += len; + while (len) { + *p = val; + p += 4; + len--; + } + } + } + + return 1; +} + +static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc) +{ + int pixelCount; + int channelCount, compression; + int channel, i; + int bitdepth; + int w,h; + stbi_uc *out; + STBI_NOTUSED(ri); + + // Check identifier + if (stbi__get32be(s) != 0x38425053) // "8BPS" + return stbi__errpuc("not PSD", "Corrupt PSD image"); + + // Check file type version. + if (stbi__get16be(s) != 1) + return stbi__errpuc("wrong version", "Unsupported version of PSD image"); + + // Skip 6 reserved bytes. + stbi__skip(s, 6 ); + + // Read the number of channels (R, G, B, A, etc). + channelCount = stbi__get16be(s); + if (channelCount < 0 || channelCount > 16) + return stbi__errpuc("wrong channel count", "Unsupported number of channels in PSD image"); + + // Read the rows and columns of the image. + h = stbi__get32be(s); + w = stbi__get32be(s); + + if (h > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + if (w > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + + // Make sure the depth is 8 bits. + bitdepth = stbi__get16be(s); + if (bitdepth != 8 && bitdepth != 16) + return stbi__errpuc("unsupported bit depth", "PSD bit depth is not 8 or 16 bit"); + + // Make sure the color mode is RGB. + // Valid options are: + // 0: Bitmap + // 1: Grayscale + // 2: Indexed color + // 3: RGB color + // 4: CMYK color + // 7: Multichannel + // 8: Duotone + // 9: Lab color + if (stbi__get16be(s) != 3) + return stbi__errpuc("wrong color format", "PSD is not in RGB color format"); + + // Skip the Mode Data. (It's the palette for indexed color; other info for other modes.) + stbi__skip(s,stbi__get32be(s) ); + + // Skip the image resources. (resolution, pen tool paths, etc) + stbi__skip(s, stbi__get32be(s) ); + + // Skip the reserved data. + stbi__skip(s, stbi__get32be(s) ); + + // Find out if the data is compressed. + // Known values: + // 0: no compression + // 1: RLE compressed + compression = stbi__get16be(s); + if (compression > 1) + return stbi__errpuc("bad compression", "PSD has an unknown compression format"); + + // Check size + if (!stbi__mad3sizes_valid(4, w, h, 0)) + return stbi__errpuc("too large", "Corrupt PSD"); + + // Create the destination image. + + if (!compression && bitdepth == 16 && bpc == 16) { + out = (stbi_uc *) stbi__malloc_mad3(8, w, h, 0); + ri->bits_per_channel = 16; + } else + out = (stbi_uc *) stbi__malloc(4 * w*h); + + if (!out) return stbi__errpuc("outofmem", "Out of memory"); + pixelCount = w*h; + + // Initialize the data to zero. + //memset( out, 0, pixelCount * 4 ); + + // Finally, the image data. + if (compression) { + // RLE as used by .PSD and .TIFF + // Loop until you get the number of unpacked bytes you are expecting: + // Read the next source byte into n. + // If n is between 0 and 127 inclusive, copy the next n+1 bytes literally. + // Else if n is between -127 and -1 inclusive, copy the next byte -n+1 times. + // Else if n is 128, noop. + // Endloop + + // The RLE-compressed data is preceded by a 2-byte data count for each row in the data, + // which we're going to just skip. + stbi__skip(s, h * channelCount * 2 ); + + // Read the RLE data by channel. + for (channel = 0; channel < 4; channel++) { + stbi_uc *p; + + p = out+channel; + if (channel >= channelCount) { + // Fill this channel with default data. + for (i = 0; i < pixelCount; i++, p += 4) + *p = (channel == 3 ? 255 : 0); + } else { + // Read the RLE data. + if (!stbi__psd_decode_rle(s, p, pixelCount)) { + STBI_FREE(out); + return stbi__errpuc("corrupt", "bad RLE data"); + } + } + } + + } else { + // We're at the raw image data. It's each channel in order (Red, Green, Blue, Alpha, ...) + // where each channel consists of an 8-bit (or 16-bit) value for each pixel in the image. + + // Read the data by channel. + for (channel = 0; channel < 4; channel++) { + if (channel >= channelCount) { + // Fill this channel with default data. + if (bitdepth == 16 && bpc == 16) { + stbi__uint16 *q = ((stbi__uint16 *) out) + channel; + stbi__uint16 val = channel == 3 ? 65535 : 0; + for (i = 0; i < pixelCount; i++, q += 4) + *q = val; + } else { + stbi_uc *p = out+channel; + stbi_uc val = channel == 3 ? 255 : 0; + for (i = 0; i < pixelCount; i++, p += 4) + *p = val; + } + } else { + if (ri->bits_per_channel == 16) { // output bpc + stbi__uint16 *q = ((stbi__uint16 *) out) + channel; + for (i = 0; i < pixelCount; i++, q += 4) + *q = (stbi__uint16) stbi__get16be(s); + } else { + stbi_uc *p = out+channel; + if (bitdepth == 16) { // input bpc + for (i = 0; i < pixelCount; i++, p += 4) + *p = (stbi_uc) (stbi__get16be(s) >> 8); + } else { + for (i = 0; i < pixelCount; i++, p += 4) + *p = stbi__get8(s); + } + } + } + } + } + + // remove weird white matte from PSD + if (channelCount >= 4) { + if (ri->bits_per_channel == 16) { + for (i=0; i < w*h; ++i) { + stbi__uint16 *pixel = (stbi__uint16 *) out + 4*i; + if (pixel[3] != 0 && pixel[3] != 65535) { + float a = pixel[3] / 65535.0f; + float ra = 1.0f / a; + float inv_a = 65535.0f * (1 - ra); + pixel[0] = (stbi__uint16) (pixel[0]*ra + inv_a); + pixel[1] = (stbi__uint16) (pixel[1]*ra + inv_a); + pixel[2] = (stbi__uint16) (pixel[2]*ra + inv_a); + } + } + } else { + for (i=0; i < w*h; ++i) { + unsigned char *pixel = out + 4*i; + if (pixel[3] != 0 && pixel[3] != 255) { + float a = pixel[3] / 255.0f; + float ra = 1.0f / a; + float inv_a = 255.0f * (1 - ra); + pixel[0] = (unsigned char) (pixel[0]*ra + inv_a); + pixel[1] = (unsigned char) (pixel[1]*ra + inv_a); + pixel[2] = (unsigned char) (pixel[2]*ra + inv_a); + } + } + } + } + + // convert to desired output format + if (req_comp && req_comp != 4) { + if (ri->bits_per_channel == 16) + out = (stbi_uc *) stbi__convert_format16((stbi__uint16 *) out, 4, req_comp, w, h); + else + out = stbi__convert_format(out, 4, req_comp, w, h); + if (out == NULL) return out; // stbi__convert_format frees input on failure + } + + if (comp) *comp = 4; + *y = h; + *x = w; + + return out; +} +#endif + +// ************************************************************************************************* +// Softimage PIC loader +// by Tom Seddon +// +// See http://softimage.wiki.softimage.com/index.php/INFO:_PIC_file_format +// See http://ozviz.wasp.uwa.edu.au/~pbourke/dataformats/softimagepic/ + +#ifndef STBI_NO_PIC +static int stbi__pic_is4(stbi__context *s,const char *str) +{ + int i; + for (i=0; i<4; ++i) + if (stbi__get8(s) != (stbi_uc)str[i]) + return 0; + + return 1; +} + +static int stbi__pic_test_core(stbi__context *s) +{ + int i; + + if (!stbi__pic_is4(s,"\x53\x80\xF6\x34")) + return 0; + + for(i=0;i<84;++i) + stbi__get8(s); + + if (!stbi__pic_is4(s,"PICT")) + return 0; + + return 1; +} + +typedef struct +{ + stbi_uc size,type,channel; +} stbi__pic_packet; + +static stbi_uc *stbi__readval(stbi__context *s, int channel, stbi_uc *dest) +{ + int mask=0x80, i; + + for (i=0; i<4; ++i, mask>>=1) { + if (channel & mask) { + if (stbi__at_eof(s)) return stbi__errpuc("bad file","PIC file too short"); + dest[i]=stbi__get8(s); + } + } + + return dest; +} + +static void stbi__copyval(int channel,stbi_uc *dest,const stbi_uc *src) +{ + int mask=0x80,i; + + for (i=0;i<4; ++i, mask>>=1) + if (channel&mask) + dest[i]=src[i]; +} + +static stbi_uc *stbi__pic_load_core(stbi__context *s,int width,int height,int *comp, stbi_uc *result) +{ + int act_comp=0,num_packets=0,y,chained; + stbi__pic_packet packets[10]; + + // this will (should...) cater for even some bizarre stuff like having data + // for the same channel in multiple packets. + do { + stbi__pic_packet *packet; + + if (num_packets==sizeof(packets)/sizeof(packets[0])) + return stbi__errpuc("bad format","too many packets"); + + packet = &packets[num_packets++]; + + chained = stbi__get8(s); + packet->size = stbi__get8(s); + packet->type = stbi__get8(s); + packet->channel = stbi__get8(s); + + act_comp |= packet->channel; + + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (reading packets)"); + if (packet->size != 8) return stbi__errpuc("bad format","packet isn't 8bpp"); + } while (chained); + + *comp = (act_comp & 0x10 ? 4 : 3); // has alpha channel? + + for(y=0; ytype) { + default: + return stbi__errpuc("bad format","packet has bad compression type"); + + case 0: {//uncompressed + int x; + + for(x=0;xchannel,dest)) + return 0; + break; + } + + case 1://Pure RLE + { + int left=width, i; + + while (left>0) { + stbi_uc count,value[4]; + + count=stbi__get8(s); + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (pure read count)"); + + if (count > left) + count = (stbi_uc) left; + + if (!stbi__readval(s,packet->channel,value)) return 0; + + for(i=0; ichannel,dest,value); + left -= count; + } + } + break; + + case 2: {//Mixed RLE + int left=width; + while (left>0) { + int count = stbi__get8(s), i; + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (mixed read count)"); + + if (count >= 128) { // Repeated + stbi_uc value[4]; + + if (count==128) + count = stbi__get16be(s); + else + count -= 127; + if (count > left) + return stbi__errpuc("bad file","scanline overrun"); + + if (!stbi__readval(s,packet->channel,value)) + return 0; + + for(i=0;ichannel,dest,value); + } else { // Raw + ++count; + if (count>left) return stbi__errpuc("bad file","scanline overrun"); + + for(i=0;ichannel,dest)) + return 0; + } + left-=count; + } + break; + } + } + } + } + + return result; +} + +static void *stbi__pic_load(stbi__context *s,int *px,int *py,int *comp,int req_comp, stbi__result_info *ri) +{ + stbi_uc *result; + int i, x,y, internal_comp; + STBI_NOTUSED(ri); + + if (!comp) comp = &internal_comp; + + for (i=0; i<92; ++i) + stbi__get8(s); + + x = stbi__get16be(s); + y = stbi__get16be(s); + + if (y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + if (x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (pic header)"); + if (!stbi__mad3sizes_valid(x, y, 4, 0)) return stbi__errpuc("too large", "PIC image too large to decode"); + + stbi__get32be(s); //skip `ratio' + stbi__get16be(s); //skip `fields' + stbi__get16be(s); //skip `pad' + + // intermediate buffer is RGBA + result = (stbi_uc *) stbi__malloc_mad3(x, y, 4, 0); + if (!result) return stbi__errpuc("outofmem", "Out of memory"); + memset(result, 0xff, x*y*4); + + if (!stbi__pic_load_core(s,x,y,comp, result)) { + STBI_FREE(result); + result=0; + } + *px = x; + *py = y; + if (req_comp == 0) req_comp = *comp; + result=stbi__convert_format(result,4,req_comp,x,y); + + return result; +} + +static int stbi__pic_test(stbi__context *s) +{ + int r = stbi__pic_test_core(s); + stbi__rewind(s); + return r; +} +#endif + +// ************************************************************************************************* +// GIF loader -- public domain by Jean-Marc Lienher -- simplified/shrunk by stb + +#ifndef STBI_NO_GIF +typedef struct +{ + stbi__int16 prefix; + stbi_uc first; + stbi_uc suffix; +} stbi__gif_lzw; + +typedef struct +{ + int w,h; + stbi_uc *out; // output buffer (always 4 components) + stbi_uc *background; // The current "background" as far as a gif is concerned + stbi_uc *history; + int flags, bgindex, ratio, transparent, eflags; + stbi_uc pal[256][4]; + stbi_uc lpal[256][4]; + stbi__gif_lzw codes[8192]; + stbi_uc *color_table; + int parse, step; + int lflags; + int start_x, start_y; + int max_x, max_y; + int cur_x, cur_y; + int line_size; + int delay; +} stbi__gif; + +static int stbi__gif_test_raw(stbi__context *s) +{ + int sz; + if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8') return 0; + sz = stbi__get8(s); + if (sz != '9' && sz != '7') return 0; + if (stbi__get8(s) != 'a') return 0; + return 1; +} + +static int stbi__gif_test(stbi__context *s) +{ + int r = stbi__gif_test_raw(s); + stbi__rewind(s); + return r; +} + +static void stbi__gif_parse_colortable(stbi__context *s, stbi_uc pal[256][4], int num_entries, int transp) +{ + int i; + for (i=0; i < num_entries; ++i) { + pal[i][2] = stbi__get8(s); + pal[i][1] = stbi__get8(s); + pal[i][0] = stbi__get8(s); + pal[i][3] = transp == i ? 0 : 255; + } +} + +static int stbi__gif_header(stbi__context *s, stbi__gif *g, int *comp, int is_info) +{ + stbi_uc version; + if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8') + return stbi__err("not GIF", "Corrupt GIF"); + + version = stbi__get8(s); + if (version != '7' && version != '9') return stbi__err("not GIF", "Corrupt GIF"); + if (stbi__get8(s) != 'a') return stbi__err("not GIF", "Corrupt GIF"); + + stbi__g_failure_reason = ""; + g->w = stbi__get16le(s); + g->h = stbi__get16le(s); + g->flags = stbi__get8(s); + g->bgindex = stbi__get8(s); + g->ratio = stbi__get8(s); + g->transparent = -1; + + if (g->w > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + if (g->h > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + + if (comp != 0) *comp = 4; // can't actually tell whether it's 3 or 4 until we parse the comments + + if (is_info) return 1; + + if (g->flags & 0x80) + stbi__gif_parse_colortable(s,g->pal, 2 << (g->flags & 7), -1); + + return 1; +} + +static int stbi__gif_info_raw(stbi__context *s, int *x, int *y, int *comp) +{ + stbi__gif* g = (stbi__gif*) stbi__malloc(sizeof(stbi__gif)); + if (!g) return stbi__err("outofmem", "Out of memory"); + if (!stbi__gif_header(s, g, comp, 1)) { + STBI_FREE(g); + stbi__rewind( s ); + return 0; + } + if (x) *x = g->w; + if (y) *y = g->h; + STBI_FREE(g); + return 1; +} + +static void stbi__out_gif_code(stbi__gif *g, stbi__uint16 code) +{ + stbi_uc *p, *c; + int idx; + + // recurse to decode the prefixes, since the linked-list is backwards, + // and working backwards through an interleaved image would be nasty + if (g->codes[code].prefix >= 0) + stbi__out_gif_code(g, g->codes[code].prefix); + + if (g->cur_y >= g->max_y) return; + + idx = g->cur_x + g->cur_y; + p = &g->out[idx]; + g->history[idx / 4] = 1; + + c = &g->color_table[g->codes[code].suffix * 4]; + if (c[3] > 128) { // don't render transparent pixels; + p[0] = c[2]; + p[1] = c[1]; + p[2] = c[0]; + p[3] = c[3]; + } + g->cur_x += 4; + + if (g->cur_x >= g->max_x) { + g->cur_x = g->start_x; + g->cur_y += g->step; + + while (g->cur_y >= g->max_y && g->parse > 0) { + g->step = (1 << g->parse) * g->line_size; + g->cur_y = g->start_y + (g->step >> 1); + --g->parse; + } + } +} + +static stbi_uc *stbi__process_gif_raster(stbi__context *s, stbi__gif *g) +{ + stbi_uc lzw_cs; + stbi__int32 len, init_code; + stbi__uint32 first; + stbi__int32 codesize, codemask, avail, oldcode, bits, valid_bits, clear; + stbi__gif_lzw *p; + + lzw_cs = stbi__get8(s); + if (lzw_cs > 12) return NULL; + clear = 1 << lzw_cs; + first = 1; + codesize = lzw_cs + 1; + codemask = (1 << codesize) - 1; + bits = 0; + valid_bits = 0; + for (init_code = 0; init_code < clear; init_code++) { + g->codes[init_code].prefix = -1; + g->codes[init_code].first = (stbi_uc) init_code; + g->codes[init_code].suffix = (stbi_uc) init_code; + } + + // support no starting clear code + avail = clear+2; + oldcode = -1; + + len = 0; + for(;;) { + if (valid_bits < codesize) { + if (len == 0) { + len = stbi__get8(s); // start new block + if (len == 0) + return g->out; + } + --len; + bits |= (stbi__int32) stbi__get8(s) << valid_bits; + valid_bits += 8; + } else { + stbi__int32 code = bits & codemask; + bits >>= codesize; + valid_bits -= codesize; + // @OPTIMIZE: is there some way we can accelerate the non-clear path? + if (code == clear) { // clear code + codesize = lzw_cs + 1; + codemask = (1 << codesize) - 1; + avail = clear + 2; + oldcode = -1; + first = 0; + } else if (code == clear + 1) { // end of stream code + stbi__skip(s, len); + while ((len = stbi__get8(s)) > 0) + stbi__skip(s,len); + return g->out; + } else if (code <= avail) { + if (first) { + return stbi__errpuc("no clear code", "Corrupt GIF"); + } + + if (oldcode >= 0) { + p = &g->codes[avail++]; + if (avail > 8192) { + return stbi__errpuc("too many codes", "Corrupt GIF"); + } + + p->prefix = (stbi__int16) oldcode; + p->first = g->codes[oldcode].first; + p->suffix = (code == avail) ? p->first : g->codes[code].first; + } else if (code == avail) + return stbi__errpuc("illegal code in raster", "Corrupt GIF"); + + stbi__out_gif_code(g, (stbi__uint16) code); + + if ((avail & codemask) == 0 && avail <= 0x0FFF) { + codesize++; + codemask = (1 << codesize) - 1; + } + + oldcode = code; + } else { + return stbi__errpuc("illegal code in raster", "Corrupt GIF"); + } + } + } +} + +// this function is designed to support animated gifs, although stb_image doesn't support it +// two back is the image from two frames ago, used for a very specific disposal format +static stbi_uc *stbi__gif_load_next(stbi__context *s, stbi__gif *g, int *comp, int req_comp, stbi_uc *two_back) +{ + int dispose; + int first_frame; + int pi; + int pcount; + STBI_NOTUSED(req_comp); + + // on first frame, any non-written pixels get the background colour (non-transparent) + first_frame = 0; + if (g->out == 0) { + if (!stbi__gif_header(s, g, comp,0)) return 0; // stbi__g_failure_reason set by stbi__gif_header + if (!stbi__mad3sizes_valid(4, g->w, g->h, 0)) + return stbi__errpuc("too large", "GIF image is too large"); + pcount = g->w * g->h; + g->out = (stbi_uc *) stbi__malloc(4 * pcount); + g->background = (stbi_uc *) stbi__malloc(4 * pcount); + g->history = (stbi_uc *) stbi__malloc(pcount); + if (!g->out || !g->background || !g->history) + return stbi__errpuc("outofmem", "Out of memory"); + + // image is treated as "transparent" at the start - ie, nothing overwrites the current background; + // background colour is only used for pixels that are not rendered first frame, after that "background" + // color refers to the color that was there the previous frame. + memset(g->out, 0x00, 4 * pcount); + memset(g->background, 0x00, 4 * pcount); // state of the background (starts transparent) + memset(g->history, 0x00, pcount); // pixels that were affected previous frame + first_frame = 1; + } else { + // second frame - how do we dispose of the previous one? + dispose = (g->eflags & 0x1C) >> 2; + pcount = g->w * g->h; + + if ((dispose == 3) && (two_back == 0)) { + dispose = 2; // if I don't have an image to revert back to, default to the old background + } + + if (dispose == 3) { // use previous graphic + for (pi = 0; pi < pcount; ++pi) { + if (g->history[pi]) { + memcpy( &g->out[pi * 4], &two_back[pi * 4], 4 ); + } + } + } else if (dispose == 2) { + // restore what was changed last frame to background before that frame; + for (pi = 0; pi < pcount; ++pi) { + if (g->history[pi]) { + memcpy( &g->out[pi * 4], &g->background[pi * 4], 4 ); + } + } + } else { + // This is a non-disposal case eithe way, so just + // leave the pixels as is, and they will become the new background + // 1: do not dispose + // 0: not specified. + } + + // background is what out is after the undoing of the previou frame; + memcpy( g->background, g->out, 4 * g->w * g->h ); + } + + // clear my history; + memset( g->history, 0x00, g->w * g->h ); // pixels that were affected previous frame + + for (;;) { + int tag = stbi__get8(s); + switch (tag) { + case 0x2C: /* Image Descriptor */ + { + stbi__int32 x, y, w, h; + stbi_uc *o; + + x = stbi__get16le(s); + y = stbi__get16le(s); + w = stbi__get16le(s); + h = stbi__get16le(s); + if (((x + w) > (g->w)) || ((y + h) > (g->h))) + return stbi__errpuc("bad Image Descriptor", "Corrupt GIF"); + + g->line_size = g->w * 4; + g->start_x = x * 4; + g->start_y = y * g->line_size; + g->max_x = g->start_x + w * 4; + g->max_y = g->start_y + h * g->line_size; + g->cur_x = g->start_x; + g->cur_y = g->start_y; + + // if the width of the specified rectangle is 0, that means + // we may not see *any* pixels or the image is malformed; + // to make sure this is caught, move the current y down to + // max_y (which is what out_gif_code checks). + if (w == 0) + g->cur_y = g->max_y; + + g->lflags = stbi__get8(s); + + if (g->lflags & 0x40) { + g->step = 8 * g->line_size; // first interlaced spacing + g->parse = 3; + } else { + g->step = g->line_size; + g->parse = 0; + } + + if (g->lflags & 0x80) { + stbi__gif_parse_colortable(s,g->lpal, 2 << (g->lflags & 7), g->eflags & 0x01 ? g->transparent : -1); + g->color_table = (stbi_uc *) g->lpal; + } else if (g->flags & 0x80) { + g->color_table = (stbi_uc *) g->pal; + } else + return stbi__errpuc("missing color table", "Corrupt GIF"); + + o = stbi__process_gif_raster(s, g); + if (!o) return NULL; + + // if this was the first frame, + pcount = g->w * g->h; + if (first_frame && (g->bgindex > 0)) { + // if first frame, any pixel not drawn to gets the background color + for (pi = 0; pi < pcount; ++pi) { + if (g->history[pi] == 0) { + g->pal[g->bgindex][3] = 255; // just in case it was made transparent, undo that; It will be reset next frame if need be; + memcpy( &g->out[pi * 4], &g->pal[g->bgindex], 4 ); + } + } + } + + return o; + } + + case 0x21: // Comment Extension. + { + int len; + int ext = stbi__get8(s); + if (ext == 0xF9) { // Graphic Control Extension. + len = stbi__get8(s); + if (len == 4) { + g->eflags = stbi__get8(s); + g->delay = 10 * stbi__get16le(s); // delay - 1/100th of a second, saving as 1/1000ths. + + // unset old transparent + if (g->transparent >= 0) { + g->pal[g->transparent][3] = 255; + } + if (g->eflags & 0x01) { + g->transparent = stbi__get8(s); + if (g->transparent >= 0) { + g->pal[g->transparent][3] = 0; + } + } else { + // don't need transparent + stbi__skip(s, 1); + g->transparent = -1; + } + } else { + stbi__skip(s, len); + break; + } + } + while ((len = stbi__get8(s)) != 0) { + stbi__skip(s, len); + } + break; + } + + case 0x3B: // gif stream termination code + return (stbi_uc *) s; // using '1' causes warning on some compilers + + default: + return stbi__errpuc("unknown code", "Corrupt GIF"); + } + } +} + +static void *stbi__load_gif_main_outofmem(stbi__gif *g, stbi_uc *out, int **delays) +{ + STBI_FREE(g->out); + STBI_FREE(g->history); + STBI_FREE(g->background); + + if (out) STBI_FREE(out); + if (delays && *delays) STBI_FREE(*delays); + return stbi__errpuc("outofmem", "Out of memory"); +} + +static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, int req_comp) +{ + if (stbi__gif_test(s)) { + int layers = 0; + stbi_uc *u = 0; + stbi_uc *out = 0; + stbi_uc *two_back = 0; + stbi__gif g; + int stride; + int out_size = 0; + int delays_size = 0; + + STBI_NOTUSED(out_size); + STBI_NOTUSED(delays_size); + + memset(&g, 0, sizeof(g)); + if (delays) { + *delays = 0; + } + + do { + u = stbi__gif_load_next(s, &g, comp, req_comp, two_back); + if (u == (stbi_uc *) s) u = 0; // end of animated gif marker + + if (u) { + *x = g.w; + *y = g.h; + ++layers; + stride = g.w * g.h * 4; + + if (out) { + void *tmp = (stbi_uc*) STBI_REALLOC_SIZED( out, out_size, layers * stride ); + if (!tmp) + return stbi__load_gif_main_outofmem(&g, out, delays); + else { + out = (stbi_uc*) tmp; + out_size = layers * stride; + } + + if (delays) { + int *new_delays = (int*) STBI_REALLOC_SIZED( *delays, delays_size, sizeof(int) * layers ); + if (!new_delays) + return stbi__load_gif_main_outofmem(&g, out, delays); + *delays = new_delays; + delays_size = layers * sizeof(int); + } + } else { + out = (stbi_uc*)stbi__malloc( layers * stride ); + if (!out) + return stbi__load_gif_main_outofmem(&g, out, delays); + out_size = layers * stride; + if (delays) { + *delays = (int*) stbi__malloc( layers * sizeof(int) ); + if (!*delays) + return stbi__load_gif_main_outofmem(&g, out, delays); + delays_size = layers * sizeof(int); + } + } + memcpy( out + ((layers - 1) * stride), u, stride ); + if (layers >= 2) { + two_back = out - 2 * stride; + } + + if (delays) { + (*delays)[layers - 1U] = g.delay; + } + } + } while (u != 0); + + // free temp buffer; + STBI_FREE(g.out); + STBI_FREE(g.history); + STBI_FREE(g.background); + + // do the final conversion after loading everything; + if (req_comp && req_comp != 4) + out = stbi__convert_format(out, 4, req_comp, layers * g.w, g.h); + + *z = layers; + return out; + } else { + return stbi__errpuc("not GIF", "Image was not as a gif type."); + } +} + +static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + stbi_uc *u = 0; + stbi__gif g; + memset(&g, 0, sizeof(g)); + STBI_NOTUSED(ri); + + u = stbi__gif_load_next(s, &g, comp, req_comp, 0); + if (u == (stbi_uc *) s) u = 0; // end of animated gif marker + if (u) { + *x = g.w; + *y = g.h; + + // moved conversion to after successful load so that the same + // can be done for multiple frames. + if (req_comp && req_comp != 4) + u = stbi__convert_format(u, 4, req_comp, g.w, g.h); + } else if (g.out) { + // if there was an error and we allocated an image buffer, free it! + STBI_FREE(g.out); + } + + // free buffers needed for multiple frame loading; + STBI_FREE(g.history); + STBI_FREE(g.background); + + return u; +} + +static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp) +{ + return stbi__gif_info_raw(s,x,y,comp); +} +#endif + +// ************************************************************************************************* +// Radiance RGBE HDR loader +// originally by Nicolas Schulz +#ifndef STBI_NO_HDR +static int stbi__hdr_test_core(stbi__context *s, const char *signature) +{ + int i; + for (i=0; signature[i]; ++i) + if (stbi__get8(s) != signature[i]) + return 0; + stbi__rewind(s); + return 1; +} + +static int stbi__hdr_test(stbi__context* s) +{ + int r = stbi__hdr_test_core(s, "#?RADIANCE\n"); + stbi__rewind(s); + if(!r) { + r = stbi__hdr_test_core(s, "#?RGBE\n"); + stbi__rewind(s); + } + return r; +} + +#define STBI__HDR_BUFLEN 1024 +static char *stbi__hdr_gettoken(stbi__context *z, char *buffer) +{ + int len=0; + char c = '\0'; + + c = (char) stbi__get8(z); + + while (!stbi__at_eof(z) && c != '\n') { + buffer[len++] = c; + if (len == STBI__HDR_BUFLEN-1) { + // flush to end of line + while (!stbi__at_eof(z) && stbi__get8(z) != '\n') + ; + break; + } + c = (char) stbi__get8(z); + } + + buffer[len] = 0; + return buffer; +} + +static void stbi__hdr_convert(float *output, stbi_uc *input, int req_comp) +{ + if ( input[3] != 0 ) { + float f1; + // Exponent + f1 = (float) ldexp(1.0f, input[3] - (int)(128 + 8)); + if (req_comp <= 2) + output[0] = (input[0] + input[1] + input[2]) * f1 / 3; + else { + output[0] = input[0] * f1; + output[1] = input[1] * f1; + output[2] = input[2] * f1; + } + if (req_comp == 2) output[1] = 1; + if (req_comp == 4) output[3] = 1; + } else { + switch (req_comp) { + case 4: output[3] = 1; /* fallthrough */ + case 3: output[0] = output[1] = output[2] = 0; + break; + case 2: output[1] = 1; /* fallthrough */ + case 1: output[0] = 0; + break; + } + } +} + +static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + char buffer[STBI__HDR_BUFLEN]; + char *token; + int valid = 0; + int width, height; + stbi_uc *scanline; + float *hdr_data; + int len; + unsigned char count, value; + int i, j, k, c1,c2, z; + const char *headerToken; + STBI_NOTUSED(ri); + + // Check identifier + headerToken = stbi__hdr_gettoken(s,buffer); + if (strcmp(headerToken, "#?RADIANCE") != 0 && strcmp(headerToken, "#?RGBE") != 0) + return stbi__errpf("not HDR", "Corrupt HDR image"); + + // Parse header + for(;;) { + token = stbi__hdr_gettoken(s,buffer); + if (token[0] == 0) break; + if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1; + } + + if (!valid) return stbi__errpf("unsupported format", "Unsupported HDR format"); + + // Parse width and height + // can't use sscanf() if we're not using stdio! + token = stbi__hdr_gettoken(s,buffer); + if (strncmp(token, "-Y ", 3)) return stbi__errpf("unsupported data layout", "Unsupported HDR format"); + token += 3; + height = (int) strtol(token, &token, 10); + while (*token == ' ') ++token; + if (strncmp(token, "+X ", 3)) return stbi__errpf("unsupported data layout", "Unsupported HDR format"); + token += 3; + width = (int) strtol(token, NULL, 10); + + if (height > STBI_MAX_DIMENSIONS) return stbi__errpf("too large","Very large image (corrupt?)"); + if (width > STBI_MAX_DIMENSIONS) return stbi__errpf("too large","Very large image (corrupt?)"); + + *x = width; + *y = height; + + if (comp) *comp = 3; + if (req_comp == 0) req_comp = 3; + + if (!stbi__mad4sizes_valid(width, height, req_comp, sizeof(float), 0)) + return stbi__errpf("too large", "HDR image is too large"); + + // Read data + hdr_data = (float *) stbi__malloc_mad4(width, height, req_comp, sizeof(float), 0); + if (!hdr_data) + return stbi__errpf("outofmem", "Out of memory"); + + // Load image data + // image data is stored as some number of sca + if ( width < 8 || width >= 32768) { + // Read flat data + for (j=0; j < height; ++j) { + for (i=0; i < width; ++i) { + stbi_uc rgbe[4]; + main_decode_loop: + stbi__getn(s, rgbe, 4); + stbi__hdr_convert(hdr_data + j * width * req_comp + i * req_comp, rgbe, req_comp); + } + } + } else { + // Read RLE-encoded data + scanline = NULL; + + for (j = 0; j < height; ++j) { + c1 = stbi__get8(s); + c2 = stbi__get8(s); + len = stbi__get8(s); + if (c1 != 2 || c2 != 2 || (len & 0x80)) { + // not run-length encoded, so we have to actually use THIS data as a decoded + // pixel (note this can't be a valid pixel--one of RGB must be >= 128) + stbi_uc rgbe[4]; + rgbe[0] = (stbi_uc) c1; + rgbe[1] = (stbi_uc) c2; + rgbe[2] = (stbi_uc) len; + rgbe[3] = (stbi_uc) stbi__get8(s); + stbi__hdr_convert(hdr_data, rgbe, req_comp); + i = 1; + j = 0; + STBI_FREE(scanline); + goto main_decode_loop; // yes, this makes no sense + } + len <<= 8; + len |= stbi__get8(s); + if (len != width) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("invalid decoded scanline length", "corrupt HDR"); } + if (scanline == NULL) { + scanline = (stbi_uc *) stbi__malloc_mad2(width, 4, 0); + if (!scanline) { + STBI_FREE(hdr_data); + return stbi__errpf("outofmem", "Out of memory"); + } + } + + for (k = 0; k < 4; ++k) { + int nleft; + i = 0; + while ((nleft = width - i) > 0) { + count = stbi__get8(s); + if (count > 128) { + // Run + value = stbi__get8(s); + count -= 128; + if ((count == 0) || (count > nleft)) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); } + for (z = 0; z < count; ++z) + scanline[i++ * 4 + k] = value; + } else { + // Dump + if ((count == 0) || (count > nleft)) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); } + for (z = 0; z < count; ++z) + scanline[i++ * 4 + k] = stbi__get8(s); + } + } + } + for (i=0; i < width; ++i) + stbi__hdr_convert(hdr_data+(j*width + i)*req_comp, scanline + i*4, req_comp); + } + if (scanline) + STBI_FREE(scanline); + } + + return hdr_data; +} + +static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp) +{ + char buffer[STBI__HDR_BUFLEN]; + char *token; + int valid = 0; + int dummy; + + if (!x) x = &dummy; + if (!y) y = &dummy; + if (!comp) comp = &dummy; + + if (stbi__hdr_test(s) == 0) { + stbi__rewind( s ); + return 0; + } + + for(;;) { + token = stbi__hdr_gettoken(s,buffer); + if (token[0] == 0) break; + if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1; + } + + if (!valid) { + stbi__rewind( s ); + return 0; + } + token = stbi__hdr_gettoken(s,buffer); + if (strncmp(token, "-Y ", 3)) { + stbi__rewind( s ); + return 0; + } + token += 3; + *y = (int) strtol(token, &token, 10); + while (*token == ' ') ++token; + if (strncmp(token, "+X ", 3)) { + stbi__rewind( s ); + return 0; + } + token += 3; + *x = (int) strtol(token, NULL, 10); + *comp = 3; + return 1; +} +#endif // STBI_NO_HDR + +#ifndef STBI_NO_BMP +static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp) +{ + void *p; + stbi__bmp_data info; + + info.all_a = 255; + p = stbi__bmp_parse_header(s, &info); + if (p == NULL) { + stbi__rewind( s ); + return 0; + } + if (x) *x = s->img_x; + if (y) *y = s->img_y; + if (comp) { + if (info.bpp == 24 && info.ma == 0xff000000) + *comp = 3; + else + *comp = info.ma ? 4 : 3; + } + return 1; +} +#endif + +#ifndef STBI_NO_PSD +static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp) +{ + int channelCount, dummy, depth; + if (!x) x = &dummy; + if (!y) y = &dummy; + if (!comp) comp = &dummy; + if (stbi__get32be(s) != 0x38425053) { + stbi__rewind( s ); + return 0; + } + if (stbi__get16be(s) != 1) { + stbi__rewind( s ); + return 0; + } + stbi__skip(s, 6); + channelCount = stbi__get16be(s); + if (channelCount < 0 || channelCount > 16) { + stbi__rewind( s ); + return 0; + } + *y = stbi__get32be(s); + *x = stbi__get32be(s); + depth = stbi__get16be(s); + if (depth != 8 && depth != 16) { + stbi__rewind( s ); + return 0; + } + if (stbi__get16be(s) != 3) { + stbi__rewind( s ); + return 0; + } + *comp = 4; + return 1; +} + +static int stbi__psd_is16(stbi__context *s) +{ + int channelCount, depth; + if (stbi__get32be(s) != 0x38425053) { + stbi__rewind( s ); + return 0; + } + if (stbi__get16be(s) != 1) { + stbi__rewind( s ); + return 0; + } + stbi__skip(s, 6); + channelCount = stbi__get16be(s); + if (channelCount < 0 || channelCount > 16) { + stbi__rewind( s ); + return 0; + } + STBI_NOTUSED(stbi__get32be(s)); + STBI_NOTUSED(stbi__get32be(s)); + depth = stbi__get16be(s); + if (depth != 16) { + stbi__rewind( s ); + return 0; + } + return 1; +} +#endif + +#ifndef STBI_NO_PIC +static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp) +{ + int act_comp=0,num_packets=0,chained,dummy; + stbi__pic_packet packets[10]; + + if (!x) x = &dummy; + if (!y) y = &dummy; + if (!comp) comp = &dummy; + + if (!stbi__pic_is4(s,"\x53\x80\xF6\x34")) { + stbi__rewind(s); + return 0; + } + + stbi__skip(s, 88); + + *x = stbi__get16be(s); + *y = stbi__get16be(s); + if (stbi__at_eof(s)) { + stbi__rewind( s); + return 0; + } + if ( (*x) != 0 && (1 << 28) / (*x) < (*y)) { + stbi__rewind( s ); + return 0; + } + + stbi__skip(s, 8); + + do { + stbi__pic_packet *packet; + + if (num_packets==sizeof(packets)/sizeof(packets[0])) + return 0; + + packet = &packets[num_packets++]; + chained = stbi__get8(s); + packet->size = stbi__get8(s); + packet->type = stbi__get8(s); + packet->channel = stbi__get8(s); + act_comp |= packet->channel; + + if (stbi__at_eof(s)) { + stbi__rewind( s ); + return 0; + } + if (packet->size != 8) { + stbi__rewind( s ); + return 0; + } + } while (chained); + + *comp = (act_comp & 0x10 ? 4 : 3); + + return 1; +} +#endif + +// ************************************************************************************************* +// Portable Gray Map and Portable Pixel Map loader +// by Ken Miller +// +// PGM: http://netpbm.sourceforge.net/doc/pgm.html +// PPM: http://netpbm.sourceforge.net/doc/ppm.html +// +// Known limitations: +// Does not support comments in the header section +// Does not support ASCII image data (formats P2 and P3) + +#ifndef STBI_NO_PNM + +static int stbi__pnm_test(stbi__context *s) +{ + char p, t; + p = (char) stbi__get8(s); + t = (char) stbi__get8(s); + if (p != 'P' || (t != '5' && t != '6')) { + stbi__rewind( s ); + return 0; + } + return 1; +} + +static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + stbi_uc *out; + STBI_NOTUSED(ri); + + ri->bits_per_channel = stbi__pnm_info(s, (int *)&s->img_x, (int *)&s->img_y, (int *)&s->img_n); + if (ri->bits_per_channel == 0) + return 0; + + if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + + *x = s->img_x; + *y = s->img_y; + if (comp) *comp = s->img_n; + + if (!stbi__mad4sizes_valid(s->img_n, s->img_x, s->img_y, ri->bits_per_channel / 8, 0)) + return stbi__errpuc("too large", "PNM too large"); + + out = (stbi_uc *) stbi__malloc_mad4(s->img_n, s->img_x, s->img_y, ri->bits_per_channel / 8, 0); + if (!out) return stbi__errpuc("outofmem", "Out of memory"); + if (!stbi__getn(s, out, s->img_n * s->img_x * s->img_y * (ri->bits_per_channel / 8))) { + STBI_FREE(out); + return stbi__errpuc("bad PNM", "PNM file truncated"); + } + + if (req_comp && req_comp != s->img_n) { + if (ri->bits_per_channel == 16) { + out = (stbi_uc *) stbi__convert_format16((stbi__uint16 *) out, s->img_n, req_comp, s->img_x, s->img_y); + } else { + out = stbi__convert_format(out, s->img_n, req_comp, s->img_x, s->img_y); + } + if (out == NULL) return out; // stbi__convert_format frees input on failure + } + return out; +} + +static int stbi__pnm_isspace(char c) +{ + return c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f' || c == '\r'; +} + +static void stbi__pnm_skip_whitespace(stbi__context *s, char *c) +{ + for (;;) { + while (!stbi__at_eof(s) && stbi__pnm_isspace(*c)) + *c = (char) stbi__get8(s); + + if (stbi__at_eof(s) || *c != '#') + break; + + while (!stbi__at_eof(s) && *c != '\n' && *c != '\r' ) + *c = (char) stbi__get8(s); + } +} + +static int stbi__pnm_isdigit(char c) +{ + return c >= '0' && c <= '9'; +} + +static int stbi__pnm_getinteger(stbi__context *s, char *c) +{ + int value = 0; + + while (!stbi__at_eof(s) && stbi__pnm_isdigit(*c)) { + value = value*10 + (*c - '0'); + *c = (char) stbi__get8(s); + if((value > 214748364) || (value == 214748364 && *c > '7')) + return stbi__err("integer parse overflow", "Parsing an integer in the PPM header overflowed a 32-bit int"); + } + + return value; +} + +static int stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp) +{ + int maxv, dummy; + char c, p, t; + + if (!x) x = &dummy; + if (!y) y = &dummy; + if (!comp) comp = &dummy; + + stbi__rewind(s); + + // Get identifier + p = (char) stbi__get8(s); + t = (char) stbi__get8(s); + if (p != 'P' || (t != '5' && t != '6')) { + stbi__rewind(s); + return 0; + } + + *comp = (t == '6') ? 3 : 1; // '5' is 1-component .pgm; '6' is 3-component .ppm + + c = (char) stbi__get8(s); + stbi__pnm_skip_whitespace(s, &c); + + *x = stbi__pnm_getinteger(s, &c); // read width + if(*x == 0) + return stbi__err("invalid width", "PPM image header had zero or overflowing width"); + stbi__pnm_skip_whitespace(s, &c); + + *y = stbi__pnm_getinteger(s, &c); // read height + if (*y == 0) + return stbi__err("invalid width", "PPM image header had zero or overflowing width"); + stbi__pnm_skip_whitespace(s, &c); + + maxv = stbi__pnm_getinteger(s, &c); // read max value + if (maxv > 65535) + return stbi__err("max value > 65535", "PPM image supports only 8-bit and 16-bit images"); + else if (maxv > 255) + return 16; + else + return 8; +} + +static int stbi__pnm_is16(stbi__context *s) +{ + if (stbi__pnm_info(s, NULL, NULL, NULL) == 16) + return 1; + return 0; +} +#endif + +static int stbi__info_main(stbi__context *s, int *x, int *y, int *comp) +{ + #ifndef STBI_NO_JPEG + if (stbi__jpeg_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PNG + if (stbi__png_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_GIF + if (stbi__gif_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_BMP + if (stbi__bmp_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PSD + if (stbi__psd_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PIC + if (stbi__pic_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PNM + if (stbi__pnm_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_HDR + if (stbi__hdr_info(s, x, y, comp)) return 1; + #endif + + // test tga last because it's a crappy test! + #ifndef STBI_NO_TGA + if (stbi__tga_info(s, x, y, comp)) + return 1; + #endif + return stbi__err("unknown image type", "Image not of any known type, or corrupt"); +} + +static int stbi__is_16_main(stbi__context *s) +{ + #ifndef STBI_NO_PNG + if (stbi__png_is16(s)) return 1; + #endif + + #ifndef STBI_NO_PSD + if (stbi__psd_is16(s)) return 1; + #endif + + #ifndef STBI_NO_PNM + if (stbi__pnm_is16(s)) return 1; + #endif + return 0; +} + +#ifndef STBI_NO_STDIO +STBIDEF int stbi_info(char const *filename, int *x, int *y, int *comp) +{ + FILE *f = stbi__fopen(filename, "rb"); + int result; + if (!f) return stbi__err("can't fopen", "Unable to open file"); + result = stbi_info_from_file(f, x, y, comp); + fclose(f); + return result; +} + +STBIDEF int stbi_info_from_file(FILE *f, int *x, int *y, int *comp) +{ + int r; + stbi__context s; + long pos = ftell(f); + stbi__start_file(&s, f); + r = stbi__info_main(&s,x,y,comp); + fseek(f,pos,SEEK_SET); + return r; +} + +STBIDEF int stbi_is_16_bit(char const *filename) +{ + FILE *f = stbi__fopen(filename, "rb"); + int result; + if (!f) return stbi__err("can't fopen", "Unable to open file"); + result = stbi_is_16_bit_from_file(f); + fclose(f); + return result; +} + +STBIDEF int stbi_is_16_bit_from_file(FILE *f) +{ + int r; + stbi__context s; + long pos = ftell(f); + stbi__start_file(&s, f); + r = stbi__is_16_main(&s); + fseek(f,pos,SEEK_SET); + return r; +} +#endif // !STBI_NO_STDIO + +STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__info_main(&s,x,y,comp); +} + +STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *c, void *user, int *x, int *y, int *comp) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user); + return stbi__info_main(&s,x,y,comp); +} + +STBIDEF int stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__is_16_main(&s); +} + +STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *c, void *user) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user); + return stbi__is_16_main(&s); +} + +#endif // STB_IMAGE_IMPLEMENTATION + +/* + revision history: + 2.20 (2019-02-07) support utf8 filenames in Windows; fix warnings and platform ifdefs + 2.19 (2018-02-11) fix warning + 2.18 (2018-01-30) fix warnings + 2.17 (2018-01-29) change sbti__shiftsigned to avoid clang -O2 bug + 1-bit BMP + *_is_16_bit api + avoid warnings + 2.16 (2017-07-23) all functions have 16-bit variants; + STBI_NO_STDIO works again; + compilation fixes; + fix rounding in unpremultiply; + optimize vertical flip; + disable raw_len validation; + documentation fixes + 2.15 (2017-03-18) fix png-1,2,4 bug; now all Imagenet JPGs decode; + warning fixes; disable run-time SSE detection on gcc; + uniform handling of optional "return" values; + thread-safe initialization of zlib tables + 2.14 (2017-03-03) remove deprecated STBI_JPEG_OLD; fixes for Imagenet JPGs + 2.13 (2016-11-29) add 16-bit API, only supported for PNG right now + 2.12 (2016-04-02) fix typo in 2.11 PSD fix that caused crashes + 2.11 (2016-04-02) allocate large structures on the stack + remove white matting for transparent PSD + fix reported channel count for PNG & BMP + re-enable SSE2 in non-gcc 64-bit + support RGB-formatted JPEG + read 16-bit PNGs (only as 8-bit) + 2.10 (2016-01-22) avoid warning introduced in 2.09 by STBI_REALLOC_SIZED + 2.09 (2016-01-16) allow comments in PNM files + 16-bit-per-pixel TGA (not bit-per-component) + info() for TGA could break due to .hdr handling + info() for BMP to shares code instead of sloppy parse + can use STBI_REALLOC_SIZED if allocator doesn't support realloc + code cleanup + 2.08 (2015-09-13) fix to 2.07 cleanup, reading RGB PSD as RGBA + 2.07 (2015-09-13) fix compiler warnings + partial animated GIF support + limited 16-bpc PSD support + #ifdef unused functions + bug with < 92 byte PIC,PNM,HDR,TGA + 2.06 (2015-04-19) fix bug where PSD returns wrong '*comp' value + 2.05 (2015-04-19) fix bug in progressive JPEG handling, fix warning + 2.04 (2015-04-15) try to re-enable SIMD on MinGW 64-bit + 2.03 (2015-04-12) extra corruption checking (mmozeiko) + stbi_set_flip_vertically_on_load (nguillemot) + fix NEON support; fix mingw support + 2.02 (2015-01-19) fix incorrect assert, fix warning + 2.01 (2015-01-17) fix various warnings; suppress SIMD on gcc 32-bit without -msse2 + 2.00b (2014-12-25) fix STBI_MALLOC in progressive JPEG + 2.00 (2014-12-25) optimize JPG, including x86 SSE2 & NEON SIMD (ryg) + progressive JPEG (stb) + PGM/PPM support (Ken Miller) + STBI_MALLOC,STBI_REALLOC,STBI_FREE + GIF bugfix -- seemingly never worked + STBI_NO_*, STBI_ONLY_* + 1.48 (2014-12-14) fix incorrectly-named assert() + 1.47 (2014-12-14) 1/2/4-bit PNG support, both direct and paletted (Omar Cornut & stb) + optimize PNG (ryg) + fix bug in interlaced PNG with user-specified channel count (stb) + 1.46 (2014-08-26) + fix broken tRNS chunk (colorkey-style transparency) in non-paletted PNG + 1.45 (2014-08-16) + fix MSVC-ARM internal compiler error by wrapping malloc + 1.44 (2014-08-07) + various warning fixes from Ronny Chevalier + 1.43 (2014-07-15) + fix MSVC-only compiler problem in code changed in 1.42 + 1.42 (2014-07-09) + don't define _CRT_SECURE_NO_WARNINGS (affects user code) + fixes to stbi__cleanup_jpeg path + added STBI_ASSERT to avoid requiring assert.h + 1.41 (2014-06-25) + fix search&replace from 1.36 that messed up comments/error messages + 1.40 (2014-06-22) + fix gcc struct-initialization warning + 1.39 (2014-06-15) + fix to TGA optimization when req_comp != number of components in TGA; + fix to GIF loading because BMP wasn't rewinding (whoops, no GIFs in my test suite) + add support for BMP version 5 (more ignored fields) + 1.38 (2014-06-06) + suppress MSVC warnings on integer casts truncating values + fix accidental rename of 'skip' field of I/O + 1.37 (2014-06-04) + remove duplicate typedef + 1.36 (2014-06-03) + convert to header file single-file library + if de-iphone isn't set, load iphone images color-swapped instead of returning NULL + 1.35 (2014-05-27) + various warnings + fix broken STBI_SIMD path + fix bug where stbi_load_from_file no longer left file pointer in correct place + fix broken non-easy path for 32-bit BMP (possibly never used) + TGA optimization by Arseny Kapoulkine + 1.34 (unknown) + use STBI_NOTUSED in stbi__resample_row_generic(), fix one more leak in tga failure case + 1.33 (2011-07-14) + make stbi_is_hdr work in STBI_NO_HDR (as specified), minor compiler-friendly improvements + 1.32 (2011-07-13) + support for "info" function for all supported filetypes (SpartanJ) + 1.31 (2011-06-20) + a few more leak fixes, bug in PNG handling (SpartanJ) + 1.30 (2011-06-11) + added ability to load files via callbacks to accomidate custom input streams (Ben Wenger) + removed deprecated format-specific test/load functions + removed support for installable file formats (stbi_loader) -- would have been broken for IO callbacks anyway + error cases in bmp and tga give messages and don't leak (Raymond Barbiero, grisha) + fix inefficiency in decoding 32-bit BMP (David Woo) + 1.29 (2010-08-16) + various warning fixes from Aurelien Pocheville + 1.28 (2010-08-01) + fix bug in GIF palette transparency (SpartanJ) + 1.27 (2010-08-01) + cast-to-stbi_uc to fix warnings + 1.26 (2010-07-24) + fix bug in file buffering for PNG reported by SpartanJ + 1.25 (2010-07-17) + refix trans_data warning (Won Chun) + 1.24 (2010-07-12) + perf improvements reading from files on platforms with lock-heavy fgetc() + minor perf improvements for jpeg + deprecated type-specific functions so we'll get feedback if they're needed + attempt to fix trans_data warning (Won Chun) + 1.23 fixed bug in iPhone support + 1.22 (2010-07-10) + removed image *writing* support + stbi_info support from Jetro Lauha + GIF support from Jean-Marc Lienher + iPhone PNG-extensions from James Brown + warning-fixes from Nicolas Schulz and Janez Zemva (i.stbi__err. Janez (U+017D)emva) + 1.21 fix use of 'stbi_uc' in header (reported by jon blow) + 1.20 added support for Softimage PIC, by Tom Seddon + 1.19 bug in interlaced PNG corruption check (found by ryg) + 1.18 (2008-08-02) + fix a threading bug (local mutable static) + 1.17 support interlaced PNG + 1.16 major bugfix - stbi__convert_format converted one too many pixels + 1.15 initialize some fields for thread safety + 1.14 fix threadsafe conversion bug + header-file-only version (#define STBI_HEADER_FILE_ONLY before including) + 1.13 threadsafe + 1.12 const qualifiers in the API + 1.11 Support installable IDCT, colorspace conversion routines + 1.10 Fixes for 64-bit (don't use "unsigned long") + optimized upsampling by Fabian "ryg" Giesen + 1.09 Fix format-conversion for PSD code (bad global variables!) + 1.08 Thatcher Ulrich's PSD code integrated by Nicolas Schulz + 1.07 attempt to fix C++ warning/errors again + 1.06 attempt to fix C++ warning/errors again + 1.05 fix TGA loading to return correct *comp and use good luminance calc + 1.04 default float alpha is 1, not 255; use 'void *' for stbi_image_free + 1.03 bugfixes to STBI_NO_STDIO, STBI_NO_HDR + 1.02 support for (subset of) HDR files, float interface for preferred access to them + 1.01 fix bug: possible bug in handling right-side up bmps... not sure + fix bug: the stbi__bmp_load() and stbi__tga_load() functions didn't work at all + 1.00 interface to zlib that skips zlib header + 0.99 correct handling of alpha in palette + 0.98 TGA loader by lonesock; dynamically add loaders (untested) + 0.97 jpeg errors on too large a file; also catch another malloc failure + 0.96 fix detection of invalid v value - particleman@mollyrocket forum + 0.95 during header scan, seek to markers in case of padding + 0.94 STBI_NO_STDIO to disable stdio usage; rename all #defines the same + 0.93 handle jpegtran output; verbose errors + 0.92 read 4,8,16,24,32-bit BMP files of several formats + 0.91 output 24-bit Windows 3.0 BMP files + 0.90 fix a few more warnings; bump version number to approach 1.0 + 0.61 bugfixes due to Marc LeBlanc, Christopher Lloyd + 0.60 fix compiling as c++ + 0.59 fix warnings: merge Dave Moore's -Wall fixes + 0.58 fix bug: zlib uncompressed mode len/nlen was wrong endian + 0.57 fix bug: jpg last huffman symbol before marker was >9 bits but less than 16 available + 0.56 fix bug: zlib uncompressed mode len vs. nlen + 0.55 fix bug: restart_interval not initialized to 0 + 0.54 allow NULL for 'int *comp' + 0.53 fix bug in png 3->4; speedup png decoding + 0.52 png handles req_comp=3,4 directly; minor cleanup; jpeg comments + 0.51 obey req_comp requests, 1-component jpegs return as 1-component, + on 'test' only check type, not whether we support this variant + 0.50 (2006-11-19) + first released version +*/ + + +/* +------------------------------------------------------------------------------ +This software is available under 2 licenses -- choose whichever you prefer. +------------------------------------------------------------------------------ +ALTERNATIVE A - MIT License +Copyright (c) 2017 Sean Barrett +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is furnished to do +so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +------------------------------------------------------------------------------ +ALTERNATIVE B - Public Domain (www.unlicense.org) +This is free and unencumbered software released into the public domain. +Anyone is free to copy, modify, publish, use, compile, sell, or distribute this +software, either in source code form or as a compiled binary, for any purpose, +commercial or non-commercial, and by any means. +In jurisdictions that recognize copyright laws, the author or authors of this +software dedicate any and all copyright interest in the software to the public +domain. We make this dedication for the benefit of the public at large and to +the detriment of our heirs and successors. We intend this dedication to be an +overt act of relinquishment in perpetuity of all present and future rights to +this software under copyright law. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN +ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +------------------------------------------------------------------------------ +*/ diff --git a/tests/data/c/stb/stb_image_resize2.h b/tests/data/c/stb/stb_image_resize2.h new file mode 100644 index 000000000..079897658 --- /dev/null +++ b/tests/data/c/stb/stb_image_resize2.h @@ -0,0 +1,10679 @@ +/* stb_image_resize2 - v2.18 - public domain image resizing + + by Jeff Roberts (v2) and Jorge L Rodriguez + http://github.com/nothings/stb + + Can be threaded with the extended API. SSE2, AVX, Neon and WASM SIMD support. Only + scaling and translation is supported, no rotations or shears. + + COMPILING & LINKING + In one C/C++ file that #includes this file, do this: + #define STB_IMAGE_RESIZE_IMPLEMENTATION + before the #include. That will create the implementation in that file. + + EASY API CALLS: + Easy API downsamples w/Mitchell filter, upsamples w/cubic interpolation, clamps to edge. + + stbir_resize_uint8_srgb( input_pixels, input_w, input_h, input_stride_in_bytes, + output_pixels, output_w, output_h, output_stride_in_bytes, + pixel_layout_enum ) + + stbir_resize_uint8_linear( input_pixels, input_w, input_h, input_stride_in_bytes, + output_pixels, output_w, output_h, output_stride_in_bytes, + pixel_layout_enum ) + + stbir_resize_float_linear( input_pixels, input_w, input_h, input_stride_in_bytes, + output_pixels, output_w, output_h, output_stride_in_bytes, + pixel_layout_enum ) + + If you pass NULL or zero for the output_pixels, we will allocate the output buffer + for you and return it from the function (free with free() or STBIR_FREE). + As a special case, XX_stride_in_bytes of 0 means packed continuously in memory. + + API LEVELS + There are three levels of API - easy-to-use, medium-complexity and extended-complexity. + + See the "header file" section of the source for API documentation. + + ADDITIONAL DOCUMENTATION + + MEMORY ALLOCATION + By default, we use malloc and free for memory allocation. To override the + memory allocation, before the implementation #include, add a: + + #define STBIR_MALLOC(size,user_data) ... + #define STBIR_FREE(ptr,user_data) ... + + Each resize makes exactly one call to malloc/free (unless you use the + extended API where you can do one allocation for many resizes). Under + address sanitizer, we do separate allocations to find overread/writes. + + PERFORMANCE + This library was written with an emphasis on performance. When testing + stb_image_resize with RGBA, the fastest mode is STBIR_4CHANNEL with + STBIR_TYPE_UINT8 pixels and CLAMPed edges (which is what many other resize + libs do by default). Also, make sure SIMD is turned on of course (default + for 64-bit targets). Avoid WRAP edge mode if you want the fastest speed. + + This library also comes with profiling built-in. If you define STBIR_PROFILE, + you can use the advanced API and get low-level profiling information by + calling stbir_resize_extended_profile_info() or stbir_resize_split_profile_info() + after a resize. + + SIMD + Most of the routines have optimized SSE2, AVX, NEON and WASM versions. + + On Microsoft compilers, we automatically turn on SIMD for 64-bit x64 and + ARM; for 32-bit x86 and ARM, you select SIMD mode by defining STBIR_SSE2 or + STBIR_NEON. For AVX and AVX2, we auto-select it by detecting the /arch:AVX + or /arch:AVX2 switches. You can also always manually turn SSE2, AVX or AVX2 + support on by defining STBIR_SSE2, STBIR_AVX or STBIR_AVX2. + + On Linux, SSE2 and Neon is on by default for 64-bit x64 or ARM64. For 32-bit, + we select x86 SIMD mode by whether you have -msse2, -mavx or -mavx2 enabled + on the command line. For 32-bit ARM, you must pass -mfpu=neon-vfpv4 for both + clang and GCC, but GCC also requires an additional -mfp16-format=ieee to + automatically enable NEON. + + On x86 platforms, you can also define STBIR_FP16C to turn on FP16C instructions + for converting back and forth to half-floats. This is autoselected when we + are using AVX2. Clang and GCC also require the -mf16c switch. ARM always uses + the built-in half float hardware NEON instructions. + + You can also tell us to use multiply-add instructions with STBIR_USE_FMA. + Because x86 doesn't always have fma, we turn it off by default to maintain + determinism across all platforms. If you don't care about non-FMA determinism + and are willing to restrict yourself to more recent x86 CPUs (around the AVX + timeframe), then fma will give you around a 15% speedup. + + You can force off SIMD in all cases by defining STBIR_NO_SIMD. You can turn + off AVX or AVX2 specifically with STBIR_NO_AVX or STBIR_NO_AVX2. AVX is 10% + to 40% faster, and AVX2 is generally another 12%. + + ALPHA CHANNEL + Most of the resizing functions provide the ability to control how the alpha + channel of an image is processed. + + When alpha represents transparency, it is important that when combining + colors with filtering, the pixels should not be treated equally; they + should use a weighted average based on their alpha values. For example, + if a pixel is 1% opaque bright green and another pixel is 99% opaque + black and you average them, the average will be 50% opaque, but the + unweighted average and will be a middling green color, while the weighted + average will be nearly black. This means the unweighted version introduced + green energy that didn't exist in the source image. + + (If you want to know why this makes sense, you can work out the math for + the following: consider what happens if you alpha composite a source image + over a fixed color and then average the output, vs. if you average the + source image pixels and then composite that over the same fixed color. + Only the weighted average produces the same result as the ground truth + composite-then-average result.) + + Therefore, it is in general best to "alpha weight" the pixels when applying + filters to them. This essentially means multiplying the colors by the alpha + values before combining them, and then dividing by the alpha value at the + end. + + The computer graphics industry introduced a technique called "premultiplied + alpha" or "associated alpha" in which image colors are stored in image files + already multiplied by their alpha. This saves some math when compositing, + and also avoids the need to divide by the alpha at the end (which is quite + inefficient). However, while premultiplied alpha is common in the movie CGI + industry, it is not commonplace in other industries like videogames, and most + consumer file formats are generally expected to contain not-premultiplied + colors. For example, Photoshop saves PNG files "unpremultiplied", and web + browsers like Chrome and Firefox expect PNG images to be unpremultiplied. + + Note that there are three possibilities that might describe your image + and resize expectation: + + 1. images are not premultiplied, alpha weighting is desired + 2. images are not premultiplied, alpha weighting is not desired + 3. images are premultiplied + + Both case #2 and case #3 require the exact same math: no alpha weighting + should be applied or removed. Only case 1 requires extra math operations; + the other two cases can be handled identically. + + stb_image_resize expects case #1 by default, applying alpha weighting to + images, expecting the input images to be unpremultiplied. This is what the + COLOR+ALPHA buffer types tell the resizer to do. + + When you use the pixel layouts STBIR_RGBA, STBIR_BGRA, STBIR_ARGB, + STBIR_ABGR, STBIR_RA, or STBIR_AR you are telling us that the pixels are + non-premultiplied. In these cases, the resizer will alpha weight the colors + (effectively creating the premultiplied image), do the filtering, and then + convert back to non-premult on exit. + + When you use the pixel layouts STBIR_RGBA_PM, STBIR_BGRA_PM, STBIR_ARGB_PM, + STBIR_ABGR_PM, STBIR_RA_PM or STBIR_AR_PM, you are telling that the pixels + ARE premultiplied. In this case, the resizer doesn't have to do the + premultipling - it can filter directly on the input. This about twice as + fast as the non-premultiplied case, so it's the right option if your data is + already setup correctly. + + When you use the pixel layout STBIR_4CHANNEL or STBIR_2CHANNEL, you are + telling us that there is no channel that represents transparency; it may be + RGB and some unrelated fourth channel that has been stored in the alpha + channel, but it is actually not alpha. No special processing will be + performed. + + The difference between the generic 4 or 2 channel layouts, and the + specialized _PM versions is with the _PM versions you are telling us that + the data *is* alpha, just don't premultiply it. That's important when + using SRGB pixel formats, we need to know where the alpha is, because + it is converted linearly (rather than with the SRGB converters). + + Because alpha weighting produces the same effect as premultiplying, you + even have the option with non-premultiplied inputs to let the resizer + produce a premultiplied output. Because the intially computed alpha-weighted + output image is effectively premultiplied, this is actually more performant + than the normal path which un-premultiplies the output image as a final step. + + Finally, when converting both in and out of non-premulitplied space (for + example, when using STBIR_RGBA), we go to somewhat heroic measures to + ensure that areas with zero alpha value pixels get something reasonable + in the RGB values. If you don't care about the RGB values of zero alpha + pixels, you can call the stbir_set_non_pm_alpha_speed_over_quality() + function - this runs a premultiplied resize about 25% faster. That said, + when you really care about speed, using premultiplied pixels for both in + and out (STBIR_RGBA_PM, etc) much faster than both of these premultiplied + options. + + PIXEL LAYOUT CONVERSION + The resizer can convert from some pixel layouts to others. When using the + stbir_set_pixel_layouts(), you can, for example, specify STBIR_RGBA + on input, and STBIR_ARGB on output, and it will re-organize the channels + during the resize. Currently, you can only convert between two pixel + layouts with the same number of channels. + + DETERMINISM + We commit to being deterministic (from x64 to ARM to scalar to SIMD, etc). + This requires compiling with fast-math off (using at least /fp:precise). + Also, you must turn off fp-contracting (which turns mult+adds into fmas)! + We attempt to do this with pragmas, but with Clang, you usually want to add + -ffp-contract=off to the command line as well. + + For 32-bit x86, you must use SSE and SSE2 codegen for determinism. That is, + if the scalar x87 unit gets used at all, we immediately lose determinism. + On Microsoft Visual Studio 2008 and earlier, from what we can tell there is + no way to be deterministic in 32-bit x86 (some x87 always leaks in, even + with fp:strict). On 32-bit x86 GCC, determinism requires both -msse2 and + -fpmath=sse. + + Note that we will not be deterministic with float data containing NaNs - + the NaNs will propagate differently on different SIMD and platforms. + + If you turn on STBIR_USE_FMA, then we will be deterministic with other + fma targets, but we will differ from non-fma targets (this is unavoidable, + because a fma isn't simply an add with a mult - it also introduces a + rounding difference compared to non-fma instruction sequences. + + FLOAT PIXEL FORMAT RANGE + Any range of values can be used for the non-alpha float data that you pass + in (0 to 1, -1 to 1, whatever). However, if you are inputting float values + but *outputting* bytes or shorts, you must use a range of 0 to 1 so that we + scale back properly. The alpha channel must also be 0 to 1 for any format + that does premultiplication prior to resizing. + + Note also that with float output, using filters with negative lobes, the + output filtered values might go slightly out of range. You can define + STBIR_FLOAT_LOW_CLAMP and/or STBIR_FLOAT_HIGH_CLAMP to specify the range + to clamp to on output, if that's important. + + MAX/MIN SCALE FACTORS + The input pixel resolutions are in integers, and we do the internal pointer + resolution in size_t sized integers. However, the scale ratio from input + resolution to output resolution is calculated in float form. This means + the effective possible scale ratio is limited to 24 bits (or 16 million + to 1). As you get close to the size of the float resolution (again, 16 + million pixels wide or high), you might start seeing float inaccuracy + issues in general in the pipeline. If you have to do extreme resizes, + you can usually do this is multiple stages (using float intermediate + buffers). + + FLIPPED IMAGES + Stride is just the delta from one scanline to the next. This means you can + use a negative stride to handle inverted images (point to the final + scanline and use a negative stride). You can invert the input or output, + using negative strides. + + DEFAULT FILTERS + For functions which don't provide explicit control over what filters to + use, you can change the compile-time defaults with: + + #define STBIR_DEFAULT_FILTER_UPSAMPLE STBIR_FILTER_something + #define STBIR_DEFAULT_FILTER_DOWNSAMPLE STBIR_FILTER_something + + See stbir_filter in the header-file section for the list of filters. + + NEW FILTERS + A number of 1D filter kernels are supplied. For a list of supported + filters, see the stbir_filter enum. You can install your own filters by + using the stbir_set_filter_callbacks function. + + PROGRESS + For interactive use with slow resize operations, you can use the + scanline callbacks in the extended API. It would have to be a *very* large + image resample to need progress though - we're very fast. + + CEIL and FLOOR + In scalar mode, the only functions we use from math.h are ceilf and floorf, + but if you have your own versions, you can define the STBIR_CEILF(v) and + STBIR_FLOORF(v) macros and we'll use them instead. In SIMD, we just use + our own versions. + + ASSERT + Define STBIR_ASSERT(boolval) to override assert() and not use assert.h + + PORTING FROM VERSION 1 + The API has changed. You can continue to use the old version of stb_image_resize.h, + which is available in the "deprecated/" directory. + + If you're using the old simple-to-use API, porting is straightforward. + (For more advanced APIs, read the documentation.) + + stbir_resize_uint8(): + - call `stbir_resize_uint8_linear`, cast channel count to `stbir_pixel_layout` + + stbir_resize_float(): + - call `stbir_resize_float_linear`, cast channel count to `stbir_pixel_layout` + + stbir_resize_uint8_srgb(): + - function name is unchanged + - cast channel count to `stbir_pixel_layout` + - above is sufficient unless your image has alpha and it's not RGBA/BGRA + - in that case, follow the below instructions for stbir_resize_uint8_srgb_edgemode + + stbir_resize_uint8_srgb_edgemode() + - switch to the "medium complexity" API + - stbir_resize(), very similar API but a few more parameters: + - pixel_layout: cast channel count to `stbir_pixel_layout` + - data_type: STBIR_TYPE_UINT8_SRGB + - edge: unchanged (STBIR_EDGE_WRAP, etc.) + - filter: STBIR_FILTER_DEFAULT + - which channel is alpha is specified in stbir_pixel_layout, see enum for details + + FUTURE TODOS + * For polyphase integral filters, we just memcpy the coeffs to dupe + them, but we should indirect and use the same coeff memory. + * Add pixel layout conversions for sensible different channel counts + (maybe, 1->3/4, 3->4, 4->1, 3->1). + * For SIMD encode and decode scanline routines, do any pre-aligning + for bad input/output buffer alignments and pitch? + * For very wide scanlines, we should we do vertical strips to stay within + L2 cache. Maybe do chunks of 1K pixels at a time. There would be + some pixel reconversion, but probably dwarfed by things falling out + of cache. Probably also something possible with alternating between + scattering and gathering at high resize scales? + * Should we have a multiple MIPs at the same time function (could keep + more memory in cache during multiple resizes)? + * Rewrite the coefficient generator to do many at once. + * AVX-512 vertical kernels - worried about downclocking here. + * Convert the reincludes to macros when we know they aren't changing. + * Experiment with pivoting the horizontal and always using the + vertical filters (which are faster, but perhaps not enough to overcome + the pivot cost and the extra memory touches). Need to buffer the whole + image so have to balance memory use. + * Most of our code is internally function pointers, should we compile + all the SIMD stuff always and dynamically dispatch? + + CONTRIBUTORS + Jeff Roberts: 2.0 implementation, optimizations, SIMD + Martins Mozeiko: NEON simd, WASM simd, clang and GCC whisperer + Fabian Giesen: half float and srgb converters + Sean Barrett: API design, optimizations + Jorge L Rodriguez: Original 1.0 implementation + Aras Pranckevicius: bugfixes + Nathan Reed: warning fixes for 1.0 + + REVISIONS + 2.18 (2026-03-25) fixed coefficient calculation when skipping a coefficient off + the left side of the window, added non-aligned access safe + memcpy mode for scalar path, fixed various typos, and fixed + define error in the float clamp output mode. + 2.17 (2025-10-25) silly format bug in easy-to-use APIs. + 2.16 (2025-10-21) fixed the easy-to-use APIs to allow inverted bitmaps (negative + strides), fix vertical filter kernel callback, fix threaded + gather buffer priming (and assert). + (thanks adipose, TainZerL, and Harrison Green) + 2.15 (2025-07-17) fixed an assert in debug mode when using floats with input + callbacks, work around GCC warning when adding to null ptr + (thanks Johannes Spohr and Pyry Kovanen). + 2.14 (2025-05-09) fixed a bug using downsampling gather horizontal first, and + scatter with vertical first. + 2.13 (2025-02-27) fixed a bug when using input callbacks, turned off simd for + tiny-c, fixed some variables that should have been static, + fixes a bug when calculating temp memory with resizes that + exceed 2GB of temp memory (very large resizes). + 2.12 (2024-10-18) fix incorrect use of user_data with STBIR_FREE + 2.11 (2024-09-08) fix harmless asan warnings in 2-channel and 3-channel mode + with AVX-2, fix some weird scaling edge conditions with + point sample mode. + 2.10 (2024-07-27) fix the defines GCC and mingw for loop unroll control, + fix MSVC 32-bit arm half float routines. + 2.09 (2024-06-19) fix the defines for 32-bit ARM GCC builds (was selecting + hardware half floats). + 2.08 (2024-06-10) fix for RGB->BGR three channel flips and add SIMD (thanks + to Ryan Salsbury), fix for sub-rect resizes, use the + pragmas to control unrolling when they are available. + 2.07 (2024-05-24) fix for slow final split during threaded conversions of very + wide scanlines when downsampling (caused by extra input + converting), fix for wide scanline resamples with many + splits (int overflow), fix GCC warning. + 2.06 (2024-02-10) fix for identical width/height 3x or more down-scaling + undersampling a single row on rare resize ratios (about 1%). + 2.05 (2024-02-07) fix for 2 pixel to 1 pixel resizes with wrap (thanks Aras), + fix for output callback (thanks Julien Koenen). + 2.04 (2023-11-17) fix for rare AVX bug, shadowed symbol (thanks Nikola Smiljanic). + 2.03 (2023-11-01) ASAN and TSAN warnings fixed, minor tweaks. + 2.00 (2023-10-10) mostly new source: new api, optimizations, simd, vertical-first, etc + 2x-5x faster without simd, 4x-12x faster with simd, + in some cases, 20x to 40x faster esp resizing large to very small. + 0.96 (2019-03-04) fixed warnings + 0.95 (2017-07-23) fixed warnings + 0.94 (2017-03-18) fixed warnings + 0.93 (2017-03-03) fixed bug with certain combinations of heights + 0.92 (2017-01-02) fix integer overflow on large (>2GB) images + 0.91 (2016-04-02) fix warnings; fix handling of subpixel regions + 0.90 (2014-09-17) first released version + + LICENSE + See end of file for license information. +*/ + +#if !defined(STB_IMAGE_RESIZE_DO_HORIZONTALS) && !defined(STB_IMAGE_RESIZE_DO_VERTICALS) && !defined(STB_IMAGE_RESIZE_DO_CODERS) // for internal re-includes + +#ifndef STBIR_INCLUDE_STB_IMAGE_RESIZE2_H +#define STBIR_INCLUDE_STB_IMAGE_RESIZE2_H + +#include +#ifdef _MSC_VER +typedef unsigned char stbir_uint8; +typedef unsigned short stbir_uint16; +typedef unsigned int stbir_uint32; +typedef unsigned __int64 stbir_uint64; +#else +#include +typedef uint8_t stbir_uint8; +typedef uint16_t stbir_uint16; +typedef uint32_t stbir_uint32; +typedef uint64_t stbir_uint64; +#endif + +#ifndef STBIRDEF +#ifdef STB_IMAGE_RESIZE_STATIC +#define STBIRDEF static +#else +#ifdef __cplusplus +#define STBIRDEF extern "C" +#else +#define STBIRDEF extern +#endif +#endif +#endif + +////////////////////////////////////////////////////////////////////////////// +//// start "header file" /////////////////////////////////////////////////// +// +// Easy-to-use API: +// +// * stride is the offset between successive rows of image data +// in memory, in bytes. specify 0 for packed continuously in memory +// * colorspace is linear or sRGB as specified by function name +// * Uses the default filters +// * Uses edge mode clamped +// * returned result is 1 for success or 0 in case of an error. + + +// stbir_pixel_layout specifies: +// number of channels +// order of channels +// whether color is premultiplied by alpha +// for back compatibility, you can cast the old channel count to an stbir_pixel_layout +typedef enum +{ + STBIR_1CHANNEL = 1, + STBIR_2CHANNEL = 2, + STBIR_RGB = 3, // 3-chan, with order specified (for channel flipping) + STBIR_BGR = 0, // 3-chan, with order specified (for channel flipping) + STBIR_4CHANNEL = 5, + + STBIR_RGBA = 4, // alpha formats, where alpha is NOT premultiplied into color channels + STBIR_BGRA = 6, + STBIR_ARGB = 7, + STBIR_ABGR = 8, + STBIR_RA = 9, + STBIR_AR = 10, + + STBIR_RGBA_PM = 11, // alpha formats, where alpha is premultiplied into color channels + STBIR_BGRA_PM = 12, + STBIR_ARGB_PM = 13, + STBIR_ABGR_PM = 14, + STBIR_RA_PM = 15, + STBIR_AR_PM = 16, + + STBIR_RGBA_NO_AW = 11, // alpha formats, where NO alpha weighting is applied at all! + STBIR_BGRA_NO_AW = 12, // these are just synonyms for the _PM flags (which also do + STBIR_ARGB_NO_AW = 13, // no alpha weighting). These names just make it more clear + STBIR_ABGR_NO_AW = 14, // for some folks). + STBIR_RA_NO_AW = 15, + STBIR_AR_NO_AW = 16, + +} stbir_pixel_layout; + +//=============================================================== +// Simple-complexity API +// +// If output_pixels is NULL (0), then we will allocate the buffer and return it to you. +//-------------------------------- + +STBIRDEF unsigned char * stbir_resize_uint8_srgb( const unsigned char *input_pixels , int input_w , int input_h, int input_stride_in_bytes, + unsigned char *output_pixels, int output_w, int output_h, int output_stride_in_bytes, + stbir_pixel_layout pixel_type ); + +STBIRDEF unsigned char * stbir_resize_uint8_linear( const unsigned char *input_pixels , int input_w , int input_h, int input_stride_in_bytes, + unsigned char *output_pixels, int output_w, int output_h, int output_stride_in_bytes, + stbir_pixel_layout pixel_type ); + +STBIRDEF float * stbir_resize_float_linear( const float *input_pixels , int input_w , int input_h, int input_stride_in_bytes, + float *output_pixels, int output_w, int output_h, int output_stride_in_bytes, + stbir_pixel_layout pixel_type ); +//=============================================================== + +//=============================================================== +// Medium-complexity API +// +// This extends the easy-to-use API as follows: +// +// * Can specify the datatype - U8, U8_SRGB, U16, FLOAT, HALF_FLOAT +// * Edge wrap can selected explicitly +// * Filter can be selected explicitly +//-------------------------------- + +typedef enum +{ + STBIR_EDGE_CLAMP = 0, + STBIR_EDGE_REFLECT = 1, + STBIR_EDGE_WRAP = 2, // this edge mode is slower and uses more memory + STBIR_EDGE_ZERO = 3, +} stbir_edge; + +typedef enum +{ + STBIR_FILTER_DEFAULT = 0, // use same filter type that easy-to-use API chooses + STBIR_FILTER_BOX = 1, // A trapezoid w/1-pixel wide ramps, same result as box for integer scale ratios + STBIR_FILTER_TRIANGLE = 2, // On upsampling, produces same results as bilinear texture filtering + STBIR_FILTER_CUBICBSPLINE = 3, // The cubic b-spline (aka Mitchell-Netrevalli with B=1,C=0), gaussian-esque + STBIR_FILTER_CATMULLROM = 4, // An interpolating cubic spline + STBIR_FILTER_MITCHELL = 5, // Mitchell-Netrevalli filter with B=1/3, C=1/3 + STBIR_FILTER_POINT_SAMPLE = 6, // Simple point sampling + STBIR_FILTER_OTHER = 7, // User callback specified +} stbir_filter; + +typedef enum +{ + STBIR_TYPE_UINT8 = 0, + STBIR_TYPE_UINT8_SRGB = 1, + STBIR_TYPE_UINT8_SRGB_ALPHA = 2, // alpha channel, when present, should also be SRGB (this is very unusual) + STBIR_TYPE_UINT16 = 3, + STBIR_TYPE_FLOAT = 4, + STBIR_TYPE_HALF_FLOAT = 5 +} stbir_datatype; + +// medium api +STBIRDEF void * stbir_resize( const void *input_pixels , int input_w , int input_h, int input_stride_in_bytes, + void *output_pixels, int output_w, int output_h, int output_stride_in_bytes, + stbir_pixel_layout pixel_layout, stbir_datatype data_type, + stbir_edge edge, stbir_filter filter ); +//=============================================================== + + + +//=============================================================== +// Extended-complexity API +// +// This API exposes all resize functionality. +// +// * Separate filter types for each axis +// * Separate edge modes for each axis +// * Separate input and output data types +// * Can specify regions with subpixel correctness +// * Can specify alpha flags +// * Can specify a memory callback +// * Can specify a callback data type for pixel input and output +// * Can be threaded for a single resize +// * Can be used to resize many frames without recalculating the sampler info +// +// Use this API as follows: +// 1) Call the stbir_resize_init function on a local STBIR_RESIZE structure +// 2) Call any of the stbir_set functions +// 3) Optionally call stbir_build_samplers() if you are going to resample multiple times +// with the same input and output dimensions (like resizing video frames) +// 4) Resample by calling stbir_resize_extended(). +// 5) Call stbir_free_samplers() if you called stbir_build_samplers() +//-------------------------------- + + +// Types: + +// INPUT CALLBACK: this callback is used for input scanlines +typedef void const * stbir_input_callback( void * optional_output, void const * input_ptr, int num_pixels, int x, int y, void * context ); + +// OUTPUT CALLBACK: this callback is used for output scanlines +typedef void stbir_output_callback( void const * output_ptr, int num_pixels, int y, void * context ); + +// callbacks for user installed filters +typedef float stbir__kernel_callback( float x, float scale, void * user_data ); // centered at zero +typedef float stbir__support_callback( float scale, void * user_data ); + +// internal structure with precomputed scaling +typedef struct stbir__info stbir__info; + +typedef struct STBIR_RESIZE // use the stbir_resize_init and stbir_override functions to set these values for future compatibility +{ + void * user_data; + void const * input_pixels; + int input_w, input_h; + double input_s0, input_t0, input_s1, input_t1; + stbir_input_callback * input_cb; + void * output_pixels; + int output_w, output_h; + int output_subx, output_suby, output_subw, output_subh; + stbir_output_callback * output_cb; + int input_stride_in_bytes; + int output_stride_in_bytes; + int splits; + int fast_alpha; + int needs_rebuild; + int called_alloc; + stbir_pixel_layout input_pixel_layout_public; + stbir_pixel_layout output_pixel_layout_public; + stbir_datatype input_data_type; + stbir_datatype output_data_type; + stbir_filter horizontal_filter, vertical_filter; + stbir_edge horizontal_edge, vertical_edge; + stbir__kernel_callback * horizontal_filter_kernel; stbir__support_callback * horizontal_filter_support; + stbir__kernel_callback * vertical_filter_kernel; stbir__support_callback * vertical_filter_support; + stbir__info * samplers; +} STBIR_RESIZE; + +// extended complexity api + + +// First off, you must ALWAYS call stbir_resize_init on your resize structure before any of the other calls! +STBIRDEF void stbir_resize_init( STBIR_RESIZE * resize, + const void *input_pixels, int input_w, int input_h, int input_stride_in_bytes, // stride can be zero + void *output_pixels, int output_w, int output_h, int output_stride_in_bytes, // stride can be zero + stbir_pixel_layout pixel_layout, stbir_datatype data_type ); + +//=============================================================== +// You can update these parameters any time after resize_init and there is no cost +//-------------------------------- + +STBIRDEF void stbir_set_datatypes( STBIR_RESIZE * resize, stbir_datatype input_type, stbir_datatype output_type ); +STBIRDEF void stbir_set_pixel_callbacks( STBIR_RESIZE * resize, stbir_input_callback * input_cb, stbir_output_callback * output_cb ); // no callbacks by default +STBIRDEF void stbir_set_user_data( STBIR_RESIZE * resize, void * user_data ); // pass back STBIR_RESIZE* by default +STBIRDEF void stbir_set_buffer_ptrs( STBIR_RESIZE * resize, const void * input_pixels, int input_stride_in_bytes, void * output_pixels, int output_stride_in_bytes ); + +//=============================================================== + + +//=============================================================== +// If you call any of these functions, you will trigger a sampler rebuild! +//-------------------------------- + +STBIRDEF int stbir_set_pixel_layouts( STBIR_RESIZE * resize, stbir_pixel_layout input_pixel_layout, stbir_pixel_layout output_pixel_layout ); // sets new buffer layouts +STBIRDEF int stbir_set_edgemodes( STBIR_RESIZE * resize, stbir_edge horizontal_edge, stbir_edge vertical_edge ); // CLAMP by default + +STBIRDEF int stbir_set_filters( STBIR_RESIZE * resize, stbir_filter horizontal_filter, stbir_filter vertical_filter ); // STBIR_DEFAULT_FILTER_UPSAMPLE/DOWNSAMPLE by default +STBIRDEF int stbir_set_filter_callbacks( STBIR_RESIZE * resize, stbir__kernel_callback * horizontal_filter, stbir__support_callback * horizontal_support, stbir__kernel_callback * vertical_filter, stbir__support_callback * vertical_support ); + +STBIRDEF int stbir_set_pixel_subrect( STBIR_RESIZE * resize, int subx, int suby, int subw, int subh ); // sets both sub-regions (full regions by default) +STBIRDEF int stbir_set_input_subrect( STBIR_RESIZE * resize, double s0, double t0, double s1, double t1 ); // sets input sub-region (full region by default) +STBIRDEF int stbir_set_output_pixel_subrect( STBIR_RESIZE * resize, int subx, int suby, int subw, int subh ); // sets output sub-region (full region by default) + +// when inputting AND outputting non-premultiplied alpha pixels, we use a slower but higher quality technique +// that fills the zero alpha pixel's RGB values with something plausible. If you don't care about areas of +// zero alpha, you can call this function to get about a 25% speed improvement for STBIR_RGBA to STBIR_RGBA +// types of resizes. +STBIRDEF int stbir_set_non_pm_alpha_speed_over_quality( STBIR_RESIZE * resize, int non_pma_alpha_speed_over_quality ); +//=============================================================== + + +//=============================================================== +// You can call build_samplers to prebuild all the internal data we need to resample. +// Then, if you call resize_extended many times with the same resize, you only pay the +// cost once. +// If you do call build_samplers, you MUST call free_samplers eventually. +//-------------------------------- + +// This builds the samplers and does one allocation +STBIRDEF int stbir_build_samplers( STBIR_RESIZE * resize ); + +// You MUST call this, if you call stbir_build_samplers or stbir_build_samplers_with_splits +STBIRDEF void stbir_free_samplers( STBIR_RESIZE * resize ); +//=============================================================== + + +// And this is the main function to perform the resize synchronously on one thread. +STBIRDEF int stbir_resize_extended( STBIR_RESIZE * resize ); + + +//=============================================================== +// Use these functions for multithreading. +// 1) You call stbir_build_samplers_with_splits first on the main thread +// 2) Then stbir_resize_with_split on each thread +// 3) stbir_free_samplers when done on the main thread +//-------------------------------- + +// This will build samplers for threading. +// You can pass in the number of threads you'd like to use (try_splits). +// It returns the number of splits (threads) that you can call it with. +/// It might be less if the image resize can't be split up that many ways. + +STBIRDEF int stbir_build_samplers_with_splits( STBIR_RESIZE * resize, int try_splits ); + +// This function does a split of the resizing (you call this fuction for each +// split, on multiple threads). A split is a piece of the output resize pixel space. + +// Note that you MUST call stbir_build_samplers_with_splits before stbir_resize_extended_split! + +// Usually, you will always call stbir_resize_split with split_start as the thread_index +// and "1" for the split_count. +// But, if you have a weird situation where you MIGHT want 8 threads, but sometimes +// only 4 threads, you can use 0,2,4,6 for the split_start's and use "2" for the +// split_count each time to turn in into a 4 thread resize. (This is unusual). + +STBIRDEF int stbir_resize_extended_split( STBIR_RESIZE * resize, int split_start, int split_count ); +//=============================================================== + + +//=============================================================== +// Pixel Callbacks info: +//-------------------------------- + +// The input callback is super flexible - it calls you with the input address +// (based on the stride and base pointer), it gives you an optional_output +// pointer that you can fill, or you can just return your own pointer into +// your own data. +// +// You can also do conversion from non-supported data types if necessary - in +// this case, you ignore the input_ptr and just use the x and y parameters to +// calculate your own input_ptr based on the size of each non-supported pixel. +// (Something like the third example below.) +// +// You can also install just an input or just an output callback by setting the +// callback that you don't want to zero. +// +// First example, progress: (getting a callback that you can monitor the progress): +// void const * my_callback( void * optional_output, void const * input_ptr, int num_pixels, int x, int y, void * context ) +// { +// percentage_done = y / input_height; +// return input_ptr; // use buffer from call +// } +// +// Next example, copying: (copy from some other buffer or stream): +// void const * my_callback( void * optional_output, void const * input_ptr, int num_pixels, int x, int y, void * context ) +// { +// CopyOrStreamData( optional_output, other_data_src, num_pixels * pixel_width_in_bytes ); +// return optional_output; // return the optional buffer that we filled +// } +// +// Third example, input another buffer without copying: (zero-copy from other buffer): +// void const * my_callback( void * optional_output, void const * input_ptr, int num_pixels, int x, int y, void * context ) +// { +// void * pixels = ( (char*) other_image_base ) + ( y * other_image_stride ) + ( x * other_pixel_width_in_bytes ); +// return pixels; // return pointer to your data without copying +// } +// +// +// The output callback is considerably simpler - it just calls you so that you can dump +// out each scanline. You could even directly copy out to disk if you have a simple format +// like TGA or BMP. You can also convert to other output types here if you want. +// +// Simple example: +// void const * my_output( void * output_ptr, int num_pixels, int y, void * context ) +// { +// percentage_done = y / output_height; +// fwrite( output_ptr, pixel_width_in_bytes, num_pixels, output_file ); +// } +//=============================================================== + + + + +//=============================================================== +// optional built-in profiling API +//-------------------------------- + +#ifdef STBIR_PROFILE + +typedef struct STBIR_PROFILE_INFO +{ + stbir_uint64 total_clocks; + + // how many clocks spent (of total_clocks) in the various resize routines, along with a string description + // there are "resize_count" number of zones + stbir_uint64 clocks[ 8 ]; + char const ** descriptions; + + // count of clocks and descriptions + stbir_uint32 count; +} STBIR_PROFILE_INFO; + +// use after calling stbir_resize_extended (or stbir_build_samplers or stbir_build_samplers_with_splits) +STBIRDEF void stbir_resize_build_profile_info( STBIR_PROFILE_INFO * out_info, STBIR_RESIZE const * resize ); + +// use after calling stbir_resize_extended +STBIRDEF void stbir_resize_extended_profile_info( STBIR_PROFILE_INFO * out_info, STBIR_RESIZE const * resize ); + +// use after calling stbir_resize_extended_split +STBIRDEF void stbir_resize_split_profile_info( STBIR_PROFILE_INFO * out_info, STBIR_RESIZE const * resize, int split_start, int split_num ); + +//=============================================================== + +#endif + + +//// end header file ///////////////////////////////////////////////////// +#endif // STBIR_INCLUDE_STB_IMAGE_RESIZE2_H + +#if defined(STB_IMAGE_RESIZE_IMPLEMENTATION) || defined(STB_IMAGE_RESIZE2_IMPLEMENTATION) + +#ifndef STBIR_ASSERT +#include +#define STBIR_ASSERT(x) assert(x) +#endif + +#ifndef STBIR_MALLOC +#include +#define STBIR_MALLOC(size,user_data) ((void)(user_data), malloc(size)) +#define STBIR_FREE(ptr,user_data) ((void)(user_data), free(ptr)) +// (we used the comma operator to evaluate user_data, to avoid "unused parameter" warnings) +#endif + +#ifdef _MSC_VER + +#define stbir__inline __forceinline + +#else + +#define stbir__inline __inline__ + +// Clang address sanitizer +#if defined(__has_feature) + #if __has_feature(address_sanitizer) || __has_feature(memory_sanitizer) + #ifndef STBIR__SEPARATE_ALLOCATIONS + #define STBIR__SEPARATE_ALLOCATIONS + #endif + #endif +#endif + +#endif + +// GCC and MSVC +#if defined(__SANITIZE_ADDRESS__) + #ifndef STBIR__SEPARATE_ALLOCATIONS + #define STBIR__SEPARATE_ALLOCATIONS + #endif +#endif + +// Always turn off automatic FMA use - use STBIR_USE_FMA if you want. +// Otherwise, this is a determinism disaster. +#ifndef STBIR_DONT_CHANGE_FP_CONTRACT // override in case you don't want this behavior +#if defined(_MSC_VER) && !defined(__clang__) +#if _MSC_VER > 1200 +#pragma fp_contract(off) +#endif +#elif defined(__GNUC__) && !defined(__clang__) +#pragma GCC optimize("fp-contract=off") +#else +#pragma STDC FP_CONTRACT OFF +#endif +#endif + +#ifdef _MSC_VER +#define STBIR__UNUSED(v) (void)(v) +#else +#define STBIR__UNUSED(v) (void)sizeof(v) +#endif + +#define STBIR__ARRAY_SIZE(a) (sizeof((a))/sizeof((a)[0])) + + +#ifndef STBIR_DEFAULT_FILTER_UPSAMPLE +#define STBIR_DEFAULT_FILTER_UPSAMPLE STBIR_FILTER_CATMULLROM +#endif + +#ifndef STBIR_DEFAULT_FILTER_DOWNSAMPLE +#define STBIR_DEFAULT_FILTER_DOWNSAMPLE STBIR_FILTER_MITCHELL +#endif + + +#ifndef STBIR__HEADER_FILENAME +#define STBIR__HEADER_FILENAME "stb_image_resize2.h" +#endif + +// the internal pixel layout enums are in a different order, so we can easily do range comparisons of types +// the public pixel layout is ordered in a way that if you cast num_channels (1-4) to the enum, you get something sensible +typedef enum +{ + STBIRI_1CHANNEL = 0, + STBIRI_2CHANNEL = 1, + STBIRI_RGB = 2, + STBIRI_BGR = 3, + STBIRI_4CHANNEL = 4, + + STBIRI_RGBA = 5, + STBIRI_BGRA = 6, + STBIRI_ARGB = 7, + STBIRI_ABGR = 8, + STBIRI_RA = 9, + STBIRI_AR = 10, + + STBIRI_RGBA_PM = 11, + STBIRI_BGRA_PM = 12, + STBIRI_ARGB_PM = 13, + STBIRI_ABGR_PM = 14, + STBIRI_RA_PM = 15, + STBIRI_AR_PM = 16, +} stbir_internal_pixel_layout; + +// define the public pixel layouts to not compile inside the implementation (to avoid accidental use) +#define STBIR_BGR bad_dont_use_in_implementation +#define STBIR_1CHANNEL STBIR_BGR +#define STBIR_2CHANNEL STBIR_BGR +#define STBIR_RGB STBIR_BGR +#define STBIR_RGBA STBIR_BGR +#define STBIR_4CHANNEL STBIR_BGR +#define STBIR_BGRA STBIR_BGR +#define STBIR_ARGB STBIR_BGR +#define STBIR_ABGR STBIR_BGR +#define STBIR_RA STBIR_BGR +#define STBIR_AR STBIR_BGR +#define STBIR_RGBA_PM STBIR_BGR +#define STBIR_BGRA_PM STBIR_BGR +#define STBIR_ARGB_PM STBIR_BGR +#define STBIR_ABGR_PM STBIR_BGR +#define STBIR_RA_PM STBIR_BGR +#define STBIR_AR_PM STBIR_BGR + +// must match stbir_datatype +static unsigned char stbir__type_size[] = { + 1,1,1,2,4,2 // STBIR_TYPE_UINT8,STBIR_TYPE_UINT8_SRGB,STBIR_TYPE_UINT8_SRGB_ALPHA,STBIR_TYPE_UINT16,STBIR_TYPE_FLOAT,STBIR_TYPE_HALF_FLOAT +}; + +// When gathering, the contributors are which source pixels contribute. +// When scattering, the contributors are which destination pixels are contributed to. +typedef struct +{ + int n0; // First contributing pixel + int n1; // Last contributing pixel +} stbir__contributors; + +typedef struct +{ + int lowest; // First sample index for whole filter + int highest; // Last sample index for whole filter + int widest; // widest single set of samples for an output +} stbir__filter_extent_info; + +typedef struct +{ + int n0; // First pixel of decode buffer to write to + int n1; // Last pixel of decode that will be written to + int pixel_offset_for_input; // Pixel offset into input_scanline +} stbir__span; + +typedef struct stbir__scale_info +{ + int input_full_size; + int output_sub_size; + float scale; + float inv_scale; + float pixel_shift; // starting shift in output pixel space (in pixels) + int scale_is_rational; + stbir_uint32 scale_numerator, scale_denominator; +} stbir__scale_info; + +typedef struct +{ + stbir__contributors * contributors; + float* coefficients; + stbir__contributors * gather_prescatter_contributors; + float * gather_prescatter_coefficients; + stbir__scale_info scale_info; + float support; + stbir_filter filter_enum; + stbir__kernel_callback * filter_kernel; + stbir__support_callback * filter_support; + stbir_edge edge; + int coefficient_width; + int filter_pixel_width; + int filter_pixel_margin; + int num_contributors; + int contributors_size; + int coefficients_size; + stbir__filter_extent_info extent_info; + int is_gather; // 0 = scatter, 1 = gather with scale >= 1, 2 = gather with scale < 1 + int gather_prescatter_num_contributors; + int gather_prescatter_coefficient_width; + int gather_prescatter_contributors_size; + int gather_prescatter_coefficients_size; +} stbir__sampler; + +typedef struct +{ + stbir__contributors conservative; + int edge_sizes[2]; // this can be less than filter_pixel_margin, if the filter and scaling falls off + stbir__span spans[2]; // can be two spans, if doing input subrect with clamp mode WRAP +} stbir__extents; + +typedef struct +{ +#ifdef STBIR_PROFILE + union + { + struct { stbir_uint64 total, looping, vertical, horizontal, decode, encode, alpha, unalpha; } named; + stbir_uint64 array[8]; + } profile; + stbir_uint64 * current_zone_excluded_ptr; +#endif + float* decode_buffer; + + int ring_buffer_first_scanline; + int ring_buffer_last_scanline; + int ring_buffer_begin_index; // first_scanline is at this index in the ring buffer + int start_output_y, end_output_y; + int start_input_y, end_input_y; // used in scatter only + + #ifdef STBIR__SEPARATE_ALLOCATIONS + float** ring_buffers; // one pointer for each ring buffer + #else + float* ring_buffer; // one big buffer that we index into + #endif + + float* vertical_buffer; + + char no_cache_straddle[64]; +} stbir__per_split_info; + +typedef float * stbir__decode_pixels_func( float * decode, int width_times_channels, void const * input ); +typedef void stbir__alpha_weight_func( float * decode_buffer, int width_times_channels ); +typedef void stbir__horizontal_gather_channels_func( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, + stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width ); +typedef void stbir__alpha_unweight_func(float * encode_buffer, int width_times_channels ); +typedef void stbir__encode_pixels_func( void * output, int width_times_channels, float const * encode ); + +struct stbir__info +{ +#ifdef STBIR_PROFILE + union + { + struct { stbir_uint64 total, build, alloc, horizontal, vertical, cleanup, pivot; } named; + stbir_uint64 array[7]; + } profile; + stbir_uint64 * current_zone_excluded_ptr; +#endif + stbir__sampler horizontal; + stbir__sampler vertical; + + void const * input_data; + void * output_data; + + int input_stride_bytes; + int output_stride_bytes; + int ring_buffer_length_bytes; // The length of an individual entry in the ring buffer. The total number of ring buffers is stbir__get_filter_pixel_width(filter) + int ring_buffer_num_entries; // Total number of entries in the ring buffer. + + stbir_datatype input_type; + stbir_datatype output_type; + + stbir_input_callback * in_pixels_cb; + void * user_data; + stbir_output_callback * out_pixels_cb; + + stbir__extents scanline_extents; + + void * alloced_mem; + stbir__per_split_info * split_info; // by default 1, but there will be N of these allocated based on the thread init you did + + stbir__decode_pixels_func * decode_pixels; + stbir__alpha_weight_func * alpha_weight; + stbir__horizontal_gather_channels_func * horizontal_gather_channels; + stbir__alpha_unweight_func * alpha_unweight; + stbir__encode_pixels_func * encode_pixels; + + int alloc_ring_buffer_num_entries; // Number of entries in the ring buffer that will be allocated + int splits; // count of splits + + stbir_internal_pixel_layout input_pixel_layout_internal; + stbir_internal_pixel_layout output_pixel_layout_internal; + + int input_color_and_type; + int offset_x, offset_y; // offset within output_data + int vertical_first; + int channels; + int effective_channels; // same as channels, except on RGBA/ARGB (7), or XA/AX (3) + size_t alloced_total; +}; + + +#define stbir__max_uint8_as_float 255.0f +#define stbir__max_uint16_as_float 65535.0f +#define stbir__max_uint8_as_float_inverted 3.9215689e-03f // (1.0f/255.0f) +#define stbir__max_uint16_as_float_inverted 1.5259022e-05f // (1.0f/65535.0f) +#define stbir__small_float ((float)1 / (1 << 20) / (1 << 20) / (1 << 20) / (1 << 20) / (1 << 20) / (1 << 20)) + +// min/max friendly +#define STBIR_CLAMP(x, xmin, xmax) for(;;) { \ + if ( (x) < (xmin) ) (x) = (xmin); \ + if ( (x) > (xmax) ) (x) = (xmax); \ + break; \ +} + +static stbir__inline int stbir__min(int a, int b) +{ + return a < b ? a : b; +} + +static stbir__inline int stbir__max(int a, int b) +{ + return a > b ? a : b; +} + +static float stbir__srgb_uchar_to_linear_float[256] = { + 0.000000f, 0.000304f, 0.000607f, 0.000911f, 0.001214f, 0.001518f, 0.001821f, 0.002125f, 0.002428f, 0.002732f, 0.003035f, + 0.003347f, 0.003677f, 0.004025f, 0.004391f, 0.004777f, 0.005182f, 0.005605f, 0.006049f, 0.006512f, 0.006995f, 0.007499f, + 0.008023f, 0.008568f, 0.009134f, 0.009721f, 0.010330f, 0.010960f, 0.011612f, 0.012286f, 0.012983f, 0.013702f, 0.014444f, + 0.015209f, 0.015996f, 0.016807f, 0.017642f, 0.018500f, 0.019382f, 0.020289f, 0.021219f, 0.022174f, 0.023153f, 0.024158f, + 0.025187f, 0.026241f, 0.027321f, 0.028426f, 0.029557f, 0.030713f, 0.031896f, 0.033105f, 0.034340f, 0.035601f, 0.036889f, + 0.038204f, 0.039546f, 0.040915f, 0.042311f, 0.043735f, 0.045186f, 0.046665f, 0.048172f, 0.049707f, 0.051269f, 0.052861f, + 0.054480f, 0.056128f, 0.057805f, 0.059511f, 0.061246f, 0.063010f, 0.064803f, 0.066626f, 0.068478f, 0.070360f, 0.072272f, + 0.074214f, 0.076185f, 0.078187f, 0.080220f, 0.082283f, 0.084376f, 0.086500f, 0.088656f, 0.090842f, 0.093059f, 0.095307f, + 0.097587f, 0.099899f, 0.102242f, 0.104616f, 0.107023f, 0.109462f, 0.111932f, 0.114435f, 0.116971f, 0.119538f, 0.122139f, + 0.124772f, 0.127438f, 0.130136f, 0.132868f, 0.135633f, 0.138432f, 0.141263f, 0.144128f, 0.147027f, 0.149960f, 0.152926f, + 0.155926f, 0.158961f, 0.162029f, 0.165132f, 0.168269f, 0.171441f, 0.174647f, 0.177888f, 0.181164f, 0.184475f, 0.187821f, + 0.191202f, 0.194618f, 0.198069f, 0.201556f, 0.205079f, 0.208637f, 0.212231f, 0.215861f, 0.219526f, 0.223228f, 0.226966f, + 0.230740f, 0.234551f, 0.238398f, 0.242281f, 0.246201f, 0.250158f, 0.254152f, 0.258183f, 0.262251f, 0.266356f, 0.270498f, + 0.274677f, 0.278894f, 0.283149f, 0.287441f, 0.291771f, 0.296138f, 0.300544f, 0.304987f, 0.309469f, 0.313989f, 0.318547f, + 0.323143f, 0.327778f, 0.332452f, 0.337164f, 0.341914f, 0.346704f, 0.351533f, 0.356400f, 0.361307f, 0.366253f, 0.371238f, + 0.376262f, 0.381326f, 0.386430f, 0.391573f, 0.396755f, 0.401978f, 0.407240f, 0.412543f, 0.417885f, 0.423268f, 0.428691f, + 0.434154f, 0.439657f, 0.445201f, 0.450786f, 0.456411f, 0.462077f, 0.467784f, 0.473532f, 0.479320f, 0.485150f, 0.491021f, + 0.496933f, 0.502887f, 0.508881f, 0.514918f, 0.520996f, 0.527115f, 0.533276f, 0.539480f, 0.545725f, 0.552011f, 0.558340f, + 0.564712f, 0.571125f, 0.577581f, 0.584078f, 0.590619f, 0.597202f, 0.603827f, 0.610496f, 0.617207f, 0.623960f, 0.630757f, + 0.637597f, 0.644480f, 0.651406f, 0.658375f, 0.665387f, 0.672443f, 0.679543f, 0.686685f, 0.693872f, 0.701102f, 0.708376f, + 0.715694f, 0.723055f, 0.730461f, 0.737911f, 0.745404f, 0.752942f, 0.760525f, 0.768151f, 0.775822f, 0.783538f, 0.791298f, + 0.799103f, 0.806952f, 0.814847f, 0.822786f, 0.830770f, 0.838799f, 0.846873f, 0.854993f, 0.863157f, 0.871367f, 0.879622f, + 0.887923f, 0.896269f, 0.904661f, 0.913099f, 0.921582f, 0.930111f, 0.938686f, 0.947307f, 0.955974f, 0.964686f, 0.973445f, + 0.982251f, 0.991102f, 1.0f +}; + +typedef union +{ + unsigned int u; + float f; +} stbir__FP32; + +// From https://gist.github.com/rygorous/2203834 + +static const stbir_uint32 fp32_to_srgb8_tab4[104] = { + 0x0073000d, 0x007a000d, 0x0080000d, 0x0087000d, 0x008d000d, 0x0094000d, 0x009a000d, 0x00a1000d, + 0x00a7001a, 0x00b4001a, 0x00c1001a, 0x00ce001a, 0x00da001a, 0x00e7001a, 0x00f4001a, 0x0101001a, + 0x010e0033, 0x01280033, 0x01410033, 0x015b0033, 0x01750033, 0x018f0033, 0x01a80033, 0x01c20033, + 0x01dc0067, 0x020f0067, 0x02430067, 0x02760067, 0x02aa0067, 0x02dd0067, 0x03110067, 0x03440067, + 0x037800ce, 0x03df00ce, 0x044600ce, 0x04ad00ce, 0x051400ce, 0x057b00c5, 0x05dd00bc, 0x063b00b5, + 0x06970158, 0x07420142, 0x07e30130, 0x087b0120, 0x090b0112, 0x09940106, 0x0a1700fc, 0x0a9500f2, + 0x0b0f01cb, 0x0bf401ae, 0x0ccb0195, 0x0d950180, 0x0e56016e, 0x0f0d015e, 0x0fbc0150, 0x10630143, + 0x11070264, 0x1238023e, 0x1357021d, 0x14660201, 0x156601e9, 0x165a01d3, 0x174401c0, 0x182401af, + 0x18fe0331, 0x1a9602fe, 0x1c1502d2, 0x1d7e02ad, 0x1ed4028d, 0x201a0270, 0x21520256, 0x227d0240, + 0x239f0443, 0x25c003fe, 0x27bf03c4, 0x29a10392, 0x2b6a0367, 0x2d1d0341, 0x2ebe031f, 0x304d0300, + 0x31d105b0, 0x34a80555, 0x37520507, 0x39d504c5, 0x3c37048b, 0x3e7c0458, 0x40a8042a, 0x42bd0401, + 0x44c20798, 0x488e071e, 0x4c1c06b6, 0x4f76065d, 0x52a50610, 0x55ac05cc, 0x5892058f, 0x5b590559, + 0x5e0c0a23, 0x631c0980, 0x67db08f6, 0x6c55087f, 0x70940818, 0x74a007bd, 0x787d076c, 0x7c330723, +}; + +static stbir__inline stbir_uint8 stbir__linear_to_srgb_uchar(float in) +{ + static const stbir__FP32 almostone = { 0x3f7fffff }; // 1-eps + static const stbir__FP32 minval = { (127-13) << 23 }; + stbir_uint32 tab,bias,scale,t; + stbir__FP32 f; + + // Clamp to [2^(-13), 1-eps]; these two values map to 0 and 1, respectively. + // The tests are carefully written so that NaNs map to 0, same as in the reference + // implementation. + if (!(in > minval.f)) // written this way to catch NaNs + return 0; + if (in > almostone.f) + return 255; + + // Do the table lookup and unpack bias, scale + f.f = in; + tab = fp32_to_srgb8_tab4[(f.u - minval.u) >> 20]; + bias = (tab >> 16) << 9; + scale = tab & 0xffff; + + // Grab next-highest mantissa bits and perform linear interpolation + t = (f.u >> 12) & 0xff; + return (unsigned char) ((bias + scale*t) >> 16); +} + +#ifndef STBIR_FORCE_GATHER_FILTER_SCANLINES_AMOUNT +#define STBIR_FORCE_GATHER_FILTER_SCANLINES_AMOUNT 32 // when downsampling and <= 32 scanlines of buffering, use gather. gather used down to 1/8th scaling for 25% win. +#endif + +#ifndef STBIR_FORCE_MINIMUM_SCANLINES_FOR_SPLITS +#define STBIR_FORCE_MINIMUM_SCANLINES_FOR_SPLITS 4 // when threading, what is the minimum number of scanlines for a split? +#endif + +#define STBIR_INPUT_CALLBACK_PADDING 3 + +#ifdef _M_IX86_FP +#if ( _M_IX86_FP >= 1 ) +#ifndef STBIR_SSE +#define STBIR_SSE +#endif +#endif +#endif + +#ifdef __TINYC__ + // tiny c has no intrinsics yet - this can become a version check if they add them + #define STBIR_NO_SIMD +#endif + +#if defined(_x86_64) || defined( __x86_64__ ) || defined( _M_X64 ) || defined(__x86_64) || defined(_M_AMD64) || defined(__SSE2__) || defined(STBIR_SSE) || defined(STBIR_SSE2) + #ifndef STBIR_SSE2 + #define STBIR_SSE2 + #endif + #if defined(__AVX__) || defined(STBIR_AVX2) + #ifndef STBIR_AVX + #ifndef STBIR_NO_AVX + #define STBIR_AVX + #endif + #endif + #endif + #if defined(__AVX2__) || defined(STBIR_AVX2) + #ifndef STBIR_NO_AVX2 + #ifndef STBIR_AVX2 + #define STBIR_AVX2 + #endif + #if defined( _MSC_VER ) && !defined(__clang__) + #ifndef STBIR_FP16C // FP16C instructions are on all AVX2 cpus, so we can autoselect it here on microsoft - clang needs -mf16c + #define STBIR_FP16C + #endif + #endif + #endif + #endif + #ifdef __F16C__ + #ifndef STBIR_FP16C // turn on FP16C instructions if the define is set (for clang and gcc) + #define STBIR_FP16C + #endif + #endif +#endif + +#if defined( _M_ARM64 ) || defined( __aarch64__ ) || defined( __arm64__ ) || ((__ARM_NEON_FP & 4) != 0) || defined(__ARM_NEON__) +#ifndef STBIR_NEON +#define STBIR_NEON +#endif +#endif + +#if defined(_M_ARM) || defined(__arm__) +#ifdef STBIR_USE_FMA +#undef STBIR_USE_FMA // no FMA for 32-bit arm on MSVC +#endif +#endif + +#if defined(__wasm__) && defined(__wasm_simd128__) +#ifndef STBIR_WASM +#define STBIR_WASM +#endif +#endif + +// restrict pointers for the output pointers, other loop and unroll control +#if defined( _MSC_VER ) && !defined(__clang__) + #define STBIR_STREAMOUT_PTR( star ) star __restrict + #define STBIR_NO_UNROLL( ptr ) __assume(ptr) // this oddly keeps msvc from unrolling a loop + #if _MSC_VER >= 1900 + #define STBIR_NO_UNROLL_LOOP_START __pragma(loop( no_vector )) + #else + #define STBIR_NO_UNROLL_LOOP_START + #endif +#elif defined( __clang__ ) + #define STBIR_STREAMOUT_PTR( star ) star __restrict__ + #define STBIR_NO_UNROLL( ptr ) __asm__ (""::"r"(ptr)) + #if ( __clang_major__ >= 4 ) || ( ( __clang_major__ >= 3 ) && ( __clang_minor__ >= 5 ) ) + #define STBIR_NO_UNROLL_LOOP_START _Pragma("clang loop unroll(disable)") _Pragma("clang loop vectorize(disable)") + #else + #define STBIR_NO_UNROLL_LOOP_START + #endif +#elif defined( __GNUC__ ) + #define STBIR_STREAMOUT_PTR( star ) star __restrict__ + #define STBIR_NO_UNROLL( ptr ) __asm__ (""::"r"(ptr)) + #if __GNUC__ >= 14 + #define STBIR_NO_UNROLL_LOOP_START _Pragma("GCC unroll 0") _Pragma("GCC novector") + #else + #define STBIR_NO_UNROLL_LOOP_START + #endif + #define STBIR_NO_UNROLL_LOOP_START_INF_FOR +#else + #define STBIR_STREAMOUT_PTR( star ) star + #define STBIR_NO_UNROLL( ptr ) + #define STBIR_NO_UNROLL_LOOP_START +#endif + +#ifndef STBIR_NO_UNROLL_LOOP_START_INF_FOR +#define STBIR_NO_UNROLL_LOOP_START_INF_FOR STBIR_NO_UNROLL_LOOP_START +#endif + +#ifdef STBIR_NO_SIMD // force simd off for whatever reason + +// force simd off overrides everything else, so clear it all + +#ifdef STBIR_SSE2 +#undef STBIR_SSE2 +#endif + +#ifdef STBIR_AVX +#undef STBIR_AVX +#endif + +#ifdef STBIR_NEON +#undef STBIR_NEON +#endif + +#ifdef STBIR_AVX2 +#undef STBIR_AVX2 +#endif + +#ifdef STBIR_FP16C +#undef STBIR_FP16C +#endif + +#ifdef STBIR_WASM +#undef STBIR_WASM +#endif + +#ifdef STBIR_SIMD +#undef STBIR_SIMD +#endif + +#else // STBIR_SIMD + +#ifdef STBIR_SSE2 + #include + + #define stbir__simdf __m128 + #define stbir__simdi __m128i + + #define stbir_simdi_castf( reg ) _mm_castps_si128(reg) + #define stbir_simdf_casti( reg ) _mm_castsi128_ps(reg) + + #define stbir__simdf_load( reg, ptr ) (reg) = _mm_loadu_ps( (float const*)(ptr) ) + #define stbir__simdi_load( reg, ptr ) (reg) = _mm_loadu_si128 ( (stbir__simdi const*)(ptr) ) + #define stbir__simdf_load1( out, ptr ) (out) = _mm_load_ss( (float const*)(ptr) ) // top values can be random (not denormal or nan for perf) + #define stbir__simdi_load1( out, ptr ) (out) = _mm_castps_si128( _mm_load_ss( (float const*)(ptr) )) + #define stbir__simdf_load1z( out, ptr ) (out) = _mm_load_ss( (float const*)(ptr) ) // top values must be zero + #define stbir__simdf_frep4( fvar ) _mm_set_ps1( fvar ) + #define stbir__simdf_load1frep4( out, fvar ) (out) = _mm_set_ps1( fvar ) + #define stbir__simdf_load2( out, ptr ) (out) = _mm_castsi128_ps( _mm_loadl_epi64( (__m128i*)(ptr)) ) // top values can be random (not denormal or nan for perf) + #define stbir__simdf_load2z( out, ptr ) (out) = _mm_castsi128_ps( _mm_loadl_epi64( (__m128i*)(ptr)) ) // top values must be zero + #define stbir__simdf_load2hmerge( out, reg, ptr ) (out) = _mm_castpd_ps(_mm_loadh_pd( _mm_castps_pd(reg), (double*)(ptr) )) + + #define stbir__simdf_zeroP() _mm_setzero_ps() + #define stbir__simdf_zero( reg ) (reg) = _mm_setzero_ps() + + #define stbir__simdf_store( ptr, reg ) _mm_storeu_ps( (float*)(ptr), reg ) + #define stbir__simdf_store1( ptr, reg ) _mm_store_ss( (float*)(ptr), reg ) + #define stbir__simdf_store2( ptr, reg ) _mm_storel_epi64( (__m128i*)(ptr), _mm_castps_si128(reg) ) + #define stbir__simdf_store2h( ptr, reg ) _mm_storeh_pd( (double*)(ptr), _mm_castps_pd(reg) ) + + #define stbir__simdi_store( ptr, reg ) _mm_storeu_si128( (__m128i*)(ptr), reg ) + #define stbir__simdi_store1( ptr, reg ) _mm_store_ss( (float*)(ptr), _mm_castsi128_ps(reg) ) + #define stbir__simdi_store2( ptr, reg ) _mm_storel_epi64( (__m128i*)(ptr), (reg) ) + + #define stbir__prefetch( ptr ) _mm_prefetch((char*)(ptr), _MM_HINT_T0 ) + + #define stbir__simdi_expand_u8_to_u32(out0,out1,out2,out3,ireg) \ + { \ + stbir__simdi zero = _mm_setzero_si128(); \ + out2 = _mm_unpacklo_epi8( ireg, zero ); \ + out3 = _mm_unpackhi_epi8( ireg, zero ); \ + out0 = _mm_unpacklo_epi16( out2, zero ); \ + out1 = _mm_unpackhi_epi16( out2, zero ); \ + out2 = _mm_unpacklo_epi16( out3, zero ); \ + out3 = _mm_unpackhi_epi16( out3, zero ); \ + } + +#define stbir__simdi_expand_u8_to_1u32(out,ireg) \ + { \ + stbir__simdi zero = _mm_setzero_si128(); \ + out = _mm_unpacklo_epi8( ireg, zero ); \ + out = _mm_unpacklo_epi16( out, zero ); \ + } + + #define stbir__simdi_expand_u16_to_u32(out0,out1,ireg) \ + { \ + stbir__simdi zero = _mm_setzero_si128(); \ + out0 = _mm_unpacklo_epi16( ireg, zero ); \ + out1 = _mm_unpackhi_epi16( ireg, zero ); \ + } + + #define stbir__simdf_convert_float_to_i32( i, f ) (i) = _mm_cvttps_epi32(f) + #define stbir__simdf_convert_float_to_int( f ) _mm_cvtt_ss2si(f) + #define stbir__simdf_convert_float_to_uint8( f ) ((unsigned char)_mm_cvtsi128_si32(_mm_cvttps_epi32(_mm_max_ps(_mm_min_ps(f,STBIR__CONSTF(STBIR_max_uint8_as_float)),_mm_setzero_ps())))) + #define stbir__simdf_convert_float_to_short( f ) ((unsigned short)_mm_cvtsi128_si32(_mm_cvttps_epi32(_mm_max_ps(_mm_min_ps(f,STBIR__CONSTF(STBIR_max_uint16_as_float)),_mm_setzero_ps())))) + + #define stbir__simdi_to_int( i ) _mm_cvtsi128_si32(i) + #define stbir__simdi_convert_i32_to_float(out, ireg) (out) = _mm_cvtepi32_ps( ireg ) + #define stbir__simdf_add( out, reg0, reg1 ) (out) = _mm_add_ps( reg0, reg1 ) + #define stbir__simdf_mult( out, reg0, reg1 ) (out) = _mm_mul_ps( reg0, reg1 ) + #define stbir__simdf_mult_mem( out, reg, ptr ) (out) = _mm_mul_ps( reg, _mm_loadu_ps( (float const*)(ptr) ) ) + #define stbir__simdf_mult1_mem( out, reg, ptr ) (out) = _mm_mul_ss( reg, _mm_load_ss( (float const*)(ptr) ) ) + #define stbir__simdf_add_mem( out, reg, ptr ) (out) = _mm_add_ps( reg, _mm_loadu_ps( (float const*)(ptr) ) ) + #define stbir__simdf_add1_mem( out, reg, ptr ) (out) = _mm_add_ss( reg, _mm_load_ss( (float const*)(ptr) ) ) + + #ifdef STBIR_USE_FMA // not on by default to maintain bit identical simd to non-simd + #include + #define stbir__simdf_madd( out, add, mul1, mul2 ) (out) = _mm_fmadd_ps( mul1, mul2, add ) + #define stbir__simdf_madd1( out, add, mul1, mul2 ) (out) = _mm_fmadd_ss( mul1, mul2, add ) + #define stbir__simdf_madd_mem( out, add, mul, ptr ) (out) = _mm_fmadd_ps( mul, _mm_loadu_ps( (float const*)(ptr) ), add ) + #define stbir__simdf_madd1_mem( out, add, mul, ptr ) (out) = _mm_fmadd_ss( mul, _mm_load_ss( (float const*)(ptr) ), add ) + #else + #define stbir__simdf_madd( out, add, mul1, mul2 ) (out) = _mm_add_ps( add, _mm_mul_ps( mul1, mul2 ) ) + #define stbir__simdf_madd1( out, add, mul1, mul2 ) (out) = _mm_add_ss( add, _mm_mul_ss( mul1, mul2 ) ) + #define stbir__simdf_madd_mem( out, add, mul, ptr ) (out) = _mm_add_ps( add, _mm_mul_ps( mul, _mm_loadu_ps( (float const*)(ptr) ) ) ) + #define stbir__simdf_madd1_mem( out, add, mul, ptr ) (out) = _mm_add_ss( add, _mm_mul_ss( mul, _mm_load_ss( (float const*)(ptr) ) ) ) + #endif + + #define stbir__simdf_add1( out, reg0, reg1 ) (out) = _mm_add_ss( reg0, reg1 ) + #define stbir__simdf_mult1( out, reg0, reg1 ) (out) = _mm_mul_ss( reg0, reg1 ) + + #define stbir__simdf_and( out, reg0, reg1 ) (out) = _mm_and_ps( reg0, reg1 ) + #define stbir__simdf_or( out, reg0, reg1 ) (out) = _mm_or_ps( reg0, reg1 ) + + #define stbir__simdf_min( out, reg0, reg1 ) (out) = _mm_min_ps( reg0, reg1 ) + #define stbir__simdf_max( out, reg0, reg1 ) (out) = _mm_max_ps( reg0, reg1 ) + #define stbir__simdf_min1( out, reg0, reg1 ) (out) = _mm_min_ss( reg0, reg1 ) + #define stbir__simdf_max1( out, reg0, reg1 ) (out) = _mm_max_ss( reg0, reg1 ) + + #define stbir__simdf_0123ABCDto3ABx( out, reg0, reg1 ) (out)=_mm_castsi128_ps( _mm_shuffle_epi32( _mm_castps_si128( _mm_shuffle_ps( reg1,reg0, (0<<0) + (1<<2) + (2<<4) + (3<<6) )), (3<<0) + (0<<2) + (1<<4) + (2<<6) ) ) + #define stbir__simdf_0123ABCDto23Ax( out, reg0, reg1 ) (out)=_mm_castsi128_ps( _mm_shuffle_epi32( _mm_castps_si128( _mm_shuffle_ps( reg1,reg0, (0<<0) + (1<<2) + (2<<4) + (3<<6) )), (2<<0) + (3<<2) + (0<<4) + (1<<6) ) ) + + static const stbir__simdf STBIR_zeroones = { 0.0f,1.0f,0.0f,1.0f }; + static const stbir__simdf STBIR_onezeros = { 1.0f,0.0f,1.0f,0.0f }; + #define stbir__simdf_aaa1( out, alp, ones ) (out)=_mm_castsi128_ps( _mm_shuffle_epi32( _mm_castps_si128( _mm_movehl_ps( ones, alp ) ), (1<<0) + (1<<2) + (1<<4) + (2<<6) ) ) + #define stbir__simdf_1aaa( out, alp, ones ) (out)=_mm_castsi128_ps( _mm_shuffle_epi32( _mm_castps_si128( _mm_movelh_ps( ones, alp ) ), (0<<0) + (2<<2) + (2<<4) + (2<<6) ) ) + #define stbir__simdf_a1a1( out, alp, ones) (out) = _mm_or_ps( _mm_castsi128_ps( _mm_srli_epi64( _mm_castps_si128(alp), 32 ) ), STBIR_zeroones ) + #define stbir__simdf_1a1a( out, alp, ones) (out) = _mm_or_ps( _mm_castsi128_ps( _mm_slli_epi64( _mm_castps_si128(alp), 32 ) ), STBIR_onezeros ) + + #define stbir__simdf_swiz( reg, one, two, three, four ) _mm_castsi128_ps( _mm_shuffle_epi32( _mm_castps_si128( reg ), (one<<0) + (two<<2) + (three<<4) + (four<<6) ) ) + + #define stbir__simdi_and( out, reg0, reg1 ) (out) = _mm_and_si128( reg0, reg1 ) + #define stbir__simdi_or( out, reg0, reg1 ) (out) = _mm_or_si128( reg0, reg1 ) + #define stbir__simdi_16madd( out, reg0, reg1 ) (out) = _mm_madd_epi16( reg0, reg1 ) + + #define stbir__simdf_pack_to_8bytes(out,aa,bb) \ + { \ + stbir__simdf af,bf; \ + stbir__simdi a,b; \ + af = _mm_min_ps( aa, STBIR_max_uint8_as_float ); \ + bf = _mm_min_ps( bb, STBIR_max_uint8_as_float ); \ + af = _mm_max_ps( af, _mm_setzero_ps() ); \ + bf = _mm_max_ps( bf, _mm_setzero_ps() ); \ + a = _mm_cvttps_epi32( af ); \ + b = _mm_cvttps_epi32( bf ); \ + a = _mm_packs_epi32( a, b ); \ + out = _mm_packus_epi16( a, a ); \ + } + + #define stbir__simdf_load4_transposed( o0, o1, o2, o3, ptr ) \ + stbir__simdf_load( o0, (ptr) ); \ + stbir__simdf_load( o1, (ptr)+4 ); \ + stbir__simdf_load( o2, (ptr)+8 ); \ + stbir__simdf_load( o3, (ptr)+12 ); \ + { \ + __m128 tmp0, tmp1, tmp2, tmp3; \ + tmp0 = _mm_unpacklo_ps(o0, o1); \ + tmp2 = _mm_unpacklo_ps(o2, o3); \ + tmp1 = _mm_unpackhi_ps(o0, o1); \ + tmp3 = _mm_unpackhi_ps(o2, o3); \ + o0 = _mm_movelh_ps(tmp0, tmp2); \ + o1 = _mm_movehl_ps(tmp2, tmp0); \ + o2 = _mm_movelh_ps(tmp1, tmp3); \ + o3 = _mm_movehl_ps(tmp3, tmp1); \ + } + + #define stbir__interleave_pack_and_store_16_u8( ptr, r0, r1, r2, r3 ) \ + r0 = _mm_packs_epi32( r0, r1 ); \ + r2 = _mm_packs_epi32( r2, r3 ); \ + r1 = _mm_unpacklo_epi16( r0, r2 ); \ + r3 = _mm_unpackhi_epi16( r0, r2 ); \ + r0 = _mm_unpacklo_epi16( r1, r3 ); \ + r2 = _mm_unpackhi_epi16( r1, r3 ); \ + r0 = _mm_packus_epi16( r0, r2 ); \ + stbir__simdi_store( ptr, r0 ); \ + + #define stbir__simdi_32shr( out, reg, imm ) out = _mm_srli_epi32( reg, imm ) + + #if defined(_MSC_VER) && !defined(__clang__) + // msvc inits with 8 bytes + #define STBIR__CONST_32_TO_8( v ) (char)(unsigned char)((v)&255),(char)(unsigned char)(((v)>>8)&255),(char)(unsigned char)(((v)>>16)&255),(char)(unsigned char)(((v)>>24)&255) + #define STBIR__CONST_4_32i( v ) STBIR__CONST_32_TO_8( v ), STBIR__CONST_32_TO_8( v ), STBIR__CONST_32_TO_8( v ), STBIR__CONST_32_TO_8( v ) + #define STBIR__CONST_4d_32i( v0, v1, v2, v3 ) STBIR__CONST_32_TO_8( v0 ), STBIR__CONST_32_TO_8( v1 ), STBIR__CONST_32_TO_8( v2 ), STBIR__CONST_32_TO_8( v3 ) + #else + // everything else inits with long long's + #define STBIR__CONST_4_32i( v ) (long long)((((stbir_uint64)(stbir_uint32)(v))<<32)|((stbir_uint64)(stbir_uint32)(v))),(long long)((((stbir_uint64)(stbir_uint32)(v))<<32)|((stbir_uint64)(stbir_uint32)(v))) + #define STBIR__CONST_4d_32i( v0, v1, v2, v3 ) (long long)((((stbir_uint64)(stbir_uint32)(v1))<<32)|((stbir_uint64)(stbir_uint32)(v0))),(long long)((((stbir_uint64)(stbir_uint32)(v3))<<32)|((stbir_uint64)(stbir_uint32)(v2))) + #endif + + #define STBIR__SIMDF_CONST(var, x) stbir__simdf var = { x, x, x, x } + #define STBIR__SIMDI_CONST(var, x) stbir__simdi var = { STBIR__CONST_4_32i(x) } + #define STBIR__CONSTF(var) (var) + #define STBIR__CONSTI(var) (var) + + #if defined(STBIR_AVX) || defined(__SSE4_1__) + #include + #define stbir__simdf_pack_to_8words(out,reg0,reg1) out = _mm_packus_epi32(_mm_cvttps_epi32(_mm_max_ps(_mm_min_ps(reg0,STBIR__CONSTF(STBIR_max_uint16_as_float)),_mm_setzero_ps())), _mm_cvttps_epi32(_mm_max_ps(_mm_min_ps(reg1,STBIR__CONSTF(STBIR_max_uint16_as_float)),_mm_setzero_ps()))) + #else + static STBIR__SIMDI_CONST(stbir__s32_32768, 32768); + static STBIR__SIMDI_CONST(stbir__s16_32768, ((32768<<16)|32768)); + + #define stbir__simdf_pack_to_8words(out,reg0,reg1) \ + { \ + stbir__simdi tmp0,tmp1; \ + tmp0 = _mm_cvttps_epi32(_mm_max_ps(_mm_min_ps(reg0,STBIR__CONSTF(STBIR_max_uint16_as_float)),_mm_setzero_ps())); \ + tmp1 = _mm_cvttps_epi32(_mm_max_ps(_mm_min_ps(reg1,STBIR__CONSTF(STBIR_max_uint16_as_float)),_mm_setzero_ps())); \ + tmp0 = _mm_sub_epi32( tmp0, stbir__s32_32768 ); \ + tmp1 = _mm_sub_epi32( tmp1, stbir__s32_32768 ); \ + out = _mm_packs_epi32( tmp0, tmp1 ); \ + out = _mm_sub_epi16( out, stbir__s16_32768 ); \ + } + + #endif + + #define STBIR_SIMD + + // if we detect AVX, set the simd8 defines + #ifdef STBIR_AVX + #include + #define STBIR_SIMD8 + #define stbir__simdf8 __m256 + #define stbir__simdi8 __m256i + #define stbir__simdf8_load( out, ptr ) (out) = _mm256_loadu_ps( (float const *)(ptr) ) + #define stbir__simdi8_load( out, ptr ) (out) = _mm256_loadu_si256( (__m256i const *)(ptr) ) + #define stbir__simdf8_mult( out, a, b ) (out) = _mm256_mul_ps( (a), (b) ) + #define stbir__simdf8_store( ptr, out ) _mm256_storeu_ps( (float*)(ptr), out ) + #define stbir__simdi8_store( ptr, reg ) _mm256_storeu_si256( (__m256i*)(ptr), reg ) + #define stbir__simdf8_frep8( fval ) _mm256_set1_ps( fval ) + + #define stbir__simdf8_min( out, reg0, reg1 ) (out) = _mm256_min_ps( reg0, reg1 ) + #define stbir__simdf8_max( out, reg0, reg1 ) (out) = _mm256_max_ps( reg0, reg1 ) + + #define stbir__simdf8_add4halves( out, bot4, top8 ) (out) = _mm_add_ps( bot4, _mm256_extractf128_ps( top8, 1 ) ) + #define stbir__simdf8_mult_mem( out, reg, ptr ) (out) = _mm256_mul_ps( reg, _mm256_loadu_ps( (float const*)(ptr) ) ) + #define stbir__simdf8_add_mem( out, reg, ptr ) (out) = _mm256_add_ps( reg, _mm256_loadu_ps( (float const*)(ptr) ) ) + #define stbir__simdf8_add( out, a, b ) (out) = _mm256_add_ps( a, b ) + #define stbir__simdf8_load1b( out, ptr ) (out) = _mm256_broadcast_ss( ptr ) + #define stbir__simdf_load1rep4( out, ptr ) (out) = _mm_broadcast_ss( ptr ) // avx load instruction + + #define stbir__simdi8_convert_i32_to_float(out, ireg) (out) = _mm256_cvtepi32_ps( ireg ) + #define stbir__simdf8_convert_float_to_i32( i, f ) (i) = _mm256_cvttps_epi32(f) + + #define stbir__simdf8_bot4s( out, a, b ) (out) = _mm256_permute2f128_ps(a,b, (0<<0)+(2<<4) ) + #define stbir__simdf8_top4s( out, a, b ) (out) = _mm256_permute2f128_ps(a,b, (1<<0)+(3<<4) ) + + #define stbir__simdf8_gettop4( reg ) _mm256_extractf128_ps(reg,1) + + #ifdef STBIR_AVX2 + + #define stbir__simdi8_expand_u8_to_u32(out0,out1,ireg) \ + { \ + stbir__simdi8 a, zero =_mm256_setzero_si256();\ + a = _mm256_permute4x64_epi64( _mm256_unpacklo_epi8( _mm256_permute4x64_epi64(_mm256_castsi128_si256(ireg),(0<<0)+(2<<2)+(1<<4)+(3<<6)), zero ),(0<<0)+(2<<2)+(1<<4)+(3<<6)); \ + out0 = _mm256_unpacklo_epi16( a, zero ); \ + out1 = _mm256_unpackhi_epi16( a, zero ); \ + } + + #define stbir__simdf8_pack_to_16bytes(out,aa,bb) \ + { \ + stbir__simdi8 t; \ + stbir__simdf8 af,bf; \ + stbir__simdi8 a,b; \ + af = _mm256_min_ps( aa, STBIR_max_uint8_as_floatX ); \ + bf = _mm256_min_ps( bb, STBIR_max_uint8_as_floatX ); \ + af = _mm256_max_ps( af, _mm256_setzero_ps() ); \ + bf = _mm256_max_ps( bf, _mm256_setzero_ps() ); \ + a = _mm256_cvttps_epi32( af ); \ + b = _mm256_cvttps_epi32( bf ); \ + t = _mm256_permute4x64_epi64( _mm256_packs_epi32( a, b ), (0<<0)+(2<<2)+(1<<4)+(3<<6) ); \ + out = _mm256_castsi256_si128( _mm256_permute4x64_epi64( _mm256_packus_epi16( t, t ), (0<<0)+(2<<2)+(1<<4)+(3<<6) ) ); \ + } + + #define stbir__simdi8_expand_u16_to_u32(out,ireg) out = _mm256_unpacklo_epi16( _mm256_permute4x64_epi64(_mm256_castsi128_si256(ireg),(0<<0)+(2<<2)+(1<<4)+(3<<6)), _mm256_setzero_si256() ); + + #define stbir__simdf8_pack_to_16words(out,aa,bb) \ + { \ + stbir__simdf8 af,bf; \ + stbir__simdi8 a,b; \ + af = _mm256_min_ps( aa, STBIR_max_uint16_as_floatX ); \ + bf = _mm256_min_ps( bb, STBIR_max_uint16_as_floatX ); \ + af = _mm256_max_ps( af, _mm256_setzero_ps() ); \ + bf = _mm256_max_ps( bf, _mm256_setzero_ps() ); \ + a = _mm256_cvttps_epi32( af ); \ + b = _mm256_cvttps_epi32( bf ); \ + (out) = _mm256_permute4x64_epi64( _mm256_packus_epi32(a, b), (0<<0)+(2<<2)+(1<<4)+(3<<6) ); \ + } + + #else + + #define stbir__simdi8_expand_u8_to_u32(out0,out1,ireg) \ + { \ + stbir__simdi a,zero = _mm_setzero_si128(); \ + a = _mm_unpacklo_epi8( ireg, zero ); \ + out0 = _mm256_setr_m128i( _mm_unpacklo_epi16( a, zero ), _mm_unpackhi_epi16( a, zero ) ); \ + a = _mm_unpackhi_epi8( ireg, zero ); \ + out1 = _mm256_setr_m128i( _mm_unpacklo_epi16( a, zero ), _mm_unpackhi_epi16( a, zero ) ); \ + } + + #define stbir__simdf8_pack_to_16bytes(out,aa,bb) \ + { \ + stbir__simdi t; \ + stbir__simdf8 af,bf; \ + stbir__simdi8 a,b; \ + af = _mm256_min_ps( aa, STBIR_max_uint8_as_floatX ); \ + bf = _mm256_min_ps( bb, STBIR_max_uint8_as_floatX ); \ + af = _mm256_max_ps( af, _mm256_setzero_ps() ); \ + bf = _mm256_max_ps( bf, _mm256_setzero_ps() ); \ + a = _mm256_cvttps_epi32( af ); \ + b = _mm256_cvttps_epi32( bf ); \ + out = _mm_packs_epi32( _mm256_castsi256_si128(a), _mm256_extractf128_si256( a, 1 ) ); \ + out = _mm_packus_epi16( out, out ); \ + t = _mm_packs_epi32( _mm256_castsi256_si128(b), _mm256_extractf128_si256( b, 1 ) ); \ + t = _mm_packus_epi16( t, t ); \ + out = _mm_castps_si128( _mm_shuffle_ps( _mm_castsi128_ps(out), _mm_castsi128_ps(t), (0<<0)+(1<<2)+(0<<4)+(1<<6) ) ); \ + } + + #define stbir__simdi8_expand_u16_to_u32(out,ireg) \ + { \ + stbir__simdi a,b,zero = _mm_setzero_si128(); \ + a = _mm_unpacklo_epi16( ireg, zero ); \ + b = _mm_unpackhi_epi16( ireg, zero ); \ + out = _mm256_insertf128_si256( _mm256_castsi128_si256( a ), b, 1 ); \ + } + + #define stbir__simdf8_pack_to_16words(out,aa,bb) \ + { \ + stbir__simdi t0,t1; \ + stbir__simdf8 af,bf; \ + stbir__simdi8 a,b; \ + af = _mm256_min_ps( aa, STBIR_max_uint16_as_floatX ); \ + bf = _mm256_min_ps( bb, STBIR_max_uint16_as_floatX ); \ + af = _mm256_max_ps( af, _mm256_setzero_ps() ); \ + bf = _mm256_max_ps( bf, _mm256_setzero_ps() ); \ + a = _mm256_cvttps_epi32( af ); \ + b = _mm256_cvttps_epi32( bf ); \ + t0 = _mm_packus_epi32( _mm256_castsi256_si128(a), _mm256_extractf128_si256( a, 1 ) ); \ + t1 = _mm_packus_epi32( _mm256_castsi256_si128(b), _mm256_extractf128_si256( b, 1 ) ); \ + out = _mm256_setr_m128i( t0, t1 ); \ + } + + #endif + + static __m256i stbir_00001111 = { STBIR__CONST_4d_32i( 0, 0, 0, 0 ), STBIR__CONST_4d_32i( 1, 1, 1, 1 ) }; + #define stbir__simdf8_0123to00001111( out, in ) (out) = _mm256_permutevar_ps ( in, stbir_00001111 ) + + static __m256i stbir_22223333 = { STBIR__CONST_4d_32i( 2, 2, 2, 2 ), STBIR__CONST_4d_32i( 3, 3, 3, 3 ) }; + #define stbir__simdf8_0123to22223333( out, in ) (out) = _mm256_permutevar_ps ( in, stbir_22223333 ) + + #define stbir__simdf8_0123to2222( out, in ) (out) = stbir__simdf_swiz(_mm256_castps256_ps128(in), 2,2,2,2 ) + + #define stbir__simdf8_load4b( out, ptr ) (out) = _mm256_broadcast_ps( (__m128 const *)(ptr) ) + + static __m256i stbir_00112233 = { STBIR__CONST_4d_32i( 0, 0, 1, 1 ), STBIR__CONST_4d_32i( 2, 2, 3, 3 ) }; + #define stbir__simdf8_0123to00112233( out, in ) (out) = _mm256_permutevar_ps ( in, stbir_00112233 ) + #define stbir__simdf8_add4( out, a8, b ) (out) = _mm256_add_ps( a8, _mm256_castps128_ps256( b ) ) + + static __m256i stbir_load6 = { STBIR__CONST_4_32i( 0x80000000 ), STBIR__CONST_4d_32i( 0x80000000, 0x80000000, 0, 0 ) }; + #define stbir__simdf8_load6z( out, ptr ) (out) = _mm256_maskload_ps( ptr, stbir_load6 ) + + #define stbir__simdf8_0123to00000000( out, in ) (out) = _mm256_shuffle_ps ( in, in, (0<<0)+(0<<2)+(0<<4)+(0<<6) ) + #define stbir__simdf8_0123to11111111( out, in ) (out) = _mm256_shuffle_ps ( in, in, (1<<0)+(1<<2)+(1<<4)+(1<<6) ) + #define stbir__simdf8_0123to22222222( out, in ) (out) = _mm256_shuffle_ps ( in, in, (2<<0)+(2<<2)+(2<<4)+(2<<6) ) + #define stbir__simdf8_0123to33333333( out, in ) (out) = _mm256_shuffle_ps ( in, in, (3<<0)+(3<<2)+(3<<4)+(3<<6) ) + #define stbir__simdf8_0123to21032103( out, in ) (out) = _mm256_shuffle_ps ( in, in, (2<<0)+(1<<2)+(0<<4)+(3<<6) ) + #define stbir__simdf8_0123to32103210( out, in ) (out) = _mm256_shuffle_ps ( in, in, (3<<0)+(2<<2)+(1<<4)+(0<<6) ) + #define stbir__simdf8_0123to12301230( out, in ) (out) = _mm256_shuffle_ps ( in, in, (1<<0)+(2<<2)+(3<<4)+(0<<6) ) + #define stbir__simdf8_0123to10321032( out, in ) (out) = _mm256_shuffle_ps ( in, in, (1<<0)+(0<<2)+(3<<4)+(2<<6) ) + #define stbir__simdf8_0123to30123012( out, in ) (out) = _mm256_shuffle_ps ( in, in, (3<<0)+(0<<2)+(1<<4)+(2<<6) ) + + #define stbir__simdf8_0123to11331133( out, in ) (out) = _mm256_shuffle_ps ( in, in, (1<<0)+(1<<2)+(3<<4)+(3<<6) ) + #define stbir__simdf8_0123to00220022( out, in ) (out) = _mm256_shuffle_ps ( in, in, (0<<0)+(0<<2)+(2<<4)+(2<<6) ) + + #define stbir__simdf8_aaa1( out, alp, ones ) (out) = _mm256_blend_ps( alp, ones, (1<<0)+(1<<1)+(1<<2)+(0<<3)+(1<<4)+(1<<5)+(1<<6)+(0<<7)); (out)=_mm256_shuffle_ps( out,out, (3<<0) + (3<<2) + (3<<4) + (0<<6) ) + #define stbir__simdf8_1aaa( out, alp, ones ) (out) = _mm256_blend_ps( alp, ones, (0<<0)+(1<<1)+(1<<2)+(1<<3)+(0<<4)+(1<<5)+(1<<6)+(1<<7)); (out)=_mm256_shuffle_ps( out,out, (1<<0) + (0<<2) + (0<<4) + (0<<6) ) + #define stbir__simdf8_a1a1( out, alp, ones) (out) = _mm256_blend_ps( alp, ones, (1<<0)+(0<<1)+(1<<2)+(0<<3)+(1<<4)+(0<<5)+(1<<6)+(0<<7)); (out)=_mm256_shuffle_ps( out,out, (1<<0) + (0<<2) + (3<<4) + (2<<6) ) + #define stbir__simdf8_1a1a( out, alp, ones) (out) = _mm256_blend_ps( alp, ones, (0<<0)+(1<<1)+(0<<2)+(1<<3)+(0<<4)+(1<<5)+(0<<6)+(1<<7)); (out)=_mm256_shuffle_ps( out,out, (1<<0) + (0<<2) + (3<<4) + (2<<6) ) + + #define stbir__simdf8_zero( reg ) (reg) = _mm256_setzero_ps() + + #ifdef STBIR_USE_FMA // not on by default to maintain bit identical simd to non-simd + #define stbir__simdf8_madd( out, add, mul1, mul2 ) (out) = _mm256_fmadd_ps( mul1, mul2, add ) + #define stbir__simdf8_madd_mem( out, add, mul, ptr ) (out) = _mm256_fmadd_ps( mul, _mm256_loadu_ps( (float const*)(ptr) ), add ) + #define stbir__simdf8_madd_mem4( out, add, mul, ptr )(out) = _mm256_fmadd_ps( _mm256_setr_m128( mul, _mm_setzero_ps() ), _mm256_setr_m128( _mm_loadu_ps( (float const*)(ptr) ), _mm_setzero_ps() ), add ) + #else + #define stbir__simdf8_madd( out, add, mul1, mul2 ) (out) = _mm256_add_ps( add, _mm256_mul_ps( mul1, mul2 ) ) + #define stbir__simdf8_madd_mem( out, add, mul, ptr ) (out) = _mm256_add_ps( add, _mm256_mul_ps( mul, _mm256_loadu_ps( (float const*)(ptr) ) ) ) + #define stbir__simdf8_madd_mem4( out, add, mul, ptr ) (out) = _mm256_add_ps( add, _mm256_setr_m128( _mm_mul_ps( mul, _mm_loadu_ps( (float const*)(ptr) ) ), _mm_setzero_ps() ) ) + #endif + #define stbir__if_simdf8_cast_to_simdf4( val ) _mm256_castps256_ps128( val ) + + #endif + + #ifdef STBIR_FLOORF + #undef STBIR_FLOORF + #endif + #define STBIR_FLOORF stbir_simd_floorf + static stbir__inline float stbir_simd_floorf(float x) // martins floorf + { + #if defined(STBIR_AVX) || defined(__SSE4_1__) || defined(STBIR_SSE41) + __m128 t = _mm_set_ss(x); + return _mm_cvtss_f32( _mm_floor_ss(t, t) ); + #else + __m128 f = _mm_set_ss(x); + __m128 t = _mm_cvtepi32_ps(_mm_cvttps_epi32(f)); + __m128 r = _mm_add_ss(t, _mm_and_ps(_mm_cmplt_ss(f, t), _mm_set_ss(-1.0f))); + return _mm_cvtss_f32(r); + #endif + } + + #ifdef STBIR_CEILF + #undef STBIR_CEILF + #endif + #define STBIR_CEILF stbir_simd_ceilf + static stbir__inline float stbir_simd_ceilf(float x) // martins ceilf + { + #if defined(STBIR_AVX) || defined(__SSE4_1__) || defined(STBIR_SSE41) + __m128 t = _mm_set_ss(x); + return _mm_cvtss_f32( _mm_ceil_ss(t, t) ); + #else + __m128 f = _mm_set_ss(x); + __m128 t = _mm_cvtepi32_ps(_mm_cvttps_epi32(f)); + __m128 r = _mm_add_ss(t, _mm_and_ps(_mm_cmplt_ss(t, f), _mm_set_ss(1.0f))); + return _mm_cvtss_f32(r); + #endif + } + +#elif defined(STBIR_NEON) + + #include + + #define stbir__simdf float32x4_t + #define stbir__simdi uint32x4_t + + #define stbir_simdi_castf( reg ) vreinterpretq_u32_f32(reg) + #define stbir_simdf_casti( reg ) vreinterpretq_f32_u32(reg) + + #define stbir__simdf_load( reg, ptr ) (reg) = vld1q_f32( (float const*)(ptr) ) + #define stbir__simdi_load( reg, ptr ) (reg) = vld1q_u32( (uint32_t const*)(ptr) ) + #define stbir__simdf_load1( out, ptr ) (out) = vld1q_dup_f32( (float const*)(ptr) ) // top values can be random (not denormal or nan for perf) + #define stbir__simdi_load1( out, ptr ) (out) = vld1q_dup_u32( (uint32_t const*)(ptr) ) + #define stbir__simdf_load1z( out, ptr ) (out) = vld1q_lane_f32( (float const*)(ptr), vdupq_n_f32(0), 0 ) // top values must be zero + #define stbir__simdf_frep4( fvar ) vdupq_n_f32( fvar ) + #define stbir__simdf_load1frep4( out, fvar ) (out) = vdupq_n_f32( fvar ) + #define stbir__simdf_load2( out, ptr ) (out) = vcombine_f32( vld1_f32( (float const*)(ptr) ), vcreate_f32(0) ) // top values can be random (not denormal or nan for perf) + #define stbir__simdf_load2z( out, ptr ) (out) = vcombine_f32( vld1_f32( (float const*)(ptr) ), vcreate_f32(0) ) // top values must be zero + #define stbir__simdf_load2hmerge( out, reg, ptr ) (out) = vcombine_f32( vget_low_f32(reg), vld1_f32( (float const*)(ptr) ) ) + + #define stbir__simdf_zeroP() vdupq_n_f32(0) + #define stbir__simdf_zero( reg ) (reg) = vdupq_n_f32(0) + + #define stbir__simdf_store( ptr, reg ) vst1q_f32( (float*)(ptr), reg ) + #define stbir__simdf_store1( ptr, reg ) vst1q_lane_f32( (float*)(ptr), reg, 0) + #define stbir__simdf_store2( ptr, reg ) vst1_f32( (float*)(ptr), vget_low_f32(reg) ) + #define stbir__simdf_store2h( ptr, reg ) vst1_f32( (float*)(ptr), vget_high_f32(reg) ) + + #define stbir__simdi_store( ptr, reg ) vst1q_u32( (uint32_t*)(ptr), reg ) + #define stbir__simdi_store1( ptr, reg ) vst1q_lane_u32( (uint32_t*)(ptr), reg, 0 ) + #define stbir__simdi_store2( ptr, reg ) vst1_u32( (uint32_t*)(ptr), vget_low_u32(reg) ) + + #define stbir__prefetch( ptr ) + + #define stbir__simdi_expand_u8_to_u32(out0,out1,out2,out3,ireg) \ + { \ + uint16x8_t l = vmovl_u8( vget_low_u8 ( vreinterpretq_u8_u32(ireg) ) ); \ + uint16x8_t h = vmovl_u8( vget_high_u8( vreinterpretq_u8_u32(ireg) ) ); \ + out0 = vmovl_u16( vget_low_u16 ( l ) ); \ + out1 = vmovl_u16( vget_high_u16( l ) ); \ + out2 = vmovl_u16( vget_low_u16 ( h ) ); \ + out3 = vmovl_u16( vget_high_u16( h ) ); \ + } + + #define stbir__simdi_expand_u8_to_1u32(out,ireg) \ + { \ + uint16x8_t tmp = vmovl_u8( vget_low_u8( vreinterpretq_u8_u32(ireg) ) ); \ + out = vmovl_u16( vget_low_u16( tmp ) ); \ + } + + #define stbir__simdi_expand_u16_to_u32(out0,out1,ireg) \ + { \ + uint16x8_t tmp = vreinterpretq_u16_u32(ireg); \ + out0 = vmovl_u16( vget_low_u16 ( tmp ) ); \ + out1 = vmovl_u16( vget_high_u16( tmp ) ); \ + } + + #define stbir__simdf_convert_float_to_i32( i, f ) (i) = vreinterpretq_u32_s32( vcvtq_s32_f32(f) ) + #define stbir__simdf_convert_float_to_int( f ) vgetq_lane_s32(vcvtq_s32_f32(f), 0) + #define stbir__simdi_to_int( i ) (int)vgetq_lane_u32(i, 0) + #define stbir__simdf_convert_float_to_uint8( f ) ((unsigned char)vgetq_lane_s32(vcvtq_s32_f32(vmaxq_f32(vminq_f32(f,STBIR__CONSTF(STBIR_max_uint8_as_float)),vdupq_n_f32(0))), 0)) + #define stbir__simdf_convert_float_to_short( f ) ((unsigned short)vgetq_lane_s32(vcvtq_s32_f32(vmaxq_f32(vminq_f32(f,STBIR__CONSTF(STBIR_max_uint16_as_float)),vdupq_n_f32(0))), 0)) + #define stbir__simdi_convert_i32_to_float(out, ireg) (out) = vcvtq_f32_s32( vreinterpretq_s32_u32(ireg) ) + #define stbir__simdf_add( out, reg0, reg1 ) (out) = vaddq_f32( reg0, reg1 ) + #define stbir__simdf_mult( out, reg0, reg1 ) (out) = vmulq_f32( reg0, reg1 ) + #define stbir__simdf_mult_mem( out, reg, ptr ) (out) = vmulq_f32( reg, vld1q_f32( (float const*)(ptr) ) ) + #define stbir__simdf_mult1_mem( out, reg, ptr ) (out) = vmulq_f32( reg, vld1q_dup_f32( (float const*)(ptr) ) ) + #define stbir__simdf_add_mem( out, reg, ptr ) (out) = vaddq_f32( reg, vld1q_f32( (float const*)(ptr) ) ) + #define stbir__simdf_add1_mem( out, reg, ptr ) (out) = vaddq_f32( reg, vld1q_dup_f32( (float const*)(ptr) ) ) + + #ifdef STBIR_USE_FMA // not on by default to maintain bit identical simd to non-simd (and also x64 no madd to arm madd) + #define stbir__simdf_madd( out, add, mul1, mul2 ) (out) = vfmaq_f32( add, mul1, mul2 ) + #define stbir__simdf_madd1( out, add, mul1, mul2 ) (out) = vfmaq_f32( add, mul1, mul2 ) + #define stbir__simdf_madd_mem( out, add, mul, ptr ) (out) = vfmaq_f32( add, mul, vld1q_f32( (float const*)(ptr) ) ) + #define stbir__simdf_madd1_mem( out, add, mul, ptr ) (out) = vfmaq_f32( add, mul, vld1q_dup_f32( (float const*)(ptr) ) ) + #else + #define stbir__simdf_madd( out, add, mul1, mul2 ) (out) = vaddq_f32( add, vmulq_f32( mul1, mul2 ) ) + #define stbir__simdf_madd1( out, add, mul1, mul2 ) (out) = vaddq_f32( add, vmulq_f32( mul1, mul2 ) ) + #define stbir__simdf_madd_mem( out, add, mul, ptr ) (out) = vaddq_f32( add, vmulq_f32( mul, vld1q_f32( (float const*)(ptr) ) ) ) + #define stbir__simdf_madd1_mem( out, add, mul, ptr ) (out) = vaddq_f32( add, vmulq_f32( mul, vld1q_dup_f32( (float const*)(ptr) ) ) ) + #endif + + #define stbir__simdf_add1( out, reg0, reg1 ) (out) = vaddq_f32( reg0, reg1 ) + #define stbir__simdf_mult1( out, reg0, reg1 ) (out) = vmulq_f32( reg0, reg1 ) + + #define stbir__simdf_and( out, reg0, reg1 ) (out) = vreinterpretq_f32_u32( vandq_u32( vreinterpretq_u32_f32(reg0), vreinterpretq_u32_f32(reg1) ) ) + #define stbir__simdf_or( out, reg0, reg1 ) (out) = vreinterpretq_f32_u32( vorrq_u32( vreinterpretq_u32_f32(reg0), vreinterpretq_u32_f32(reg1) ) ) + + #define stbir__simdf_min( out, reg0, reg1 ) (out) = vminq_f32( reg0, reg1 ) + #define stbir__simdf_max( out, reg0, reg1 ) (out) = vmaxq_f32( reg0, reg1 ) + #define stbir__simdf_min1( out, reg0, reg1 ) (out) = vminq_f32( reg0, reg1 ) + #define stbir__simdf_max1( out, reg0, reg1 ) (out) = vmaxq_f32( reg0, reg1 ) + + #define stbir__simdf_0123ABCDto3ABx( out, reg0, reg1 ) (out) = vextq_f32( reg0, reg1, 3 ) + #define stbir__simdf_0123ABCDto23Ax( out, reg0, reg1 ) (out) = vextq_f32( reg0, reg1, 2 ) + + #define stbir__simdf_a1a1( out, alp, ones ) (out) = vzipq_f32(vuzpq_f32(alp, alp).val[1], ones).val[0] + #define stbir__simdf_1a1a( out, alp, ones ) (out) = vzipq_f32(ones, vuzpq_f32(alp, alp).val[0]).val[0] + + #if defined( _M_ARM64 ) || defined( __aarch64__ ) || defined( __arm64__ ) + + #define stbir__simdf_aaa1( out, alp, ones ) (out) = vcopyq_laneq_f32(vdupq_n_f32(vgetq_lane_f32(alp, 3)), 3, ones, 3) + #define stbir__simdf_1aaa( out, alp, ones ) (out) = vcopyq_laneq_f32(vdupq_n_f32(vgetq_lane_f32(alp, 0)), 0, ones, 0) + + #if defined( _MSC_VER ) && !defined(__clang__) + #define stbir_make16(a,b,c,d) vcombine_u8( \ + vcreate_u8( (4*a+0) | ((4*a+1)<<8) | ((4*a+2)<<16) | ((4*a+3)<<24) | \ + ((stbir_uint64)(4*b+0)<<32) | ((stbir_uint64)(4*b+1)<<40) | ((stbir_uint64)(4*b+2)<<48) | ((stbir_uint64)(4*b+3)<<56)), \ + vcreate_u8( (4*c+0) | ((4*c+1)<<8) | ((4*c+2)<<16) | ((4*c+3)<<24) | \ + ((stbir_uint64)(4*d+0)<<32) | ((stbir_uint64)(4*d+1)<<40) | ((stbir_uint64)(4*d+2)<<48) | ((stbir_uint64)(4*d+3)<<56) ) ) + + static stbir__inline uint8x16x2_t stbir_make16x2(float32x4_t rega,float32x4_t regb) + { + uint8x16x2_t r = { vreinterpretq_u8_f32(rega), vreinterpretq_u8_f32(regb) }; + return r; + } + #else + #define stbir_make16(a,b,c,d) (uint8x16_t){4*a+0,4*a+1,4*a+2,4*a+3,4*b+0,4*b+1,4*b+2,4*b+3,4*c+0,4*c+1,4*c+2,4*c+3,4*d+0,4*d+1,4*d+2,4*d+3} + #define stbir_make16x2(a,b) (uint8x16x2_t){{vreinterpretq_u8_f32(a),vreinterpretq_u8_f32(b)}} + #endif + + #define stbir__simdf_swiz( reg, one, two, three, four ) vreinterpretq_f32_u8( vqtbl1q_u8( vreinterpretq_u8_f32(reg), stbir_make16(one, two, three, four) ) ) + #define stbir__simdf_swiz2( rega, regb, one, two, three, four ) vreinterpretq_f32_u8( vqtbl2q_u8( stbir_make16x2(rega,regb), stbir_make16(one, two, three, four) ) ) + + #define stbir__simdi_16madd( out, reg0, reg1 ) \ + { \ + int16x8_t r0 = vreinterpretq_s16_u32(reg0); \ + int16x8_t r1 = vreinterpretq_s16_u32(reg1); \ + int32x4_t tmp0 = vmull_s16( vget_low_s16(r0), vget_low_s16(r1) ); \ + int32x4_t tmp1 = vmull_s16( vget_high_s16(r0), vget_high_s16(r1) ); \ + (out) = vreinterpretq_u32_s32( vpaddq_s32(tmp0, tmp1) ); \ + } + + #else + + #define stbir__simdf_aaa1( out, alp, ones ) (out) = vsetq_lane_f32(1.0f, vdupq_n_f32(vgetq_lane_f32(alp, 3)), 3) + #define stbir__simdf_1aaa( out, alp, ones ) (out) = vsetq_lane_f32(1.0f, vdupq_n_f32(vgetq_lane_f32(alp, 0)), 0) + + #if defined( _MSC_VER ) && !defined(__clang__) + static stbir__inline uint8x8x2_t stbir_make8x2(float32x4_t reg) + { + uint8x8x2_t r = { { vget_low_u8(vreinterpretq_u8_f32(reg)), vget_high_u8(vreinterpretq_u8_f32(reg)) } }; + return r; + } + #define stbir_make8(a,b) vcreate_u8( \ + (4*a+0) | ((4*a+1)<<8) | ((4*a+2)<<16) | ((4*a+3)<<24) | \ + ((stbir_uint64)(4*b+0)<<32) | ((stbir_uint64)(4*b+1)<<40) | ((stbir_uint64)(4*b+2)<<48) | ((stbir_uint64)(4*b+3)<<56) ) + #else + #define stbir_make8x2(reg) (uint8x8x2_t){ { vget_low_u8(vreinterpretq_u8_f32(reg)), vget_high_u8(vreinterpretq_u8_f32(reg)) } } + #define stbir_make8(a,b) (uint8x8_t){4*a+0,4*a+1,4*a+2,4*a+3,4*b+0,4*b+1,4*b+2,4*b+3} + #endif + + #define stbir__simdf_swiz( reg, one, two, three, four ) vreinterpretq_f32_u8( vcombine_u8( \ + vtbl2_u8( stbir_make8x2( reg ), stbir_make8( one, two ) ), \ + vtbl2_u8( stbir_make8x2( reg ), stbir_make8( three, four ) ) ) ) + + #define stbir__simdi_16madd( out, reg0, reg1 ) \ + { \ + int16x8_t r0 = vreinterpretq_s16_u32(reg0); \ + int16x8_t r1 = vreinterpretq_s16_u32(reg1); \ + int32x4_t tmp0 = vmull_s16( vget_low_s16(r0), vget_low_s16(r1) ); \ + int32x4_t tmp1 = vmull_s16( vget_high_s16(r0), vget_high_s16(r1) ); \ + int32x2_t out0 = vpadd_s32( vget_low_s32(tmp0), vget_high_s32(tmp0) ); \ + int32x2_t out1 = vpadd_s32( vget_low_s32(tmp1), vget_high_s32(tmp1) ); \ + (out) = vreinterpretq_u32_s32( vcombine_s32(out0, out1) ); \ + } + + #endif + + #define stbir__simdi_and( out, reg0, reg1 ) (out) = vandq_u32( reg0, reg1 ) + #define stbir__simdi_or( out, reg0, reg1 ) (out) = vorrq_u32( reg0, reg1 ) + + #define stbir__simdf_pack_to_8bytes(out,aa,bb) \ + { \ + float32x4_t af = vmaxq_f32( vminq_f32(aa,STBIR__CONSTF(STBIR_max_uint8_as_float) ), vdupq_n_f32(0) ); \ + float32x4_t bf = vmaxq_f32( vminq_f32(bb,STBIR__CONSTF(STBIR_max_uint8_as_float) ), vdupq_n_f32(0) ); \ + int16x4_t ai = vqmovn_s32( vcvtq_s32_f32( af ) ); \ + int16x4_t bi = vqmovn_s32( vcvtq_s32_f32( bf ) ); \ + uint8x8_t out8 = vqmovun_s16( vcombine_s16(ai, bi) ); \ + out = vreinterpretq_u32_u8( vcombine_u8(out8, out8) ); \ + } + + #define stbir__simdf_pack_to_8words(out,aa,bb) \ + { \ + float32x4_t af = vmaxq_f32( vminq_f32(aa,STBIR__CONSTF(STBIR_max_uint16_as_float) ), vdupq_n_f32(0) ); \ + float32x4_t bf = vmaxq_f32( vminq_f32(bb,STBIR__CONSTF(STBIR_max_uint16_as_float) ), vdupq_n_f32(0) ); \ + int32x4_t ai = vcvtq_s32_f32( af ); \ + int32x4_t bi = vcvtq_s32_f32( bf ); \ + out = vreinterpretq_u32_u16( vcombine_u16(vqmovun_s32(ai), vqmovun_s32(bi)) ); \ + } + + #define stbir__interleave_pack_and_store_16_u8( ptr, r0, r1, r2, r3 ) \ + { \ + int16x4x2_t tmp0 = vzip_s16( vqmovn_s32(vreinterpretq_s32_u32(r0)), vqmovn_s32(vreinterpretq_s32_u32(r2)) ); \ + int16x4x2_t tmp1 = vzip_s16( vqmovn_s32(vreinterpretq_s32_u32(r1)), vqmovn_s32(vreinterpretq_s32_u32(r3)) ); \ + uint8x8x2_t out = \ + { { \ + vqmovun_s16( vcombine_s16(tmp0.val[0], tmp0.val[1]) ), \ + vqmovun_s16( vcombine_s16(tmp1.val[0], tmp1.val[1]) ), \ + } }; \ + vst2_u8(ptr, out); \ + } + + #define stbir__simdf_load4_transposed( o0, o1, o2, o3, ptr ) \ + { \ + float32x4x4_t tmp = vld4q_f32(ptr); \ + o0 = tmp.val[0]; \ + o1 = tmp.val[1]; \ + o2 = tmp.val[2]; \ + o3 = tmp.val[3]; \ + } + + #define stbir__simdi_32shr( out, reg, imm ) out = vshrq_n_u32( reg, imm ) + + #if defined( _MSC_VER ) && !defined(__clang__) + #define STBIR__SIMDF_CONST(var, x) __declspec(align(8)) float var[] = { x, x, x, x } + #define STBIR__SIMDI_CONST(var, x) __declspec(align(8)) uint32_t var[] = { x, x, x, x } + #define STBIR__CONSTF(var) (*(const float32x4_t*)var) + #define STBIR__CONSTI(var) (*(const uint32x4_t*)var) + #else + #define STBIR__SIMDF_CONST(var, x) stbir__simdf var = { x, x, x, x } + #define STBIR__SIMDI_CONST(var, x) stbir__simdi var = { x, x, x, x } + #define STBIR__CONSTF(var) (var) + #define STBIR__CONSTI(var) (var) + #endif + + #ifdef STBIR_FLOORF + #undef STBIR_FLOORF + #endif + #define STBIR_FLOORF stbir_simd_floorf + static stbir__inline float stbir_simd_floorf(float x) + { + #if defined( _M_ARM64 ) || defined( __aarch64__ ) || defined( __arm64__ ) + return vget_lane_f32( vrndm_f32( vdup_n_f32(x) ), 0); + #else + float32x2_t f = vdup_n_f32(x); + float32x2_t t = vcvt_f32_s32(vcvt_s32_f32(f)); + uint32x2_t a = vclt_f32(f, t); + uint32x2_t b = vreinterpret_u32_f32(vdup_n_f32(-1.0f)); + float32x2_t r = vadd_f32(t, vreinterpret_f32_u32(vand_u32(a, b))); + return vget_lane_f32(r, 0); + #endif + } + + #ifdef STBIR_CEILF + #undef STBIR_CEILF + #endif + #define STBIR_CEILF stbir_simd_ceilf + static stbir__inline float stbir_simd_ceilf(float x) + { + #if defined( _M_ARM64 ) || defined( __aarch64__ ) || defined( __arm64__ ) + return vget_lane_f32( vrndp_f32( vdup_n_f32(x) ), 0); + #else + float32x2_t f = vdup_n_f32(x); + float32x2_t t = vcvt_f32_s32(vcvt_s32_f32(f)); + uint32x2_t a = vclt_f32(t, f); + uint32x2_t b = vreinterpret_u32_f32(vdup_n_f32(1.0f)); + float32x2_t r = vadd_f32(t, vreinterpret_f32_u32(vand_u32(a, b))); + return vget_lane_f32(r, 0); + #endif + } + + #define STBIR_SIMD + +#elif defined(STBIR_WASM) + + #include + + #define stbir__simdf v128_t + #define stbir__simdi v128_t + + #define stbir_simdi_castf( reg ) (reg) + #define stbir_simdf_casti( reg ) (reg) + + #define stbir__simdf_load( reg, ptr ) (reg) = wasm_v128_load( (void const*)(ptr) ) + #define stbir__simdi_load( reg, ptr ) (reg) = wasm_v128_load( (void const*)(ptr) ) + #define stbir__simdf_load1( out, ptr ) (out) = wasm_v128_load32_splat( (void const*)(ptr) ) // top values can be random (not denormal or nan for perf) + #define stbir__simdi_load1( out, ptr ) (out) = wasm_v128_load32_splat( (void const*)(ptr) ) + #define stbir__simdf_load1z( out, ptr ) (out) = wasm_v128_load32_zero( (void const*)(ptr) ) // top values must be zero + #define stbir__simdf_frep4( fvar ) wasm_f32x4_splat( fvar ) + #define stbir__simdf_load1frep4( out, fvar ) (out) = wasm_f32x4_splat( fvar ) + #define stbir__simdf_load2( out, ptr ) (out) = wasm_v128_load64_splat( (void const*)(ptr) ) // top values can be random (not denormal or nan for perf) + #define stbir__simdf_load2z( out, ptr ) (out) = wasm_v128_load64_zero( (void const*)(ptr) ) // top values must be zero + #define stbir__simdf_load2hmerge( out, reg, ptr ) (out) = wasm_v128_load64_lane( (void const*)(ptr), reg, 1 ) + + #define stbir__simdf_zeroP() wasm_f32x4_const_splat(0) + #define stbir__simdf_zero( reg ) (reg) = wasm_f32x4_const_splat(0) + + #define stbir__simdf_store( ptr, reg ) wasm_v128_store( (void*)(ptr), reg ) + #define stbir__simdf_store1( ptr, reg ) wasm_v128_store32_lane( (void*)(ptr), reg, 0 ) + #define stbir__simdf_store2( ptr, reg ) wasm_v128_store64_lane( (void*)(ptr), reg, 0 ) + #define stbir__simdf_store2h( ptr, reg ) wasm_v128_store64_lane( (void*)(ptr), reg, 1 ) + + #define stbir__simdi_store( ptr, reg ) wasm_v128_store( (void*)(ptr), reg ) + #define stbir__simdi_store1( ptr, reg ) wasm_v128_store32_lane( (void*)(ptr), reg, 0 ) + #define stbir__simdi_store2( ptr, reg ) wasm_v128_store64_lane( (void*)(ptr), reg, 0 ) + + #define stbir__prefetch( ptr ) + + #define stbir__simdi_expand_u8_to_u32(out0,out1,out2,out3,ireg) \ + { \ + v128_t l = wasm_u16x8_extend_low_u8x16 ( ireg ); \ + v128_t h = wasm_u16x8_extend_high_u8x16( ireg ); \ + out0 = wasm_u32x4_extend_low_u16x8 ( l ); \ + out1 = wasm_u32x4_extend_high_u16x8( l ); \ + out2 = wasm_u32x4_extend_low_u16x8 ( h ); \ + out3 = wasm_u32x4_extend_high_u16x8( h ); \ + } + + #define stbir__simdi_expand_u8_to_1u32(out,ireg) \ + { \ + v128_t tmp = wasm_u16x8_extend_low_u8x16(ireg); \ + out = wasm_u32x4_extend_low_u16x8(tmp); \ + } + + #define stbir__simdi_expand_u16_to_u32(out0,out1,ireg) \ + { \ + out0 = wasm_u32x4_extend_low_u16x8 ( ireg ); \ + out1 = wasm_u32x4_extend_high_u16x8( ireg ); \ + } + + #define stbir__simdf_convert_float_to_i32( i, f ) (i) = wasm_i32x4_trunc_sat_f32x4(f) + #define stbir__simdf_convert_float_to_int( f ) wasm_i32x4_extract_lane(wasm_i32x4_trunc_sat_f32x4(f), 0) + #define stbir__simdi_to_int( i ) wasm_i32x4_extract_lane(i, 0) + #define stbir__simdf_convert_float_to_uint8( f ) ((unsigned char)wasm_i32x4_extract_lane(wasm_i32x4_trunc_sat_f32x4(wasm_f32x4_max(wasm_f32x4_min(f,STBIR_max_uint8_as_float),wasm_f32x4_const_splat(0))), 0)) + #define stbir__simdf_convert_float_to_short( f ) ((unsigned short)wasm_i32x4_extract_lane(wasm_i32x4_trunc_sat_f32x4(wasm_f32x4_max(wasm_f32x4_min(f,STBIR_max_uint16_as_float),wasm_f32x4_const_splat(0))), 0)) + #define stbir__simdi_convert_i32_to_float(out, ireg) (out) = wasm_f32x4_convert_i32x4(ireg) + #define stbir__simdf_add( out, reg0, reg1 ) (out) = wasm_f32x4_add( reg0, reg1 ) + #define stbir__simdf_mult( out, reg0, reg1 ) (out) = wasm_f32x4_mul( reg0, reg1 ) + #define stbir__simdf_mult_mem( out, reg, ptr ) (out) = wasm_f32x4_mul( reg, wasm_v128_load( (void const*)(ptr) ) ) + #define stbir__simdf_mult1_mem( out, reg, ptr ) (out) = wasm_f32x4_mul( reg, wasm_v128_load32_splat( (void const*)(ptr) ) ) + #define stbir__simdf_add_mem( out, reg, ptr ) (out) = wasm_f32x4_add( reg, wasm_v128_load( (void const*)(ptr) ) ) + #define stbir__simdf_add1_mem( out, reg, ptr ) (out) = wasm_f32x4_add( reg, wasm_v128_load32_splat( (void const*)(ptr) ) ) + + #define stbir__simdf_madd( out, add, mul1, mul2 ) (out) = wasm_f32x4_add( add, wasm_f32x4_mul( mul1, mul2 ) ) + #define stbir__simdf_madd1( out, add, mul1, mul2 ) (out) = wasm_f32x4_add( add, wasm_f32x4_mul( mul1, mul2 ) ) + #define stbir__simdf_madd_mem( out, add, mul, ptr ) (out) = wasm_f32x4_add( add, wasm_f32x4_mul( mul, wasm_v128_load( (void const*)(ptr) ) ) ) + #define stbir__simdf_madd1_mem( out, add, mul, ptr ) (out) = wasm_f32x4_add( add, wasm_f32x4_mul( mul, wasm_v128_load32_splat( (void const*)(ptr) ) ) ) + + #define stbir__simdf_add1( out, reg0, reg1 ) (out) = wasm_f32x4_add( reg0, reg1 ) + #define stbir__simdf_mult1( out, reg0, reg1 ) (out) = wasm_f32x4_mul( reg0, reg1 ) + + #define stbir__simdf_and( out, reg0, reg1 ) (out) = wasm_v128_and( reg0, reg1 ) + #define stbir__simdf_or( out, reg0, reg1 ) (out) = wasm_v128_or( reg0, reg1 ) + + #define stbir__simdf_min( out, reg0, reg1 ) (out) = wasm_f32x4_min( reg0, reg1 ) + #define stbir__simdf_max( out, reg0, reg1 ) (out) = wasm_f32x4_max( reg0, reg1 ) + #define stbir__simdf_min1( out, reg0, reg1 ) (out) = wasm_f32x4_min( reg0, reg1 ) + #define stbir__simdf_max1( out, reg0, reg1 ) (out) = wasm_f32x4_max( reg0, reg1 ) + + #define stbir__simdf_0123ABCDto3ABx( out, reg0, reg1 ) (out) = wasm_i32x4_shuffle( reg0, reg1, 3, 4, 5, -1 ) + #define stbir__simdf_0123ABCDto23Ax( out, reg0, reg1 ) (out) = wasm_i32x4_shuffle( reg0, reg1, 2, 3, 4, -1 ) + + #define stbir__simdf_aaa1(out,alp,ones) (out) = wasm_i32x4_shuffle(alp, ones, 3, 3, 3, 4) + #define stbir__simdf_1aaa(out,alp,ones) (out) = wasm_i32x4_shuffle(alp, ones, 4, 0, 0, 0) + #define stbir__simdf_a1a1(out,alp,ones) (out) = wasm_i32x4_shuffle(alp, ones, 1, 4, 3, 4) + #define stbir__simdf_1a1a(out,alp,ones) (out) = wasm_i32x4_shuffle(alp, ones, 4, 0, 4, 2) + + #define stbir__simdf_swiz( reg, one, two, three, four ) wasm_i32x4_shuffle(reg, reg, one, two, three, four) + + #define stbir__simdi_and( out, reg0, reg1 ) (out) = wasm_v128_and( reg0, reg1 ) + #define stbir__simdi_or( out, reg0, reg1 ) (out) = wasm_v128_or( reg0, reg1 ) + #define stbir__simdi_16madd( out, reg0, reg1 ) (out) = wasm_i32x4_dot_i16x8( reg0, reg1 ) + + #define stbir__simdf_pack_to_8bytes(out,aa,bb) \ + { \ + v128_t af = wasm_f32x4_max( wasm_f32x4_min(aa, STBIR_max_uint8_as_float), wasm_f32x4_const_splat(0) ); \ + v128_t bf = wasm_f32x4_max( wasm_f32x4_min(bb, STBIR_max_uint8_as_float), wasm_f32x4_const_splat(0) ); \ + v128_t ai = wasm_i32x4_trunc_sat_f32x4( af ); \ + v128_t bi = wasm_i32x4_trunc_sat_f32x4( bf ); \ + v128_t out16 = wasm_i16x8_narrow_i32x4( ai, bi ); \ + out = wasm_u8x16_narrow_i16x8( out16, out16 ); \ + } + + #define stbir__simdf_pack_to_8words(out,aa,bb) \ + { \ + v128_t af = wasm_f32x4_max( wasm_f32x4_min(aa, STBIR_max_uint16_as_float), wasm_f32x4_const_splat(0)); \ + v128_t bf = wasm_f32x4_max( wasm_f32x4_min(bb, STBIR_max_uint16_as_float), wasm_f32x4_const_splat(0)); \ + v128_t ai = wasm_i32x4_trunc_sat_f32x4( af ); \ + v128_t bi = wasm_i32x4_trunc_sat_f32x4( bf ); \ + out = wasm_u16x8_narrow_i32x4( ai, bi ); \ + } + + #define stbir__interleave_pack_and_store_16_u8( ptr, r0, r1, r2, r3 ) \ + { \ + v128_t tmp0 = wasm_i16x8_narrow_i32x4(r0, r1); \ + v128_t tmp1 = wasm_i16x8_narrow_i32x4(r2, r3); \ + v128_t tmp = wasm_u8x16_narrow_i16x8(tmp0, tmp1); \ + tmp = wasm_i8x16_shuffle(tmp, tmp, 0, 4, 8, 12, 1, 5, 9, 13, 2, 6, 10, 14, 3, 7, 11, 15); \ + wasm_v128_store( (void*)(ptr), tmp); \ + } + + #define stbir__simdf_load4_transposed( o0, o1, o2, o3, ptr ) \ + { \ + v128_t t0 = wasm_v128_load( ptr ); \ + v128_t t1 = wasm_v128_load( ptr+4 ); \ + v128_t t2 = wasm_v128_load( ptr+8 ); \ + v128_t t3 = wasm_v128_load( ptr+12 ); \ + v128_t s0 = wasm_i32x4_shuffle(t0, t1, 0, 4, 2, 6); \ + v128_t s1 = wasm_i32x4_shuffle(t0, t1, 1, 5, 3, 7); \ + v128_t s2 = wasm_i32x4_shuffle(t2, t3, 0, 4, 2, 6); \ + v128_t s3 = wasm_i32x4_shuffle(t2, t3, 1, 5, 3, 7); \ + o0 = wasm_i32x4_shuffle(s0, s2, 0, 1, 4, 5); \ + o1 = wasm_i32x4_shuffle(s1, s3, 0, 1, 4, 5); \ + o2 = wasm_i32x4_shuffle(s0, s2, 2, 3, 6, 7); \ + o3 = wasm_i32x4_shuffle(s1, s3, 2, 3, 6, 7); \ + } + + #define stbir__simdi_32shr( out, reg, imm ) out = wasm_u32x4_shr( reg, imm ) + + typedef float stbir__f32x4 __attribute__((__vector_size__(16), __aligned__(16))); + #define STBIR__SIMDF_CONST(var, x) stbir__simdf var = (v128_t)(stbir__f32x4){ x, x, x, x } + #define STBIR__SIMDI_CONST(var, x) stbir__simdi var = { x, x, x, x } + #define STBIR__CONSTF(var) (var) + #define STBIR__CONSTI(var) (var) + + #ifdef STBIR_FLOORF + #undef STBIR_FLOORF + #endif + #define STBIR_FLOORF stbir_simd_floorf + static stbir__inline float stbir_simd_floorf(float x) + { + return wasm_f32x4_extract_lane( wasm_f32x4_floor( wasm_f32x4_splat(x) ), 0); + } + + #ifdef STBIR_CEILF + #undef STBIR_CEILF + #endif + #define STBIR_CEILF stbir_simd_ceilf + static stbir__inline float stbir_simd_ceilf(float x) + { + return wasm_f32x4_extract_lane( wasm_f32x4_ceil( wasm_f32x4_splat(x) ), 0); + } + + #define STBIR_SIMD + +#endif // SSE2/NEON/WASM + +#endif // NO SIMD + +#ifdef STBIR_SIMD8 + #define stbir__simdfX stbir__simdf8 + #define stbir__simdiX stbir__simdi8 + #define stbir__simdfX_load stbir__simdf8_load + #define stbir__simdiX_load stbir__simdi8_load + #define stbir__simdfX_mult stbir__simdf8_mult + #define stbir__simdfX_add_mem stbir__simdf8_add_mem + #define stbir__simdfX_madd_mem stbir__simdf8_madd_mem + #define stbir__simdfX_store stbir__simdf8_store + #define stbir__simdiX_store stbir__simdi8_store + #define stbir__simdf_frepX stbir__simdf8_frep8 + #define stbir__simdfX_madd stbir__simdf8_madd + #define stbir__simdfX_min stbir__simdf8_min + #define stbir__simdfX_max stbir__simdf8_max + #define stbir__simdfX_aaa1 stbir__simdf8_aaa1 + #define stbir__simdfX_1aaa stbir__simdf8_1aaa + #define stbir__simdfX_a1a1 stbir__simdf8_a1a1 + #define stbir__simdfX_1a1a stbir__simdf8_1a1a + #define stbir__simdfX_convert_float_to_i32 stbir__simdf8_convert_float_to_i32 + #define stbir__simdfX_pack_to_words stbir__simdf8_pack_to_16words + #define stbir__simdfX_zero stbir__simdf8_zero + #define STBIR_onesX STBIR_ones8 + #define STBIR_max_uint8_as_floatX STBIR_max_uint8_as_float8 + #define STBIR_max_uint16_as_floatX STBIR_max_uint16_as_float8 + #define STBIR_simd_point5X STBIR_simd_point58 + #define stbir__simdfX_float_count 8 + #define stbir__simdfX_0123to1230 stbir__simdf8_0123to12301230 + #define stbir__simdfX_0123to2103 stbir__simdf8_0123to21032103 + static const stbir__simdf8 STBIR_max_uint16_as_float_inverted8 = { stbir__max_uint16_as_float_inverted,stbir__max_uint16_as_float_inverted,stbir__max_uint16_as_float_inverted,stbir__max_uint16_as_float_inverted,stbir__max_uint16_as_float_inverted,stbir__max_uint16_as_float_inverted,stbir__max_uint16_as_float_inverted,stbir__max_uint16_as_float_inverted }; + static const stbir__simdf8 STBIR_max_uint8_as_float_inverted8 = { stbir__max_uint8_as_float_inverted,stbir__max_uint8_as_float_inverted,stbir__max_uint8_as_float_inverted,stbir__max_uint8_as_float_inverted,stbir__max_uint8_as_float_inverted,stbir__max_uint8_as_float_inverted,stbir__max_uint8_as_float_inverted,stbir__max_uint8_as_float_inverted }; + static const stbir__simdf8 STBIR_ones8 = { 1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0 }; + static const stbir__simdf8 STBIR_simd_point58 = { 0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5 }; + static const stbir__simdf8 STBIR_max_uint8_as_float8 = { stbir__max_uint8_as_float,stbir__max_uint8_as_float,stbir__max_uint8_as_float,stbir__max_uint8_as_float, stbir__max_uint8_as_float,stbir__max_uint8_as_float,stbir__max_uint8_as_float,stbir__max_uint8_as_float }; + static const stbir__simdf8 STBIR_max_uint16_as_float8 = { stbir__max_uint16_as_float,stbir__max_uint16_as_float,stbir__max_uint16_as_float,stbir__max_uint16_as_float, stbir__max_uint16_as_float,stbir__max_uint16_as_float,stbir__max_uint16_as_float,stbir__max_uint16_as_float }; +#else + #define stbir__simdfX stbir__simdf + #define stbir__simdiX stbir__simdi + #define stbir__simdfX_load stbir__simdf_load + #define stbir__simdiX_load stbir__simdi_load + #define stbir__simdfX_mult stbir__simdf_mult + #define stbir__simdfX_add_mem stbir__simdf_add_mem + #define stbir__simdfX_madd_mem stbir__simdf_madd_mem + #define stbir__simdfX_store stbir__simdf_store + #define stbir__simdiX_store stbir__simdi_store + #define stbir__simdf_frepX stbir__simdf_frep4 + #define stbir__simdfX_madd stbir__simdf_madd + #define stbir__simdfX_min stbir__simdf_min + #define stbir__simdfX_max stbir__simdf_max + #define stbir__simdfX_aaa1 stbir__simdf_aaa1 + #define stbir__simdfX_1aaa stbir__simdf_1aaa + #define stbir__simdfX_a1a1 stbir__simdf_a1a1 + #define stbir__simdfX_1a1a stbir__simdf_1a1a + #define stbir__simdfX_convert_float_to_i32 stbir__simdf_convert_float_to_i32 + #define stbir__simdfX_pack_to_words stbir__simdf_pack_to_8words + #define stbir__simdfX_zero stbir__simdf_zero + #define STBIR_onesX STBIR__CONSTF(STBIR_ones) + #define STBIR_simd_point5X STBIR__CONSTF(STBIR_simd_point5) + #define STBIR_max_uint8_as_floatX STBIR__CONSTF(STBIR_max_uint8_as_float) + #define STBIR_max_uint16_as_floatX STBIR__CONSTF(STBIR_max_uint16_as_float) + #define stbir__simdfX_float_count 4 + #define stbir__if_simdf8_cast_to_simdf4( val ) ( val ) + #define stbir__simdfX_0123to1230 stbir__simdf_0123to1230 + #define stbir__simdfX_0123to2103 stbir__simdf_0123to2103 +#endif + + +#if defined(STBIR_NEON) && !defined(_M_ARM) && !defined(__arm__) + + #if defined( _MSC_VER ) && !defined(__clang__) + typedef __int16 stbir__FP16; + #else + typedef float16_t stbir__FP16; + #endif + +#else // no NEON, or 32-bit ARM for MSVC + + typedef union stbir__FP16 + { + unsigned short u; + } stbir__FP16; + +#endif + +#if (!defined(STBIR_NEON) && !defined(STBIR_FP16C)) || (defined(STBIR_NEON) && defined(_M_ARM)) || (defined(STBIR_NEON) && defined(__arm__)) + + // Fabian's half float routines, see: https://gist.github.com/rygorous/2156668 + + static stbir__inline float stbir__half_to_float( stbir__FP16 h ) + { + static const stbir__FP32 magic = { (254 - 15) << 23 }; + static const stbir__FP32 was_infnan = { (127 + 16) << 23 }; + stbir__FP32 o; + + o.u = (h.u & 0x7fff) << 13; // exponent/mantissa bits + o.f *= magic.f; // exponent adjust + if (o.f >= was_infnan.f) // make sure Inf/NaN survive + o.u |= 255 << 23; + o.u |= (h.u & 0x8000) << 16; // sign bit + return o.f; + } + + static stbir__inline stbir__FP16 stbir__float_to_half(float val) + { + stbir__FP32 f32infty = { 255 << 23 }; + stbir__FP32 f16max = { (127 + 16) << 23 }; + stbir__FP32 denorm_magic = { ((127 - 15) + (23 - 10) + 1) << 23 }; + unsigned int sign_mask = 0x80000000u; + stbir__FP16 o = { 0 }; + stbir__FP32 f; + unsigned int sign; + + f.f = val; + sign = f.u & sign_mask; + f.u ^= sign; + + if (f.u >= f16max.u) // result is Inf or NaN (all exponent bits set) + o.u = (f.u > f32infty.u) ? 0x7e00 : 0x7c00; // NaN->qNaN and Inf->Inf + else // (De)normalized number or zero + { + if (f.u < (113 << 23)) // resulting FP16 is subnormal or zero + { + // use a magic value to align our 10 mantissa bits at the bottom of + // the float. as long as FP addition is round-to-nearest-even this + // just works. + f.f += denorm_magic.f; + // and one integer subtract of the bias later, we have our final float! + o.u = (unsigned short) ( f.u - denorm_magic.u ); + } + else + { + unsigned int mant_odd = (f.u >> 13) & 1; // resulting mantissa is odd + // update exponent, rounding bias part 1 + f.u = f.u + ((15u - 127) << 23) + 0xfff; + // rounding bias part 2 + f.u += mant_odd; + // take the bits! + o.u = (unsigned short) ( f.u >> 13 ); + } + } + + o.u |= sign >> 16; + return o; + } + +#endif + + +#if defined(STBIR_FP16C) + + #include + + static stbir__inline void stbir__half_to_float_SIMD(float * output, stbir__FP16 const * input) + { + _mm256_storeu_ps( (float*)output, _mm256_cvtph_ps( _mm_loadu_si128( (__m128i const* )input ) ) ); + } + + static stbir__inline void stbir__float_to_half_SIMD(stbir__FP16 * output, float const * input) + { + _mm_storeu_si128( (__m128i*)output, _mm256_cvtps_ph( _mm256_loadu_ps( input ), 0 ) ); + } + + static stbir__inline float stbir__half_to_float( stbir__FP16 h ) + { + return _mm_cvtss_f32( _mm_cvtph_ps( _mm_cvtsi32_si128( (int)h.u ) ) ); + } + + static stbir__inline stbir__FP16 stbir__float_to_half( float f ) + { + stbir__FP16 h; + h.u = (unsigned short) _mm_cvtsi128_si32( _mm_cvtps_ph( _mm_set_ss( f ), 0 ) ); + return h; + } + +#elif defined(STBIR_SSE2) + + // Fabian's half float routines, see: https://gist.github.com/rygorous/2156668 + stbir__inline static void stbir__half_to_float_SIMD(float * output, void const * input) + { + static const STBIR__SIMDI_CONST(mask_nosign, 0x7fff); + static const STBIR__SIMDI_CONST(smallest_normal, 0x0400); + static const STBIR__SIMDI_CONST(infinity, 0x7c00); + static const STBIR__SIMDI_CONST(expadjust_normal, (127 - 15) << 23); + static const STBIR__SIMDI_CONST(magic_denorm, 113 << 23); + + __m128i i = _mm_loadu_si128 ( (__m128i const*)(input) ); + __m128i h = _mm_unpacklo_epi16 ( i, _mm_setzero_si128() ); + __m128i mnosign = STBIR__CONSTI(mask_nosign); + __m128i eadjust = STBIR__CONSTI(expadjust_normal); + __m128i smallest = STBIR__CONSTI(smallest_normal); + __m128i infty = STBIR__CONSTI(infinity); + __m128i expmant = _mm_and_si128(mnosign, h); + __m128i justsign = _mm_xor_si128(h, expmant); + __m128i b_notinfnan = _mm_cmpgt_epi32(infty, expmant); + __m128i b_isdenorm = _mm_cmpgt_epi32(smallest, expmant); + __m128i shifted = _mm_slli_epi32(expmant, 13); + __m128i adj_infnan = _mm_andnot_si128(b_notinfnan, eadjust); + __m128i adjusted = _mm_add_epi32(eadjust, shifted); + __m128i den1 = _mm_add_epi32(shifted, STBIR__CONSTI(magic_denorm)); + __m128i adjusted2 = _mm_add_epi32(adjusted, adj_infnan); + __m128 den2 = _mm_sub_ps(_mm_castsi128_ps(den1), *(const __m128 *)&magic_denorm); + __m128 adjusted3 = _mm_and_ps(den2, _mm_castsi128_ps(b_isdenorm)); + __m128 adjusted4 = _mm_andnot_ps(_mm_castsi128_ps(b_isdenorm), _mm_castsi128_ps(adjusted2)); + __m128 adjusted5 = _mm_or_ps(adjusted3, adjusted4); + __m128i sign = _mm_slli_epi32(justsign, 16); + __m128 final = _mm_or_ps(adjusted5, _mm_castsi128_ps(sign)); + stbir__simdf_store( output + 0, final ); + + h = _mm_unpackhi_epi16 ( i, _mm_setzero_si128() ); + expmant = _mm_and_si128(mnosign, h); + justsign = _mm_xor_si128(h, expmant); + b_notinfnan = _mm_cmpgt_epi32(infty, expmant); + b_isdenorm = _mm_cmpgt_epi32(smallest, expmant); + shifted = _mm_slli_epi32(expmant, 13); + adj_infnan = _mm_andnot_si128(b_notinfnan, eadjust); + adjusted = _mm_add_epi32(eadjust, shifted); + den1 = _mm_add_epi32(shifted, STBIR__CONSTI(magic_denorm)); + adjusted2 = _mm_add_epi32(adjusted, adj_infnan); + den2 = _mm_sub_ps(_mm_castsi128_ps(den1), *(const __m128 *)&magic_denorm); + adjusted3 = _mm_and_ps(den2, _mm_castsi128_ps(b_isdenorm)); + adjusted4 = _mm_andnot_ps(_mm_castsi128_ps(b_isdenorm), _mm_castsi128_ps(adjusted2)); + adjusted5 = _mm_or_ps(adjusted3, adjusted4); + sign = _mm_slli_epi32(justsign, 16); + final = _mm_or_ps(adjusted5, _mm_castsi128_ps(sign)); + stbir__simdf_store( output + 4, final ); + + // ~38 SSE2 ops for 8 values + } + + // Fabian's round-to-nearest-even float to half + // ~48 SSE2 ops for 8 output + stbir__inline static void stbir__float_to_half_SIMD(void * output, float const * input) + { + static const STBIR__SIMDI_CONST(mask_sign, 0x80000000u); + static const STBIR__SIMDI_CONST(c_f16max, (127 + 16) << 23); // all FP32 values >=this round to +inf + static const STBIR__SIMDI_CONST(c_nanbit, 0x200); + static const STBIR__SIMDI_CONST(c_infty_as_fp16, 0x7c00); + static const STBIR__SIMDI_CONST(c_min_normal, (127 - 14) << 23); // smallest FP32 that yields a normalized FP16 + static const STBIR__SIMDI_CONST(c_subnorm_magic, ((127 - 15) + (23 - 10) + 1) << 23); + static const STBIR__SIMDI_CONST(c_normal_bias, 0xfff - ((127 - 15) << 23)); // adjust exponent and add mantissa rounding + + __m128 f = _mm_loadu_ps(input); + __m128 msign = _mm_castsi128_ps(STBIR__CONSTI(mask_sign)); + __m128 justsign = _mm_and_ps(msign, f); + __m128 absf = _mm_xor_ps(f, justsign); + __m128i absf_int = _mm_castps_si128(absf); // the cast is "free" (extra bypass latency, but no thruput hit) + __m128i f16max = STBIR__CONSTI(c_f16max); + __m128 b_isnan = _mm_cmpunord_ps(absf, absf); // is this a NaN? + __m128i b_isregular = _mm_cmpgt_epi32(f16max, absf_int); // (sub)normalized or special? + __m128i nanbit = _mm_and_si128(_mm_castps_si128(b_isnan), STBIR__CONSTI(c_nanbit)); + __m128i inf_or_nan = _mm_or_si128(nanbit, STBIR__CONSTI(c_infty_as_fp16)); // output for specials + + __m128i min_normal = STBIR__CONSTI(c_min_normal); + __m128i b_issub = _mm_cmpgt_epi32(min_normal, absf_int); + + // "result is subnormal" path + __m128 subnorm1 = _mm_add_ps(absf, _mm_castsi128_ps(STBIR__CONSTI(c_subnorm_magic))); // magic value to round output mantissa + __m128i subnorm2 = _mm_sub_epi32(_mm_castps_si128(subnorm1), STBIR__CONSTI(c_subnorm_magic)); // subtract out bias + + // "result is normal" path + __m128i mantoddbit = _mm_slli_epi32(absf_int, 31 - 13); // shift bit 13 (mantissa LSB) to sign + __m128i mantodd = _mm_srai_epi32(mantoddbit, 31); // -1 if FP16 mantissa odd, else 0 + + __m128i round1 = _mm_add_epi32(absf_int, STBIR__CONSTI(c_normal_bias)); + __m128i round2 = _mm_sub_epi32(round1, mantodd); // if mantissa LSB odd, bias towards rounding up (RTNE) + __m128i normal = _mm_srli_epi32(round2, 13); // rounded result + + // combine the two non-specials + __m128i nonspecial = _mm_or_si128(_mm_and_si128(subnorm2, b_issub), _mm_andnot_si128(b_issub, normal)); + + // merge in specials as well + __m128i joined = _mm_or_si128(_mm_and_si128(nonspecial, b_isregular), _mm_andnot_si128(b_isregular, inf_or_nan)); + + __m128i sign_shift = _mm_srai_epi32(_mm_castps_si128(justsign), 16); + __m128i final2, final= _mm_or_si128(joined, sign_shift); + + f = _mm_loadu_ps(input+4); + justsign = _mm_and_ps(msign, f); + absf = _mm_xor_ps(f, justsign); + absf_int = _mm_castps_si128(absf); // the cast is "free" (extra bypass latency, but no thruput hit) + b_isnan = _mm_cmpunord_ps(absf, absf); // is this a NaN? + b_isregular = _mm_cmpgt_epi32(f16max, absf_int); // (sub)normalized or special? + nanbit = _mm_and_si128(_mm_castps_si128(b_isnan), c_nanbit); + inf_or_nan = _mm_or_si128(nanbit, STBIR__CONSTI(c_infty_as_fp16)); // output for specials + + b_issub = _mm_cmpgt_epi32(min_normal, absf_int); + + // "result is subnormal" path + subnorm1 = _mm_add_ps(absf, _mm_castsi128_ps(STBIR__CONSTI(c_subnorm_magic))); // magic value to round output mantissa + subnorm2 = _mm_sub_epi32(_mm_castps_si128(subnorm1), STBIR__CONSTI(c_subnorm_magic)); // subtract out bias + + // "result is normal" path + mantoddbit = _mm_slli_epi32(absf_int, 31 - 13); // shift bit 13 (mantissa LSB) to sign + mantodd = _mm_srai_epi32(mantoddbit, 31); // -1 if FP16 mantissa odd, else 0 + + round1 = _mm_add_epi32(absf_int, STBIR__CONSTI(c_normal_bias)); + round2 = _mm_sub_epi32(round1, mantodd); // if mantissa LSB odd, bias towards rounding up (RTNE) + normal = _mm_srli_epi32(round2, 13); // rounded result + + // combine the two non-specials + nonspecial = _mm_or_si128(_mm_and_si128(subnorm2, b_issub), _mm_andnot_si128(b_issub, normal)); + + // merge in specials as well + joined = _mm_or_si128(_mm_and_si128(nonspecial, b_isregular), _mm_andnot_si128(b_isregular, inf_or_nan)); + + sign_shift = _mm_srai_epi32(_mm_castps_si128(justsign), 16); + final2 = _mm_or_si128(joined, sign_shift); + final = _mm_packs_epi32(final, final2); + stbir__simdi_store( output,final ); + } + +#elif defined(STBIR_NEON) && defined(_MSC_VER) && defined(_M_ARM64) && !defined(__clang__) // 64-bit ARM on MSVC (not clang) + + static stbir__inline void stbir__half_to_float_SIMD(float * output, stbir__FP16 const * input) + { + float16x4_t in0 = vld1_f16(input + 0); + float16x4_t in1 = vld1_f16(input + 4); + vst1q_f32(output + 0, vcvt_f32_f16(in0)); + vst1q_f32(output + 4, vcvt_f32_f16(in1)); + } + + static stbir__inline void stbir__float_to_half_SIMD(stbir__FP16 * output, float const * input) + { + float16x4_t out0 = vcvt_f16_f32(vld1q_f32(input + 0)); + float16x4_t out1 = vcvt_f16_f32(vld1q_f32(input + 4)); + vst1_f16(output+0, out0); + vst1_f16(output+4, out1); + } + + static stbir__inline float stbir__half_to_float( stbir__FP16 h ) + { + return vgetq_lane_f32(vcvt_f32_f16(vld1_dup_f16(&h)), 0); + } + + static stbir__inline stbir__FP16 stbir__float_to_half( float f ) + { + return vget_lane_f16(vcvt_f16_f32(vdupq_n_f32(f)), 0).n16_u16[0]; + } + +#elif defined(STBIR_NEON) && ( defined( _M_ARM64 ) || defined( __aarch64__ ) || defined( __arm64__ ) ) // 64-bit ARM + + static stbir__inline void stbir__half_to_float_SIMD(float * output, stbir__FP16 const * input) + { + float16x8_t in = vld1q_f16(input); + vst1q_f32(output + 0, vcvt_f32_f16(vget_low_f16(in))); + vst1q_f32(output + 4, vcvt_f32_f16(vget_high_f16(in))); + } + + static stbir__inline void stbir__float_to_half_SIMD(stbir__FP16 * output, float const * input) + { + float16x4_t out0 = vcvt_f16_f32(vld1q_f32(input + 0)); + float16x4_t out1 = vcvt_f16_f32(vld1q_f32(input + 4)); + vst1q_f16(output, vcombine_f16(out0, out1)); + } + + static stbir__inline float stbir__half_to_float( stbir__FP16 h ) + { + return vgetq_lane_f32(vcvt_f32_f16(vdup_n_f16(h)), 0); + } + + static stbir__inline stbir__FP16 stbir__float_to_half( float f ) + { + return vget_lane_f16(vcvt_f16_f32(vdupq_n_f32(f)), 0); + } + +#elif defined(STBIR_WASM) || (defined(STBIR_NEON) && (defined(_MSC_VER) || defined(_M_ARM) || defined(__arm__))) // WASM or 32-bit ARM on MSVC/clang + + static stbir__inline void stbir__half_to_float_SIMD(float * output, stbir__FP16 const * input) + { + for (int i=0; i<8; i++) + { + output[i] = stbir__half_to_float(input[i]); + } + } + static stbir__inline void stbir__float_to_half_SIMD(stbir__FP16 * output, float const * input) + { + for (int i=0; i<8; i++) + { + output[i] = stbir__float_to_half(input[i]); + } + } + +#endif + + +#ifdef STBIR_SIMD + +#define stbir__simdf_0123to3333( out, reg ) (out) = stbir__simdf_swiz( reg, 3,3,3,3 ) +#define stbir__simdf_0123to2222( out, reg ) (out) = stbir__simdf_swiz( reg, 2,2,2,2 ) +#define stbir__simdf_0123to1111( out, reg ) (out) = stbir__simdf_swiz( reg, 1,1,1,1 ) +#define stbir__simdf_0123to0000( out, reg ) (out) = stbir__simdf_swiz( reg, 0,0,0,0 ) +#define stbir__simdf_0123to0003( out, reg ) (out) = stbir__simdf_swiz( reg, 0,0,0,3 ) +#define stbir__simdf_0123to0001( out, reg ) (out) = stbir__simdf_swiz( reg, 0,0,0,1 ) +#define stbir__simdf_0123to1122( out, reg ) (out) = stbir__simdf_swiz( reg, 1,1,2,2 ) +#define stbir__simdf_0123to2333( out, reg ) (out) = stbir__simdf_swiz( reg, 2,3,3,3 ) +#define stbir__simdf_0123to0023( out, reg ) (out) = stbir__simdf_swiz( reg, 0,0,2,3 ) +#define stbir__simdf_0123to1230( out, reg ) (out) = stbir__simdf_swiz( reg, 1,2,3,0 ) +#define stbir__simdf_0123to2103( out, reg ) (out) = stbir__simdf_swiz( reg, 2,1,0,3 ) +#define stbir__simdf_0123to3210( out, reg ) (out) = stbir__simdf_swiz( reg, 3,2,1,0 ) +#define stbir__simdf_0123to2301( out, reg ) (out) = stbir__simdf_swiz( reg, 2,3,0,1 ) +#define stbir__simdf_0123to3012( out, reg ) (out) = stbir__simdf_swiz( reg, 3,0,1,2 ) +#define stbir__simdf_0123to0011( out, reg ) (out) = stbir__simdf_swiz( reg, 0,0,1,1 ) +#define stbir__simdf_0123to1100( out, reg ) (out) = stbir__simdf_swiz( reg, 1,1,0,0 ) +#define stbir__simdf_0123to2233( out, reg ) (out) = stbir__simdf_swiz( reg, 2,2,3,3 ) +#define stbir__simdf_0123to1133( out, reg ) (out) = stbir__simdf_swiz( reg, 1,1,3,3 ) +#define stbir__simdf_0123to0022( out, reg ) (out) = stbir__simdf_swiz( reg, 0,0,2,2 ) +#define stbir__simdf_0123to1032( out, reg ) (out) = stbir__simdf_swiz( reg, 1,0,3,2 ) + +typedef union stbir__simdi_u32 +{ + stbir_uint32 m128i_u32[4]; + int m128i_i32[4]; + stbir__simdi m128i_i128; +} stbir__simdi_u32; + +static const int STBIR_mask[9] = { 0,0,0,-1,-1,-1,0,0,0 }; + +static const STBIR__SIMDF_CONST(STBIR_max_uint8_as_float, stbir__max_uint8_as_float); +static const STBIR__SIMDF_CONST(STBIR_max_uint16_as_float, stbir__max_uint16_as_float); +static const STBIR__SIMDF_CONST(STBIR_max_uint8_as_float_inverted, stbir__max_uint8_as_float_inverted); +static const STBIR__SIMDF_CONST(STBIR_max_uint16_as_float_inverted, stbir__max_uint16_as_float_inverted); + +static const STBIR__SIMDF_CONST(STBIR_simd_point5, 0.5f); +static const STBIR__SIMDF_CONST(STBIR_ones, 1.0f); +static const STBIR__SIMDI_CONST(STBIR_almost_zero, (127 - 13) << 23); +static const STBIR__SIMDI_CONST(STBIR_almost_one, 0x3f7fffff); +static const STBIR__SIMDI_CONST(STBIR_mantissa_mask, 0xff); +static const STBIR__SIMDI_CONST(STBIR_topscale, 0x02000000); + +// Basically, in simd mode, we unroll the proper amount, and we don't want +// the non-simd remnant loops to be unroll because they only run a few times +// Adding this switch saves about 5K on clang which is Captain Unroll the 3rd. +#define STBIR_SIMD_STREAMOUT_PTR( star ) STBIR_STREAMOUT_PTR( star ) +#define STBIR_SIMD_NO_UNROLL(ptr) STBIR_NO_UNROLL(ptr) +#define STBIR_SIMD_NO_UNROLL_LOOP_START STBIR_NO_UNROLL_LOOP_START +#define STBIR_SIMD_NO_UNROLL_LOOP_START_INF_FOR STBIR_NO_UNROLL_LOOP_START_INF_FOR + +#ifdef STBIR_MEMCPY +#undef STBIR_MEMCPY +#endif +#define STBIR_MEMCPY stbir_simd_memcpy + +// override normal use of memcpy with much simpler copy (faster and smaller with our sized copies) +static void stbir_simd_memcpy( void * dest, void const * src, size_t bytes ) +{ + char STBIR_SIMD_STREAMOUT_PTR (*) d = (char*) dest; + char STBIR_SIMD_STREAMOUT_PTR( * ) d_end = ((char*) dest) + bytes; + ptrdiff_t ofs_to_src = (char*)src - (char*)dest; + + // check overlaps + STBIR_ASSERT( ( ( d >= ( (char*)src) + bytes ) ) || ( ( d + bytes ) <= (char*)src ) ); + + if ( bytes < (16*stbir__simdfX_float_count) ) + { + if ( bytes < 16 ) + { + if ( bytes ) + { + STBIR_SIMD_NO_UNROLL_LOOP_START + do + { + STBIR_SIMD_NO_UNROLL(d); + d[ 0 ] = d[ ofs_to_src ]; + ++d; + } while ( d < d_end ); + } + } + else + { + stbir__simdf x; + // do one unaligned to get us aligned for the stream out below + stbir__simdf_load( x, ( d + ofs_to_src ) ); + stbir__simdf_store( d, x ); + d = (char*)( ( ( (size_t)d ) + 16 ) & ~15 ); + + STBIR_SIMD_NO_UNROLL_LOOP_START_INF_FOR + for(;;) + { + STBIR_SIMD_NO_UNROLL(d); + + if ( d > ( d_end - 16 ) ) + { + if ( d == d_end ) + return; + d = d_end - 16; + } + + stbir__simdf_load( x, ( d + ofs_to_src ) ); + stbir__simdf_store( d, x ); + d += 16; + } + } + } + else + { + stbir__simdfX x0,x1,x2,x3; + + // do one unaligned to get us aligned for the stream out below + stbir__simdfX_load( x0, ( d + ofs_to_src ) + 0*stbir__simdfX_float_count ); + stbir__simdfX_load( x1, ( d + ofs_to_src ) + 4*stbir__simdfX_float_count ); + stbir__simdfX_load( x2, ( d + ofs_to_src ) + 8*stbir__simdfX_float_count ); + stbir__simdfX_load( x3, ( d + ofs_to_src ) + 12*stbir__simdfX_float_count ); + stbir__simdfX_store( d + 0*stbir__simdfX_float_count, x0 ); + stbir__simdfX_store( d + 4*stbir__simdfX_float_count, x1 ); + stbir__simdfX_store( d + 8*stbir__simdfX_float_count, x2 ); + stbir__simdfX_store( d + 12*stbir__simdfX_float_count, x3 ); + d = (char*)( ( ( (size_t)d ) + (16*stbir__simdfX_float_count) ) & ~((16*stbir__simdfX_float_count)-1) ); + + STBIR_SIMD_NO_UNROLL_LOOP_START_INF_FOR + for(;;) + { + STBIR_SIMD_NO_UNROLL(d); + + if ( d > ( d_end - (16*stbir__simdfX_float_count) ) ) + { + if ( d == d_end ) + return; + d = d_end - (16*stbir__simdfX_float_count); + } + + stbir__simdfX_load( x0, ( d + ofs_to_src ) + 0*stbir__simdfX_float_count ); + stbir__simdfX_load( x1, ( d + ofs_to_src ) + 4*stbir__simdfX_float_count ); + stbir__simdfX_load( x2, ( d + ofs_to_src ) + 8*stbir__simdfX_float_count ); + stbir__simdfX_load( x3, ( d + ofs_to_src ) + 12*stbir__simdfX_float_count ); + stbir__simdfX_store( d + 0*stbir__simdfX_float_count, x0 ); + stbir__simdfX_store( d + 4*stbir__simdfX_float_count, x1 ); + stbir__simdfX_store( d + 8*stbir__simdfX_float_count, x2 ); + stbir__simdfX_store( d + 12*stbir__simdfX_float_count, x3 ); + d += (16*stbir__simdfX_float_count); + } + } +} + +// memcpy that is specically intentionally overlapping (src is smaller then dest, so can be +// a normal forward copy, bytes is divisible by 4 and bytes is greater than or equal to +// the diff between dest and src) +static void stbir_overlapping_memcpy( void * dest, void const * src, size_t bytes ) +{ + char STBIR_SIMD_STREAMOUT_PTR (*) sd = (char*) src; + char STBIR_SIMD_STREAMOUT_PTR( * ) s_end = ((char*) src) + bytes; + ptrdiff_t ofs_to_dest = (char*)dest - (char*)src; + + if ( ofs_to_dest >= 16 ) // is the overlap more than 16 away? + { + char STBIR_SIMD_STREAMOUT_PTR( * ) s_end16 = ((char*) src) + (bytes&~15); + STBIR_SIMD_NO_UNROLL_LOOP_START + do + { + stbir__simdf x; + STBIR_SIMD_NO_UNROLL(sd); + stbir__simdf_load( x, sd ); + stbir__simdf_store( ( sd + ofs_to_dest ), x ); + sd += 16; + } while ( sd < s_end16 ); + + if ( sd == s_end ) + return; + } + + do + { + STBIR_SIMD_NO_UNROLL(sd); + *(int*)( sd + ofs_to_dest ) = *(int*) sd; + sd += 4; + } while ( sd < s_end ); +} + +#else // no SSE2 + +// when in scalar mode, we let unrolling happen, so this macro just does the __restrict +#define STBIR_SIMD_STREAMOUT_PTR( star ) STBIR_STREAMOUT_PTR( star ) +#define STBIR_SIMD_NO_UNROLL(ptr) +#define STBIR_SIMD_NO_UNROLL_LOOP_START +#define STBIR_SIMD_NO_UNROLL_LOOP_START_INF_FOR + +#endif // SSE2 + + +#ifdef STBIR_PROFILE + +#ifndef STBIR_PROFILE_FUNC + +#if defined(_x86_64) || defined( __x86_64__ ) || defined( _M_X64 ) || defined(__x86_64) || defined(__SSE2__) || defined(STBIR_SSE) || defined( _M_IX86_FP ) || defined(__i386) || defined( __i386__ ) || defined( _M_IX86 ) || defined( _X86_ ) + +#ifdef _MSC_VER + + STBIRDEF stbir_uint64 __rdtsc(); + #define STBIR_PROFILE_FUNC() __rdtsc() + +#else // non msvc + + static stbir__inline stbir_uint64 STBIR_PROFILE_FUNC() + { + stbir_uint32 lo, hi; + asm volatile ("rdtsc" : "=a" (lo), "=d" (hi) ); + return ( ( (stbir_uint64) hi ) << 32 ) | ( (stbir_uint64) lo ); + } + +#endif // msvc + +#elif defined( _M_ARM64 ) || defined( __aarch64__ ) || defined( __arm64__ ) || defined(__ARM_NEON__) + +#if defined( _MSC_VER ) && !defined(__clang__) + + #define STBIR_PROFILE_FUNC() _ReadStatusReg(ARM64_CNTVCT) + +#else + + static stbir__inline stbir_uint64 STBIR_PROFILE_FUNC() + { + stbir_uint64 tsc; + asm volatile("mrs %0, cntvct_el0" : "=r" (tsc)); + return tsc; + } + +#endif + +#else // x64, arm + +#error Unknown platform for profiling. + +#endif // x64, arm + +#endif // STBIR_PROFILE_FUNC + +#define STBIR_ONLY_PROFILE_GET_SPLIT_INFO ,stbir__per_split_info * split_info +#define STBIR_ONLY_PROFILE_SET_SPLIT_INFO ,split_info + +#define STBIR_ONLY_PROFILE_BUILD_GET_INFO ,stbir__info * profile_info +#define STBIR_ONLY_PROFILE_BUILD_SET_INFO ,profile_info + +// super light-weight micro profiler +#define STBIR_PROFILE_START_ll( info, wh ) { stbir_uint64 wh##thiszonetime = STBIR_PROFILE_FUNC(); stbir_uint64 * wh##save_parent_excluded_ptr = info->current_zone_excluded_ptr; stbir_uint64 wh##current_zone_excluded = 0; info->current_zone_excluded_ptr = &wh##current_zone_excluded; +#define STBIR_PROFILE_END_ll( info, wh ) wh##thiszonetime = STBIR_PROFILE_FUNC() - wh##thiszonetime; info->profile.named.wh += wh##thiszonetime - wh##current_zone_excluded; *wh##save_parent_excluded_ptr += wh##thiszonetime; info->current_zone_excluded_ptr = wh##save_parent_excluded_ptr; } +#define STBIR_PROFILE_FIRST_START_ll( info, wh ) { int i; info->current_zone_excluded_ptr = &info->profile.named.total; for(i=0;iprofile.array);i++) info->profile.array[i]=0; } STBIR_PROFILE_START_ll( info, wh ); +#define STBIR_PROFILE_CLEAR_EXTRAS_ll( info, num ) { int extra; for(extra=1;extra<(num);extra++) { int i; for(i=0;iprofile.array);i++) (info)[extra].profile.array[i]=0; } } + +// for thread data +#define STBIR_PROFILE_START( wh ) STBIR_PROFILE_START_ll( split_info, wh ) +#define STBIR_PROFILE_END( wh ) STBIR_PROFILE_END_ll( split_info, wh ) +#define STBIR_PROFILE_FIRST_START( wh ) STBIR_PROFILE_FIRST_START_ll( split_info, wh ) +#define STBIR_PROFILE_CLEAR_EXTRAS() STBIR_PROFILE_CLEAR_EXTRAS_ll( split_info, split_count ) + +// for build data +#define STBIR_PROFILE_BUILD_START( wh ) STBIR_PROFILE_START_ll( profile_info, wh ) +#define STBIR_PROFILE_BUILD_END( wh ) STBIR_PROFILE_END_ll( profile_info, wh ) +#define STBIR_PROFILE_BUILD_FIRST_START( wh ) STBIR_PROFILE_FIRST_START_ll( profile_info, wh ) +#define STBIR_PROFILE_BUILD_CLEAR( info ) { int i; for(i=0;iprofile.array);i++) info->profile.array[i]=0; } + +#else // no profile + +#define STBIR_ONLY_PROFILE_GET_SPLIT_INFO +#define STBIR_ONLY_PROFILE_SET_SPLIT_INFO + +#define STBIR_ONLY_PROFILE_BUILD_GET_INFO +#define STBIR_ONLY_PROFILE_BUILD_SET_INFO + +#define STBIR_PROFILE_START( wh ) +#define STBIR_PROFILE_END( wh ) +#define STBIR_PROFILE_FIRST_START( wh ) +#define STBIR_PROFILE_CLEAR_EXTRAS( ) + +#define STBIR_PROFILE_BUILD_START( wh ) +#define STBIR_PROFILE_BUILD_END( wh ) +#define STBIR_PROFILE_BUILD_FIRST_START( wh ) +#define STBIR_PROFILE_BUILD_CLEAR( info ) + +#endif // stbir_profile + +#ifndef STBIR_CEILF +#include +#if _MSC_VER <= 1200 // support VC6 for Sean +#define STBIR_CEILF(x) ((float)ceil((float)(x))) +#define STBIR_FLOORF(x) ((float)floor((float)(x))) +#else +#define STBIR_CEILF(x) ceilf(x) +#define STBIR_FLOORF(x) floorf(x) +#endif +#endif + +#ifndef STBIR_MEMCPY +// For memcpy +#include +#define STBIR_MEMCPY( dest, src, len ) memcpy( dest, src, len ) +#endif + +#ifndef STBIR_SIMD + +// memcpy that is specifically intentionally overlapping (src is smaller then dest, so can be +// a normal forward copy, bytes is divisible by 4 and bytes is greater than or equal to +// the diff between dest and src) +static void stbir_overlapping_memcpy( void * dest, void const * src, size_t bytes ) +{ + char STBIR_SIMD_STREAMOUT_PTR (*) sd = (char*) src; + char STBIR_SIMD_STREAMOUT_PTR( * ) s_end = ((char*) src) + bytes; + ptrdiff_t ofs_to_dest = (char*)dest - (char*)src; + + if ( ofs_to_dest >= 8 ) // is the overlap more than 8 away + { + char STBIR_SIMD_STREAMOUT_PTR( * ) s_end8 = ((char*) src) + (bytes&~7); + + if ( ( ( ((ptrdiff_t)dest)|((ptrdiff_t)src) ) & 7 ) == 0 ) // is it 8byte aligned? + { + STBIR_NO_UNROLL_LOOP_START + do + { + STBIR_NO_UNROLL(sd); + *(stbir_uint64*)( sd + ofs_to_dest ) = *(stbir_uint64*) sd; + sd += 8; + } while ( sd < s_end8 ); + } + else + { + STBIR_NO_UNROLL_LOOP_START + do + { + int a,b; + STBIR_NO_UNROLL(sd); + a = ((int*)sd)[0]; + b = ((int*)sd)[1]; + ((int*)( sd + ofs_to_dest ))[0] = a; + ((int*)( sd + ofs_to_dest ))[1] = b; + sd += 8; + } while ( sd < s_end8 ); + } + + if ( sd == s_end ) + return; + } + + STBIR_NO_UNROLL_LOOP_START + do + { + STBIR_NO_UNROLL(sd); + *(int*)( sd + ofs_to_dest ) = *(int*) sd; + sd += 4; + } while ( sd < s_end ); +} + +#endif + +static float stbir__filter_trapezoid(float x, float scale, void * user_data) +{ + float halfscale = scale / 2; + float t = 0.5f + halfscale; + STBIR_ASSERT(scale <= 1); + STBIR__UNUSED(user_data); + + if ( x < 0.0f ) x = -x; + + if (x >= t) + return 0.0f; + else + { + float r = 0.5f - halfscale; + if (x <= r) + return 1.0f; + else + return (t - x) / scale; + } +} + +static float stbir__support_trapezoid(float scale, void * user_data) +{ + STBIR__UNUSED(user_data); + return 0.5f + scale / 2.0f; +} + +static float stbir__filter_triangle(float x, float s, void * user_data) +{ + STBIR__UNUSED(s); + STBIR__UNUSED(user_data); + + if ( x < 0.0f ) x = -x; + + if (x <= 1.0f) + return 1.0f - x; + else + return 0.0f; +} + +static float stbir__filter_point(float x, float s, void * user_data) +{ + STBIR__UNUSED(x); + STBIR__UNUSED(s); + STBIR__UNUSED(user_data); + + return 1.0f; +} + +static float stbir__filter_cubic(float x, float s, void * user_data) +{ + STBIR__UNUSED(s); + STBIR__UNUSED(user_data); + + if ( x < 0.0f ) x = -x; + + if (x < 1.0f) + return (4.0f + x*x*(3.0f*x - 6.0f))/6.0f; + else if (x < 2.0f) + return (8.0f + x*(-12.0f + x*(6.0f - x)))/6.0f; + + return (0.0f); +} + +static float stbir__filter_catmullrom(float x, float s, void * user_data) +{ + STBIR__UNUSED(s); + STBIR__UNUSED(user_data); + + if ( x < 0.0f ) x = -x; + + if (x < 1.0f) + return 1.0f - x*x*(2.5f - 1.5f*x); + else if (x < 2.0f) + return 2.0f - x*(4.0f + x*(0.5f*x - 2.5f)); + + return (0.0f); +} + +static float stbir__filter_mitchell(float x, float s, void * user_data) +{ + STBIR__UNUSED(s); + STBIR__UNUSED(user_data); + + if ( x < 0.0f ) x = -x; + + if (x < 1.0f) + return (16.0f + x*x*(21.0f * x - 36.0f))/18.0f; + else if (x < 2.0f) + return (32.0f + x*(-60.0f + x*(36.0f - 7.0f*x)))/18.0f; + + return (0.0f); +} + +static float stbir__support_zeropoint5(float s, void * user_data) +{ + STBIR__UNUSED(s); + STBIR__UNUSED(user_data); + return 0.5f; +} + +static float stbir__support_one(float s, void * user_data) +{ + STBIR__UNUSED(s); + STBIR__UNUSED(user_data); + return 1; +} + +static float stbir__support_two(float s, void * user_data) +{ + STBIR__UNUSED(s); + STBIR__UNUSED(user_data); + return 2; +} + +// This is the maximum number of input samples that can affect an output sample +// with the given filter from the output pixel's perspective +static int stbir__get_filter_pixel_width(stbir__support_callback * support, float scale, void * user_data) +{ + STBIR_ASSERT(support != 0); + + if ( scale >= ( 1.0f-stbir__small_float ) ) // upscale + return (int)STBIR_CEILF(support(1.0f/scale,user_data) * 2.0f); + else + return (int)STBIR_CEILF(support(scale,user_data) * 2.0f / scale); +} + +// this is how many coefficents per run of the filter (which is different +// from the filter_pixel_width depending on if we are scattering or gathering) +static int stbir__get_coefficient_width(stbir__sampler * samp, int is_gather, void * user_data) +{ + float scale = samp->scale_info.scale; + stbir__support_callback * support = samp->filter_support; + + switch( is_gather ) + { + case 1: + return (int)STBIR_CEILF(support(1.0f / scale, user_data) * 2.0f); + case 2: + return (int)STBIR_CEILF(support(scale, user_data) * 2.0f / scale); + case 0: + return (int)STBIR_CEILF(support(scale, user_data) * 2.0f); + default: + STBIR_ASSERT( (is_gather >= 0 ) && (is_gather <= 2 ) ); + return 0; + } +} + +static int stbir__get_contributors(stbir__sampler * samp, int is_gather) +{ + if (is_gather) + return samp->scale_info.output_sub_size; + else + return (samp->scale_info.input_full_size + samp->filter_pixel_margin * 2); +} + +static int stbir__edge_zero_full( int n, int max ) +{ + STBIR__UNUSED(n); + STBIR__UNUSED(max); + return 0; // NOTREACHED +} + +static int stbir__edge_clamp_full( int n, int max ) +{ + if (n < 0) + return 0; + + if (n >= max) + return max - 1; + + return n; // NOTREACHED +} + +static int stbir__edge_reflect_full( int n, int max ) +{ + if (n < 0) + { + if (n > -max) + return -n; + else + return max - 1; + } + + if (n >= max) + { + int max2 = max * 2; + if (n >= max2) + return 0; + else + return max2 - n - 1; + } + + return n; // NOTREACHED +} + +static int stbir__edge_wrap_full( int n, int max ) +{ + if (n >= 0) + return (n % max); + else + { + int m = (-n) % max; + + if (m != 0) + m = max - m; + + return (m); + } +} + +typedef int stbir__edge_wrap_func( int n, int max ); +static stbir__edge_wrap_func * stbir__edge_wrap_slow[] = +{ + stbir__edge_clamp_full, // STBIR_EDGE_CLAMP + stbir__edge_reflect_full, // STBIR_EDGE_REFLECT + stbir__edge_wrap_full, // STBIR_EDGE_WRAP + stbir__edge_zero_full, // STBIR_EDGE_ZERO +}; + +stbir__inline static int stbir__edge_wrap(stbir_edge edge, int n, int max) +{ + // avoid per-pixel switch + if (n >= 0 && n < max) + return n; + return stbir__edge_wrap_slow[edge]( n, max ); +} + +#define STBIR__MERGE_RUNS_PIXEL_THRESHOLD 16 + +// get information on the extents of a sampler +static void stbir__get_extents( stbir__sampler * samp, stbir__extents * scanline_extents ) +{ + int j, stop; + int left_margin, right_margin; + int min_n = 0x7fffffff, max_n = -0x7fffffff; + int min_left = 0x7fffffff, max_left = -0x7fffffff; + int min_right = 0x7fffffff, max_right = -0x7fffffff; + stbir_edge edge = samp->edge; + stbir__contributors* contributors = samp->contributors; + int output_sub_size = samp->scale_info.output_sub_size; + int input_full_size = samp->scale_info.input_full_size; + int filter_pixel_margin = samp->filter_pixel_margin; + + STBIR_ASSERT( samp->is_gather ); + + stop = output_sub_size; + for (j = 0; j < stop; j++ ) + { + STBIR_ASSERT( contributors[j].n1 >= contributors[j].n0 ); + if ( contributors[j].n0 < min_n ) + { + min_n = contributors[j].n0; + stop = j + filter_pixel_margin; // if we find a new min, only scan another filter width + if ( stop > output_sub_size ) stop = output_sub_size; + } + } + + stop = 0; + for (j = output_sub_size - 1; j >= stop; j-- ) + { + STBIR_ASSERT( contributors[j].n1 >= contributors[j].n0 ); + if ( contributors[j].n1 > max_n ) + { + max_n = contributors[j].n1; + stop = j - filter_pixel_margin; // if we find a new max, only scan another filter width + if (stop<0) stop = 0; + } + } + + STBIR_ASSERT( scanline_extents->conservative.n0 <= min_n ); + STBIR_ASSERT( scanline_extents->conservative.n1 >= max_n ); + + // now calculate how much into the margins we really read + left_margin = 0; + if ( min_n < 0 ) + { + left_margin = -min_n; + min_n = 0; + } + + right_margin = 0; + if ( max_n >= input_full_size ) + { + right_margin = max_n - input_full_size + 1; + max_n = input_full_size - 1; + } + + // index 1 is margin pixel extents (how many pixels we hang over the edge) + scanline_extents->edge_sizes[0] = left_margin; + scanline_extents->edge_sizes[1] = right_margin; + + // index 2 is pixels read from the input + scanline_extents->spans[0].n0 = min_n; + scanline_extents->spans[0].n1 = max_n; + scanline_extents->spans[0].pixel_offset_for_input = min_n; + + // default to no other input range + scanline_extents->spans[1].n0 = 0; + scanline_extents->spans[1].n1 = -1; + scanline_extents->spans[1].pixel_offset_for_input = 0; + + // don't have to do edge calc for zero clamp + if ( edge == STBIR_EDGE_ZERO ) + return; + + // convert margin pixels to the pixels within the input (min and max) + for( j = -left_margin ; j < 0 ; j++ ) + { + int p = stbir__edge_wrap( edge, j, input_full_size ); + if ( p < min_left ) + min_left = p; + if ( p > max_left ) + max_left = p; + } + + for( j = input_full_size ; j < (input_full_size + right_margin) ; j++ ) + { + int p = stbir__edge_wrap( edge, j, input_full_size ); + if ( p < min_right ) + min_right = p; + if ( p > max_right ) + max_right = p; + } + + // merge the left margin pixel region if it connects within 4 pixels of main pixel region + if ( min_left != 0x7fffffff ) + { + if ( ( ( min_left <= min_n ) && ( ( max_left + STBIR__MERGE_RUNS_PIXEL_THRESHOLD ) >= min_n ) ) || + ( ( min_n <= min_left ) && ( ( max_n + STBIR__MERGE_RUNS_PIXEL_THRESHOLD ) >= max_left ) ) ) + { + scanline_extents->spans[0].n0 = min_n = stbir__min( min_n, min_left ); + scanline_extents->spans[0].n1 = max_n = stbir__max( max_n, max_left ); + scanline_extents->spans[0].pixel_offset_for_input = min_n; + left_margin = 0; + } + } + + // merge the right margin pixel region if it connects within 4 pixels of main pixel region + if ( min_right != 0x7fffffff ) + { + if ( ( ( min_right <= min_n ) && ( ( max_right + STBIR__MERGE_RUNS_PIXEL_THRESHOLD ) >= min_n ) ) || + ( ( min_n <= min_right ) && ( ( max_n + STBIR__MERGE_RUNS_PIXEL_THRESHOLD ) >= max_right ) ) ) + { + scanline_extents->spans[0].n0 = min_n = stbir__min( min_n, min_right ); + scanline_extents->spans[0].n1 = max_n = stbir__max( max_n, max_right ); + scanline_extents->spans[0].pixel_offset_for_input = min_n; + right_margin = 0; + } + } + + STBIR_ASSERT( scanline_extents->conservative.n0 <= min_n ); + STBIR_ASSERT( scanline_extents->conservative.n1 >= max_n ); + + // you get two ranges when you have the WRAP edge mode and you are doing just the a piece of the resize + // so you need to get a second run of pixels from the opposite side of the scanline (which you + // wouldn't need except for WRAP) + + + // if we can't merge the min_left range, add it as a second range + if ( ( left_margin ) && ( min_left != 0x7fffffff ) ) + { + stbir__span * newspan = scanline_extents->spans + 1; + STBIR_ASSERT( right_margin == 0 ); + if ( min_left < scanline_extents->spans[0].n0 ) + { + scanline_extents->spans[1].pixel_offset_for_input = scanline_extents->spans[0].n0; + scanline_extents->spans[1].n0 = scanline_extents->spans[0].n0; + scanline_extents->spans[1].n1 = scanline_extents->spans[0].n1; + --newspan; + } + newspan->pixel_offset_for_input = min_left; + newspan->n0 = -left_margin; + newspan->n1 = ( max_left - min_left ) - left_margin; + scanline_extents->edge_sizes[0] = 0; // don't need to copy the left margin, since we are directly decoding into the margin + } + // if we can't merge the min_right range, add it as a second range + else + if ( ( right_margin ) && ( min_right != 0x7fffffff ) ) + { + stbir__span * newspan = scanline_extents->spans + 1; + if ( min_right < scanline_extents->spans[0].n0 ) + { + scanline_extents->spans[1].pixel_offset_for_input = scanline_extents->spans[0].n0; + scanline_extents->spans[1].n0 = scanline_extents->spans[0].n0; + scanline_extents->spans[1].n1 = scanline_extents->spans[0].n1; + --newspan; + } + newspan->pixel_offset_for_input = min_right; + newspan->n0 = scanline_extents->spans[1].n1 + 1; + newspan->n1 = scanline_extents->spans[1].n1 + 1 + ( max_right - min_right ); + scanline_extents->edge_sizes[1] = 0; // don't need to copy the right margin, since we are directly decoding into the margin + } + + // sort the spans into write output order + if ( ( scanline_extents->spans[1].n1 > scanline_extents->spans[1].n0 ) && ( scanline_extents->spans[0].n0 > scanline_extents->spans[1].n0 ) ) + { + stbir__span tspan = scanline_extents->spans[0]; + scanline_extents->spans[0] = scanline_extents->spans[1]; + scanline_extents->spans[1] = tspan; + } +} + +static void stbir__calculate_in_pixel_range( int * first_pixel, int * last_pixel, float out_pixel_center, float out_filter_radius, float inv_scale, float out_shift, int input_size, stbir_edge edge ) +{ + int first, last; + float out_pixel_influence_lowerbound = out_pixel_center - out_filter_radius; + float out_pixel_influence_upperbound = out_pixel_center + out_filter_radius; + + float in_pixel_influence_lowerbound = (out_pixel_influence_lowerbound + out_shift) * inv_scale; + float in_pixel_influence_upperbound = (out_pixel_influence_upperbound + out_shift) * inv_scale; + + first = (int)(STBIR_FLOORF(in_pixel_influence_lowerbound + 0.5f)); + last = (int)(STBIR_FLOORF(in_pixel_influence_upperbound - 0.5f)); + if ( last < first ) last = first; // point sample mode can span a value *right* at 0.5, and cause these to cross + + if ( edge == STBIR_EDGE_WRAP ) + { + if ( first < -input_size ) + first = -input_size; + if ( last >= (input_size*2)) + last = (input_size*2) - 1; + } + + *first_pixel = first; + *last_pixel = last; +} + +static void stbir__calculate_coefficients_for_gather_upsample( float out_filter_radius, stbir__kernel_callback * kernel, stbir__scale_info * scale_info, int num_contributors, stbir__contributors* contributors, float* coefficient_group, int coefficient_width, stbir_edge edge, void * user_data ) +{ + int n, end; + float inv_scale = scale_info->inv_scale; + float out_shift = scale_info->pixel_shift; + int input_size = scale_info->input_full_size; + int numerator = scale_info->scale_numerator; + int polyphase = ( ( scale_info->scale_is_rational ) && ( numerator < num_contributors ) ); + + // Looping through out pixels + end = num_contributors; if ( polyphase ) end = numerator; + for (n = 0; n < end; n++) + { + int i; + int last_non_zero; + float out_pixel_center = (float)n + 0.5f; + float in_center_of_out = (out_pixel_center + out_shift) * inv_scale; + + int in_first_pixel, in_last_pixel; + + stbir__calculate_in_pixel_range( &in_first_pixel, &in_last_pixel, out_pixel_center, out_filter_radius, inv_scale, out_shift, input_size, edge ); + + // make sure we never generate a range larger than our precalculated coeff width + // this only happens in point sample mode, but it's a good safe thing to do anyway + if ( ( in_last_pixel - in_first_pixel + 1 ) > coefficient_width ) + in_last_pixel = in_first_pixel + coefficient_width - 1; + + last_non_zero = -1; + for (i = 0; i <= in_last_pixel - in_first_pixel; i++) + { + float in_pixel_center = (float)(i + in_first_pixel) + 0.5f; + float coeff = kernel(in_center_of_out - in_pixel_center, inv_scale, user_data); + + // kill denormals + if ( ( ( coeff < stbir__small_float ) && ( coeff > -stbir__small_float ) ) ) + { + if ( i == 0 ) // if we're at the front, just eat zero contributors + { + STBIR_ASSERT ( ( in_last_pixel - in_first_pixel ) != 0 ); // there should be at least one contrib + ++in_first_pixel; + i--; + continue; + } + coeff = 0; // make sure is fully zero (should keep denormals away) + } + else + last_non_zero = i; + + coefficient_group[i] = coeff; + } + + in_last_pixel = last_non_zero+in_first_pixel; // kills trailing zeros + contributors->n0 = in_first_pixel; + contributors->n1 = in_last_pixel; + + STBIR_ASSERT(contributors->n1 >= contributors->n0); + + ++contributors; + coefficient_group += coefficient_width; + } +} + +static void stbir__insert_coeff( stbir__contributors * contribs, float * coeffs, int new_pixel, float new_coeff, int max_width ) +{ + if ( contribs->n1 < contribs->n0 ) // this first clause should never happen, but handle in case + { + contribs->n0 = contribs->n1 = new_pixel; + coeffs[0] = new_coeff; + } + else if ( new_pixel <= contribs->n1 ) // before the end + { + if ( new_pixel < contribs->n0 ) // before the front? + { + if ( ( contribs->n1 - new_pixel + 1 ) <= max_width ) + { + int j, o = contribs->n0 - new_pixel; + for ( j = contribs->n1 - contribs->n0 ; j >= 0 ; j-- ) + coeffs[ j + o ] = coeffs[ j ]; + for ( j = 1 ; j < o ; j++ ) + coeffs[ j ] = 0; + coeffs[ 0 ] = new_coeff; + contribs->n0 = new_pixel; + } + } + else + { + // add new weight to existing coeff if already there + coeffs[ new_pixel - contribs->n0 ] += new_coeff; + } + } + else + { + if ( ( new_pixel - contribs->n0 + 1 ) <= max_width ) + { + int j, e = new_pixel - contribs->n0; + for( j = ( contribs->n1 - contribs->n0 ) + 1 ; j < e ; j++ ) // clear in-betweens coeffs if there are any + coeffs[j] = 0; + + coeffs[ e ] = new_coeff; + contribs->n1 = new_pixel; + } + } +} + +static void stbir__calculate_out_pixel_range( int * first_pixel, int * last_pixel, float in_pixel_center, float in_pixels_radius, float scale, float out_shift, int out_size ) +{ + float in_pixel_influence_lowerbound = in_pixel_center - in_pixels_radius; + float in_pixel_influence_upperbound = in_pixel_center + in_pixels_radius; + float out_pixel_influence_lowerbound = in_pixel_influence_lowerbound * scale - out_shift; + float out_pixel_influence_upperbound = in_pixel_influence_upperbound * scale - out_shift; + int out_first_pixel = (int)(STBIR_FLOORF(out_pixel_influence_lowerbound + 0.5f)); + int out_last_pixel = (int)(STBIR_FLOORF(out_pixel_influence_upperbound - 0.5f)); + + if ( out_first_pixel < 0 ) + out_first_pixel = 0; + if ( out_last_pixel >= out_size ) + out_last_pixel = out_size - 1; + *first_pixel = out_first_pixel; + *last_pixel = out_last_pixel; +} + +static void stbir__calculate_coefficients_for_gather_downsample( int start, int end, float in_pixels_radius, stbir__kernel_callback * kernel, stbir__scale_info * scale_info, int coefficient_width, int num_contributors, stbir__contributors * contributors, float * coefficient_group, void * user_data ) +{ + int in_pixel; + int i; + int first_out_inited = -1; + float scale = scale_info->scale; + float out_shift = scale_info->pixel_shift; + int out_size = scale_info->output_sub_size; + int numerator = scale_info->scale_numerator; + int polyphase = ( ( scale_info->scale_is_rational ) && ( numerator < out_size ) ); + + STBIR__UNUSED(num_contributors); + + // Loop through the input pixels + for (in_pixel = start; in_pixel < end; in_pixel++) + { + float in_pixel_center = (float)in_pixel + 0.5f; + float out_center_of_in = in_pixel_center * scale - out_shift; + int out_first_pixel, out_last_pixel; + + stbir__calculate_out_pixel_range( &out_first_pixel, &out_last_pixel, in_pixel_center, in_pixels_radius, scale, out_shift, out_size ); + + if ( out_first_pixel > out_last_pixel ) + continue; + + // clamp or exit if we are using polyphase filtering, and the limit is up + if ( polyphase ) + { + // when polyphase, you only have to do coeffs up to the numerator count + if ( out_first_pixel == numerator ) + break; + + // don't do any extra work, clamp last pixel at numerator too + if ( out_last_pixel >= numerator ) + out_last_pixel = numerator - 1; + } + + for (i = 0; i <= out_last_pixel - out_first_pixel; i++) + { + float out_pixel_center = (float)(i + out_first_pixel) + 0.5f; + float x = out_pixel_center - out_center_of_in; + float coeff = kernel(x, scale, user_data) * scale; + + // kill the coeff if it's too small (avoid denormals) + if ( ( ( coeff < stbir__small_float ) && ( coeff > -stbir__small_float ) ) ) + coeff = 0.0f; + + { + int out = i + out_first_pixel; + float * coeffs = coefficient_group + out * coefficient_width; + stbir__contributors * contribs = contributors + out; + + // is this the first time this output pixel has been seen? Init it. + if ( out > first_out_inited ) + { + STBIR_ASSERT( out == ( first_out_inited + 1 ) ); // ensure we have only advanced one at time + first_out_inited = out; + contribs->n0 = in_pixel; + contribs->n1 = in_pixel; + coeffs[0] = coeff; + } + else + { + // insert on end (always in order) + if ( coeffs[0] == 0.0f ) // if the first coefficent is zero, then zap it for this coeffs + { + STBIR_ASSERT( ( in_pixel - contribs->n0 ) == 1 ); // ensure that when we zap, we're at the 2nd pos + contribs->n0 = in_pixel; + } + contribs->n1 = in_pixel; + STBIR_ASSERT( ( in_pixel - contribs->n0 ) < coefficient_width ); + coeffs[in_pixel - contribs->n0] = coeff; + } + } + } + } +} + +#ifdef STBIR_RENORMALIZE_IN_FLOAT +#define STBIR_RENORM_TYPE float +#else +#define STBIR_RENORM_TYPE double +#endif + +static void stbir__cleanup_gathered_coefficients( stbir_edge edge, stbir__filter_extent_info* filter_info, stbir__scale_info * scale_info, int num_contributors, stbir__contributors* contributors, float * coefficient_group, int coefficient_width ) +{ + int input_size = scale_info->input_full_size; + int input_last_n1 = input_size - 1; + int n, end; + int lowest = 0x7fffffff; + int highest = -0x7fffffff; + int widest = -1; + int numerator = scale_info->scale_numerator; + int denominator = scale_info->scale_denominator; + int polyphase = ( ( scale_info->scale_is_rational ) && ( numerator < num_contributors ) ); + float * coeffs; + stbir__contributors * contribs; + + // weight all the coeffs for each sample + coeffs = coefficient_group; + contribs = contributors; + end = num_contributors; if ( polyphase ) end = numerator; + for (n = 0; n < end; n++) + { + int i; + STBIR_RENORM_TYPE filter_scale, total_filter = 0; + int e; + + // add all contribs + e = contribs->n1 - contribs->n0; + for( i = 0 ; i <= e ; i++ ) + { + total_filter += (STBIR_RENORM_TYPE) coeffs[i]; + STBIR_ASSERT( ( coeffs[i] >= -2.0f ) && ( coeffs[i] <= 2.0f ) ); // check for wonky weights + } + + // rescale + if ( ( total_filter < stbir__small_float ) && ( total_filter > -stbir__small_float ) ) + { + // all coeffs are extremely small, just zero it + contribs->n1 = contribs->n0; + coeffs[0] = 0.0f; + } + else + { + // if the total isn't 1.0, rescale everything + if ( ( total_filter < (1.0f-stbir__small_float) ) || ( total_filter > (1.0f+stbir__small_float) ) ) + { + filter_scale = ((STBIR_RENORM_TYPE)1.0) / total_filter; + + // scale them all + for (i = 0; i <= e; i++) + coeffs[i] = (float) ( coeffs[i] * filter_scale ); + } + } + ++contribs; + coeffs += coefficient_width; + } + + // if we have a rational for the scale, we can exploit the polyphaseness to not calculate + // most of the coefficients, so we copy them here + if ( polyphase ) + { + stbir__contributors * prev_contribs = contributors; + stbir__contributors * cur_contribs = contributors + numerator; + + for( n = numerator ; n < num_contributors ; n++ ) + { + cur_contribs->n0 = prev_contribs->n0 + denominator; + cur_contribs->n1 = prev_contribs->n1 + denominator; + ++cur_contribs; + ++prev_contribs; + } + stbir_overlapping_memcpy( coefficient_group + numerator * coefficient_width, coefficient_group, ( num_contributors - numerator ) * coefficient_width * sizeof( coeffs[ 0 ] ) ); + } + + coeffs = coefficient_group; + contribs = contributors; + + for (n = 0; n < num_contributors; n++) + { + int i; + + // in zero edge mode, just remove out of bounds contribs completely (since their weights are accounted for now) + if ( edge == STBIR_EDGE_ZERO ) + { + // shrink the right side if necessary + if ( contribs->n1 > input_last_n1 ) + contribs->n1 = input_last_n1; + + // shrink the left side + if ( contribs->n0 < 0 ) + { + int j, left, skips = 0; + + skips = -contribs->n0; + contribs->n0 = 0; + + // now move down the weights + left = contribs->n1 - contribs->n0 + 1; + if ( left > 0 ) + { + for( j = 0 ; j < left ; j++ ) + coeffs[ j ] = coeffs[ j + skips ]; + } + } + } + else if ( ( edge == STBIR_EDGE_CLAMP ) || ( edge == STBIR_EDGE_REFLECT ) ) + { + // for clamp and reflect, calculate the true inbounds position (based on edge type) and just add that to the existing weight + + // right hand side first + if ( contribs->n1 > input_last_n1 ) + { + int start = contribs->n0; + int endi = contribs->n1; + contribs->n1 = input_last_n1; + for( i = input_size; i <= endi; i++ ) + stbir__insert_coeff( contribs, coeffs, stbir__edge_wrap_slow[edge]( i, input_size ), coeffs[i-start], coefficient_width ); + } + + // now check left hand edge + if ( contribs->n0 < 0 ) + { + int save_n0; + float save_n0_coeff; + float * c = coeffs - ( contribs->n0 + 1 ); + + // reinsert the coeffs with it reflected or clamped (insert accumulates, if the coeffs exist) + for( i = -1 ; i > contribs->n0 ; i-- ) + stbir__insert_coeff( contribs, coeffs, stbir__edge_wrap_slow[edge]( i, input_size ), *c--, coefficient_width ); + save_n0 = contribs->n0; + save_n0_coeff = c[0]; // save it, since we didn't do the final one (i==n0), because there might be too many coeffs to hold (before we resize)! + + // now slide all the coeffs down (since we have accumulated them in the positive contribs) and reset the first contrib + contribs->n0 = 0; + for(i = 0 ; i <= contribs->n1 ; i++ ) + coeffs[i] = coeffs[i-save_n0]; + + // now that we have shrunk down the contribs, we insert the first one safely + stbir__insert_coeff( contribs, coeffs, stbir__edge_wrap_slow[edge]( save_n0, input_size ), save_n0_coeff, coefficient_width ); + } + } + + if ( contribs->n0 <= contribs->n1 ) + { + int diff = contribs->n1 - contribs->n0 + 1; + while ( diff && ( coeffs[ diff-1 ] == 0.0f ) ) + --diff; + + contribs->n1 = contribs->n0 + diff - 1; + + if ( contribs->n0 <= contribs->n1 ) + { + if ( contribs->n0 < lowest ) + lowest = contribs->n0; + if ( contribs->n1 > highest ) + highest = contribs->n1; + if ( diff > widest ) + widest = diff; + } + + // re-zero out unused coefficients (if any) + for( i = diff ; i < coefficient_width ; i++ ) + coeffs[i] = 0.0f; + } + + ++contribs; + coeffs += coefficient_width; + } + filter_info->lowest = lowest; + filter_info->highest = highest; + filter_info->widest = widest; +} + +#undef STBIR_RENORM_TYPE + +static int stbir__pack_coefficients( int num_contributors, stbir__contributors* contributors, float * coefficents, int coefficient_width, int widest, int row0, int row1 ) +{ + #define STBIR_MOVE_1( dest, src ) { STBIR_NO_UNROLL(dest); ((stbir_uint32*)(dest))[0] = ((stbir_uint32*)(src))[0]; } + #define STBIR_MOVE_2( dest, src ) { STBIR_NO_UNROLL(dest); ((stbir_uint64*)(dest))[0] = ((stbir_uint64*)(src))[0]; } + #ifdef STBIR_SIMD + #define STBIR_MOVE_4( dest, src ) { stbir__simdf t; STBIR_NO_UNROLL(dest); stbir__simdf_load( t, src ); stbir__simdf_store( dest, t ); } + #else + #define STBIR_MOVE_4( dest, src ) { STBIR_NO_UNROLL(dest); ((stbir_uint64*)(dest))[0] = ((stbir_uint64*)(src))[0]; ((stbir_uint64*)(dest))[1] = ((stbir_uint64*)(src))[1]; } + #endif + + int row_end = row1 + 1; + STBIR__UNUSED( row0 ); // only used in an assert + + if ( coefficient_width != widest ) + { + float * pc = coefficents; + float * coeffs = coefficents; + float * pc_end = coefficents + num_contributors * widest; + switch( widest ) + { + case 1: + STBIR_NO_UNROLL_LOOP_START + do { + STBIR_MOVE_1( pc, coeffs ); + ++pc; + coeffs += coefficient_width; + } while ( pc < pc_end ); + break; + case 2: + STBIR_NO_UNROLL_LOOP_START + do { + STBIR_MOVE_2( pc, coeffs ); + pc += 2; + coeffs += coefficient_width; + } while ( pc < pc_end ); + break; + case 3: + STBIR_NO_UNROLL_LOOP_START + do { + STBIR_MOVE_2( pc, coeffs ); + STBIR_MOVE_1( pc+2, coeffs+2 ); + pc += 3; + coeffs += coefficient_width; + } while ( pc < pc_end ); + break; + case 4: + STBIR_NO_UNROLL_LOOP_START + do { + STBIR_MOVE_4( pc, coeffs ); + pc += 4; + coeffs += coefficient_width; + } while ( pc < pc_end ); + break; + case 5: + STBIR_NO_UNROLL_LOOP_START + do { + STBIR_MOVE_4( pc, coeffs ); + STBIR_MOVE_1( pc+4, coeffs+4 ); + pc += 5; + coeffs += coefficient_width; + } while ( pc < pc_end ); + break; + case 6: + STBIR_NO_UNROLL_LOOP_START + do { + STBIR_MOVE_4( pc, coeffs ); + STBIR_MOVE_2( pc+4, coeffs+4 ); + pc += 6; + coeffs += coefficient_width; + } while ( pc < pc_end ); + break; + case 7: + STBIR_NO_UNROLL_LOOP_START + do { + STBIR_MOVE_4( pc, coeffs ); + STBIR_MOVE_2( pc+4, coeffs+4 ); + STBIR_MOVE_1( pc+6, coeffs+6 ); + pc += 7; + coeffs += coefficient_width; + } while ( pc < pc_end ); + break; + case 8: + STBIR_NO_UNROLL_LOOP_START + do { + STBIR_MOVE_4( pc, coeffs ); + STBIR_MOVE_4( pc+4, coeffs+4 ); + pc += 8; + coeffs += coefficient_width; + } while ( pc < pc_end ); + break; + case 9: + STBIR_NO_UNROLL_LOOP_START + do { + STBIR_MOVE_4( pc, coeffs ); + STBIR_MOVE_4( pc+4, coeffs+4 ); + STBIR_MOVE_1( pc+8, coeffs+8 ); + pc += 9; + coeffs += coefficient_width; + } while ( pc < pc_end ); + break; + case 10: + STBIR_NO_UNROLL_LOOP_START + do { + STBIR_MOVE_4( pc, coeffs ); + STBIR_MOVE_4( pc+4, coeffs+4 ); + STBIR_MOVE_2( pc+8, coeffs+8 ); + pc += 10; + coeffs += coefficient_width; + } while ( pc < pc_end ); + break; + case 11: + STBIR_NO_UNROLL_LOOP_START + do { + STBIR_MOVE_4( pc, coeffs ); + STBIR_MOVE_4( pc+4, coeffs+4 ); + STBIR_MOVE_2( pc+8, coeffs+8 ); + STBIR_MOVE_1( pc+10, coeffs+10 ); + pc += 11; + coeffs += coefficient_width; + } while ( pc < pc_end ); + break; + case 12: + STBIR_NO_UNROLL_LOOP_START + do { + STBIR_MOVE_4( pc, coeffs ); + STBIR_MOVE_4( pc+4, coeffs+4 ); + STBIR_MOVE_4( pc+8, coeffs+8 ); + pc += 12; + coeffs += coefficient_width; + } while ( pc < pc_end ); + break; + default: + STBIR_NO_UNROLL_LOOP_START + do { + float * copy_end = pc + widest - 4; + float * c = coeffs; + do { + STBIR_NO_UNROLL( pc ); + STBIR_MOVE_4( pc, c ); + pc += 4; + c += 4; + } while ( pc <= copy_end ); + copy_end += 4; + STBIR_NO_UNROLL_LOOP_START + while ( pc < copy_end ) + { + STBIR_MOVE_1( pc, c ); + ++pc; ++c; + } + coeffs += coefficient_width; + } while ( pc < pc_end ); + break; + } + } + + // some horizontal routines read one float off the end (which is then masked off), so put in a sentinel so we don't read an snan or denormal + coefficents[ widest * num_contributors ] = 8888.0f; + + // the minimum we might read for unrolled filters widths is 12. So, we need to + // make sure we never read outside the decode buffer, by possibly moving + // the sample area back into the scanline, and putting zeros weights first. + // we start on the right edge and check until we're well past the possible + // clip area (2*widest). + { + stbir__contributors * contribs = contributors + num_contributors - 1; + float * coeffs = coefficents + widest * ( num_contributors - 1 ); + + // go until no chance of clipping (this is usually less than 8 lops) + while ( ( contribs >= contributors ) && ( ( contribs->n0 + widest*2 ) >= row_end ) ) + { + // might we clip?? + if ( ( contribs->n0 + widest ) > row_end ) + { + int stop_range = widest; + + // if range is larger than 12, it will be handled by generic loops that can terminate on the exact length + // of this contrib n1, instead of a fixed widest amount - so calculate this + if ( widest > 12 ) + { + int mod; + + // how far will be read in the n_coeff loop (which depends on the widest count mod4); + mod = widest & 3; + stop_range = ( ( ( contribs->n1 - contribs->n0 + 1 ) - mod + 3 ) & ~3 ) + mod; + + // the n_coeff loops do a minimum amount of coeffs, so factor that in! + if ( stop_range < ( 8 + mod ) ) stop_range = 8 + mod; + } + + // now see if we still clip with the refined range + if ( ( contribs->n0 + stop_range ) > row_end ) + { + int new_n0 = row_end - stop_range; + int num = contribs->n1 - contribs->n0 + 1; + int backup = contribs->n0 - new_n0; + float * from_co = coeffs + num - 1; + float * to_co = from_co + backup; + + STBIR_ASSERT( ( new_n0 >= row0 ) && ( new_n0 < contribs->n0 ) ); + + // move the coeffs over + while( num ) + { + *to_co-- = *from_co--; + --num; + } + // zero new positions + while ( to_co >= coeffs ) + *to_co-- = 0; + // set new start point + contribs->n0 = new_n0; + if ( widest > 12 ) + { + int mod; + + // how far will be read in the n_coeff loop (which depends on the widest count mod4); + mod = widest & 3; + stop_range = ( ( ( contribs->n1 - contribs->n0 + 1 ) - mod + 3 ) & ~3 ) + mod; + + // the n_coeff loops do a minimum amount of coeffs, so factor that in! + if ( stop_range < ( 8 + mod ) ) stop_range = 8 + mod; + } + } + } + --contribs; + coeffs -= widest; + } + } + + return widest; + #undef STBIR_MOVE_1 + #undef STBIR_MOVE_2 + #undef STBIR_MOVE_4 +} + +static void stbir__calculate_filters( stbir__sampler * samp, stbir__sampler * other_axis_for_pivot, void * user_data STBIR_ONLY_PROFILE_BUILD_GET_INFO ) +{ + int n; + float scale = samp->scale_info.scale; + stbir__kernel_callback * kernel = samp->filter_kernel; + stbir__support_callback * support = samp->filter_support; + float inv_scale = samp->scale_info.inv_scale; + int input_full_size = samp->scale_info.input_full_size; + int gather_num_contributors = samp->num_contributors; + stbir__contributors* gather_contributors = samp->contributors; + float * gather_coeffs = samp->coefficients; + int gather_coefficient_width = samp->coefficient_width; + + switch ( samp->is_gather ) + { + case 1: // gather upsample + { + float out_pixels_radius = support(inv_scale,user_data) * scale; + + stbir__calculate_coefficients_for_gather_upsample( out_pixels_radius, kernel, &samp->scale_info, gather_num_contributors, gather_contributors, gather_coeffs, gather_coefficient_width, samp->edge, user_data ); + + STBIR_PROFILE_BUILD_START( cleanup ); + stbir__cleanup_gathered_coefficients( samp->edge, &samp->extent_info, &samp->scale_info, gather_num_contributors, gather_contributors, gather_coeffs, gather_coefficient_width ); + STBIR_PROFILE_BUILD_END( cleanup ); + } + break; + + case 0: // scatter downsample (only on vertical) + case 2: // gather downsample + { + float in_pixels_radius = support(scale,user_data) * inv_scale; + int filter_pixel_margin = samp->filter_pixel_margin; + int input_end = input_full_size + filter_pixel_margin; + + // if this is a scatter, we do a downsample gather to get the coeffs, and then pivot after + if ( !samp->is_gather ) + { + // check if we are using the same gather downsample on the horizontal as this vertical, + // if so, then we don't have to generate them, we can just pivot from the horizontal. + if ( other_axis_for_pivot ) + { + gather_contributors = other_axis_for_pivot->contributors; + gather_coeffs = other_axis_for_pivot->coefficients; + gather_coefficient_width = other_axis_for_pivot->coefficient_width; + gather_num_contributors = other_axis_for_pivot->num_contributors; + samp->extent_info.lowest = other_axis_for_pivot->extent_info.lowest; + samp->extent_info.highest = other_axis_for_pivot->extent_info.highest; + samp->extent_info.widest = other_axis_for_pivot->extent_info.widest; + goto jump_right_to_pivot; + } + + gather_contributors = samp->gather_prescatter_contributors; + gather_coeffs = samp->gather_prescatter_coefficients; + gather_coefficient_width = samp->gather_prescatter_coefficient_width; + gather_num_contributors = samp->gather_prescatter_num_contributors; + } + + stbir__calculate_coefficients_for_gather_downsample( -filter_pixel_margin, input_end, in_pixels_radius, kernel, &samp->scale_info, gather_coefficient_width, gather_num_contributors, gather_contributors, gather_coeffs, user_data ); + + STBIR_PROFILE_BUILD_START( cleanup ); + stbir__cleanup_gathered_coefficients( samp->edge, &samp->extent_info, &samp->scale_info, gather_num_contributors, gather_contributors, gather_coeffs, gather_coefficient_width ); + STBIR_PROFILE_BUILD_END( cleanup ); + + if ( !samp->is_gather ) + { + // if this is a scatter (vertical only), then we need to pivot the coeffs + stbir__contributors * scatter_contributors; + int highest_set; + + jump_right_to_pivot: + + STBIR_PROFILE_BUILD_START( pivot ); + + highest_set = (-filter_pixel_margin) - 1; + for (n = 0; n < gather_num_contributors; n++) + { + int k; + int gn0 = gather_contributors->n0, gn1 = gather_contributors->n1; + int scatter_coefficient_width = samp->coefficient_width; + float * scatter_coeffs = samp->coefficients + ( gn0 + filter_pixel_margin ) * scatter_coefficient_width; + float * g_coeffs = gather_coeffs; + scatter_contributors = samp->contributors + ( gn0 + filter_pixel_margin ); + + for (k = gn0 ; k <= gn1 ; k++ ) + { + float gc = *g_coeffs++; + + // skip zero and denormals - must skip zeros to avoid adding coeffs beyond scatter_coefficient_width + // (which happens when pivoting from horizontal, which might have dummy zeros) + if ( ( ( gc >= stbir__small_float ) || ( gc <= -stbir__small_float ) ) ) + { + if ( ( k > highest_set ) || ( scatter_contributors->n0 > scatter_contributors->n1 ) ) + { + { + // if we are skipping over several contributors, we need to clear the skipped ones + stbir__contributors * clear_contributors = samp->contributors + ( highest_set + filter_pixel_margin + 1); + while ( clear_contributors < scatter_contributors ) + { + clear_contributors->n0 = 0; + clear_contributors->n1 = -1; + ++clear_contributors; + } + } + scatter_contributors->n0 = n; + scatter_contributors->n1 = n; + scatter_coeffs[0] = gc; + highest_set = k; + } + else + { + stbir__insert_coeff( scatter_contributors, scatter_coeffs, n, gc, scatter_coefficient_width ); + } + STBIR_ASSERT( ( scatter_contributors->n1 - scatter_contributors->n0 + 1 ) <= scatter_coefficient_width ); + } + ++scatter_contributors; + scatter_coeffs += scatter_coefficient_width; + } + + ++gather_contributors; + gather_coeffs += gather_coefficient_width; + } + + // now clear any unset contribs + { + stbir__contributors * clear_contributors = samp->contributors + ( highest_set + filter_pixel_margin + 1); + stbir__contributors * end_contributors = samp->contributors + samp->num_contributors; + while ( clear_contributors < end_contributors ) + { + clear_contributors->n0 = 0; + clear_contributors->n1 = -1; + ++clear_contributors; + } + } + + STBIR_PROFILE_BUILD_END( pivot ); + } + } + break; + } +} + + +//======================================================================================================== +// scanline decoders and encoders + +#define stbir__coder_min_num 1 +#define STB_IMAGE_RESIZE_DO_CODERS +#include STBIR__HEADER_FILENAME + +#define stbir__decode_suffix BGRA +#define stbir__decode_swizzle +#define stbir__decode_order0 2 +#define stbir__decode_order1 1 +#define stbir__decode_order2 0 +#define stbir__decode_order3 3 +#define stbir__encode_order0 2 +#define stbir__encode_order1 1 +#define stbir__encode_order2 0 +#define stbir__encode_order3 3 +#define stbir__coder_min_num 4 +#define STB_IMAGE_RESIZE_DO_CODERS +#include STBIR__HEADER_FILENAME + +#define stbir__decode_suffix ARGB +#define stbir__decode_swizzle +#define stbir__decode_order0 1 +#define stbir__decode_order1 2 +#define stbir__decode_order2 3 +#define stbir__decode_order3 0 +#define stbir__encode_order0 3 +#define stbir__encode_order1 0 +#define stbir__encode_order2 1 +#define stbir__encode_order3 2 +#define stbir__coder_min_num 4 +#define STB_IMAGE_RESIZE_DO_CODERS +#include STBIR__HEADER_FILENAME + +#define stbir__decode_suffix ABGR +#define stbir__decode_swizzle +#define stbir__decode_order0 3 +#define stbir__decode_order1 2 +#define stbir__decode_order2 1 +#define stbir__decode_order3 0 +#define stbir__encode_order0 3 +#define stbir__encode_order1 2 +#define stbir__encode_order2 1 +#define stbir__encode_order3 0 +#define stbir__coder_min_num 4 +#define STB_IMAGE_RESIZE_DO_CODERS +#include STBIR__HEADER_FILENAME + +#define stbir__decode_suffix AR +#define stbir__decode_swizzle +#define stbir__decode_order0 1 +#define stbir__decode_order1 0 +#define stbir__decode_order2 3 +#define stbir__decode_order3 2 +#define stbir__encode_order0 1 +#define stbir__encode_order1 0 +#define stbir__encode_order2 3 +#define stbir__encode_order3 2 +#define stbir__coder_min_num 2 +#define STB_IMAGE_RESIZE_DO_CODERS +#include STBIR__HEADER_FILENAME + + +// fancy alpha means we expand to keep both premultipied and non-premultiplied color channels +static void stbir__fancy_alpha_weight_4ch( float * out_buffer, int width_times_channels ) +{ + float STBIR_STREAMOUT_PTR(*) out = out_buffer; + float const * end_decode = out_buffer + ( width_times_channels / 4 ) * 7; // decode buffer aligned to end of out_buffer + float STBIR_STREAMOUT_PTR(*) decode = (float*)end_decode - width_times_channels; + + // fancy alpha is stored internally as R G B A Rpm Gpm Bpm + + #ifdef STBIR_SIMD + + #ifdef STBIR_SIMD8 + decode += 16; + STBIR_NO_UNROLL_LOOP_START + while ( decode <= end_decode ) + { + stbir__simdf8 d0,d1,a0,a1,p0,p1; + STBIR_NO_UNROLL(decode); + stbir__simdf8_load( d0, decode-16 ); + stbir__simdf8_load( d1, decode-16+8 ); + stbir__simdf8_0123to33333333( a0, d0 ); + stbir__simdf8_0123to33333333( a1, d1 ); + stbir__simdf8_mult( p0, a0, d0 ); + stbir__simdf8_mult( p1, a1, d1 ); + stbir__simdf8_bot4s( a0, d0, p0 ); + stbir__simdf8_bot4s( a1, d1, p1 ); + stbir__simdf8_top4s( d0, d0, p0 ); + stbir__simdf8_top4s( d1, d1, p1 ); + stbir__simdf8_store ( out, a0 ); + stbir__simdf8_store ( out+7, d0 ); + stbir__simdf8_store ( out+14, a1 ); + stbir__simdf8_store ( out+21, d1 ); + decode += 16; + out += 28; + } + decode -= 16; + #else + decode += 8; + STBIR_NO_UNROLL_LOOP_START + while ( decode <= end_decode ) + { + stbir__simdf d0,a0,d1,a1,p0,p1; + STBIR_NO_UNROLL(decode); + stbir__simdf_load( d0, decode-8 ); + stbir__simdf_load( d1, decode-8+4 ); + stbir__simdf_0123to3333( a0, d0 ); + stbir__simdf_0123to3333( a1, d1 ); + stbir__simdf_mult( p0, a0, d0 ); + stbir__simdf_mult( p1, a1, d1 ); + stbir__simdf_store ( out, d0 ); + stbir__simdf_store ( out+4, p0 ); + stbir__simdf_store ( out+7, d1 ); + stbir__simdf_store ( out+7+4, p1 ); + decode += 8; + out += 14; + } + decode -= 8; + #endif + + // might be one last odd pixel + #ifdef STBIR_SIMD8 + STBIR_NO_UNROLL_LOOP_START + while ( decode < end_decode ) + #else + if ( decode < end_decode ) + #endif + { + stbir__simdf d,a,p; + STBIR_NO_UNROLL(decode); + stbir__simdf_load( d, decode ); + stbir__simdf_0123to3333( a, d ); + stbir__simdf_mult( p, a, d ); + stbir__simdf_store ( out, d ); + stbir__simdf_store ( out+4, p ); + decode += 4; + out += 7; + } + + #else + + while( decode < end_decode ) + { + float r = decode[0], g = decode[1], b = decode[2], alpha = decode[3]; + out[0] = r; + out[1] = g; + out[2] = b; + out[3] = alpha; + out[4] = r * alpha; + out[5] = g * alpha; + out[6] = b * alpha; + out += 7; + decode += 4; + } + + #endif +} + +static void stbir__fancy_alpha_weight_2ch( float * out_buffer, int width_times_channels ) +{ + float STBIR_STREAMOUT_PTR(*) out = out_buffer; + float const * end_decode = out_buffer + ( width_times_channels / 2 ) * 3; + float STBIR_STREAMOUT_PTR(*) decode = (float*)end_decode - width_times_channels; + + // for fancy alpha, turns into: [X A Xpm][X A Xpm],etc + + #ifdef STBIR_SIMD + + decode += 8; + if ( decode <= end_decode ) + { + STBIR_NO_UNROLL_LOOP_START + do { + #ifdef STBIR_SIMD8 + stbir__simdf8 d0,a0,p0; + STBIR_NO_UNROLL(decode); + stbir__simdf8_load( d0, decode-8 ); + stbir__simdf8_0123to11331133( p0, d0 ); + stbir__simdf8_0123to00220022( a0, d0 ); + stbir__simdf8_mult( p0, p0, a0 ); + + stbir__simdf_store2( out, stbir__if_simdf8_cast_to_simdf4( d0 ) ); + stbir__simdf_store( out+2, stbir__if_simdf8_cast_to_simdf4( p0 ) ); + stbir__simdf_store2h( out+3, stbir__if_simdf8_cast_to_simdf4( d0 ) ); + + stbir__simdf_store2( out+6, stbir__simdf8_gettop4( d0 ) ); + stbir__simdf_store( out+8, stbir__simdf8_gettop4( p0 ) ); + stbir__simdf_store2h( out+9, stbir__simdf8_gettop4( d0 ) ); + #else + stbir__simdf d0,a0,d1,a1,p0,p1; + STBIR_NO_UNROLL(decode); + stbir__simdf_load( d0, decode-8 ); + stbir__simdf_load( d1, decode-8+4 ); + stbir__simdf_0123to1133( p0, d0 ); + stbir__simdf_0123to1133( p1, d1 ); + stbir__simdf_0123to0022( a0, d0 ); + stbir__simdf_0123to0022( a1, d1 ); + stbir__simdf_mult( p0, p0, a0 ); + stbir__simdf_mult( p1, p1, a1 ); + + stbir__simdf_store2( out, d0 ); + stbir__simdf_store( out+2, p0 ); + stbir__simdf_store2h( out+3, d0 ); + + stbir__simdf_store2( out+6, d1 ); + stbir__simdf_store( out+8, p1 ); + stbir__simdf_store2h( out+9, d1 ); + #endif + decode += 8; + out += 12; + } while ( decode <= end_decode ); + } + decode -= 8; + #endif + + STBIR_SIMD_NO_UNROLL_LOOP_START + while( decode < end_decode ) + { + float x = decode[0], y = decode[1]; + STBIR_SIMD_NO_UNROLL(decode); + out[0] = x; + out[1] = y; + out[2] = x * y; + out += 3; + decode += 2; + } +} + +static void stbir__fancy_alpha_unweight_4ch( float * encode_buffer, int width_times_channels ) +{ + float STBIR_SIMD_STREAMOUT_PTR(*) encode = encode_buffer; + float STBIR_SIMD_STREAMOUT_PTR(*) input = encode_buffer; + float const * end_output = encode_buffer + width_times_channels; + + // fancy RGBA is stored internally as R G B A Rpm Gpm Bpm + + STBIR_SIMD_NO_UNROLL_LOOP_START + do { + float alpha = input[3]; +#ifdef STBIR_SIMD + stbir__simdf i,ia; + STBIR_SIMD_NO_UNROLL(encode); + if ( alpha < stbir__small_float ) + { + stbir__simdf_load( i, input ); + stbir__simdf_store( encode, i ); + } + else + { + stbir__simdf_load1frep4( ia, 1.0f / alpha ); + stbir__simdf_load( i, input+4 ); + stbir__simdf_mult( i, i, ia ); + stbir__simdf_store( encode, i ); + encode[3] = alpha; + } +#else + if ( alpha < stbir__small_float ) + { + encode[0] = input[0]; + encode[1] = input[1]; + encode[2] = input[2]; + } + else + { + float ialpha = 1.0f / alpha; + encode[0] = input[4] * ialpha; + encode[1] = input[5] * ialpha; + encode[2] = input[6] * ialpha; + } + encode[3] = alpha; +#endif + + input += 7; + encode += 4; + } while ( encode < end_output ); +} + +// format: [X A Xpm][X A Xpm] etc +static void stbir__fancy_alpha_unweight_2ch( float * encode_buffer, int width_times_channels ) +{ + float STBIR_SIMD_STREAMOUT_PTR(*) encode = encode_buffer; + float STBIR_SIMD_STREAMOUT_PTR(*) input = encode_buffer; + float const * end_output = encode_buffer + width_times_channels; + + do { + float alpha = input[1]; + encode[0] = input[0]; + if ( alpha >= stbir__small_float ) + encode[0] = input[2] / alpha; + encode[1] = alpha; + + input += 3; + encode += 2; + } while ( encode < end_output ); +} + +static void stbir__simple_alpha_weight_4ch( float * decode_buffer, int width_times_channels ) +{ + float STBIR_STREAMOUT_PTR(*) decode = decode_buffer; + float const * end_decode = decode_buffer + width_times_channels; + + #ifdef STBIR_SIMD + { + decode += 2 * stbir__simdfX_float_count; + STBIR_NO_UNROLL_LOOP_START + while ( decode <= end_decode ) + { + stbir__simdfX d0,a0,d1,a1; + STBIR_NO_UNROLL(decode); + stbir__simdfX_load( d0, decode-2*stbir__simdfX_float_count ); + stbir__simdfX_load( d1, decode-2*stbir__simdfX_float_count+stbir__simdfX_float_count ); + stbir__simdfX_aaa1( a0, d0, STBIR_onesX ); + stbir__simdfX_aaa1( a1, d1, STBIR_onesX ); + stbir__simdfX_mult( d0, d0, a0 ); + stbir__simdfX_mult( d1, d1, a1 ); + stbir__simdfX_store ( decode-2*stbir__simdfX_float_count, d0 ); + stbir__simdfX_store ( decode-2*stbir__simdfX_float_count+stbir__simdfX_float_count, d1 ); + decode += 2 * stbir__simdfX_float_count; + } + decode -= 2 * stbir__simdfX_float_count; + + // few last pixels remnants + #ifdef STBIR_SIMD8 + STBIR_NO_UNROLL_LOOP_START + while ( decode < end_decode ) + #else + if ( decode < end_decode ) + #endif + { + stbir__simdf d,a; + stbir__simdf_load( d, decode ); + stbir__simdf_aaa1( a, d, STBIR__CONSTF(STBIR_ones) ); + stbir__simdf_mult( d, d, a ); + stbir__simdf_store ( decode, d ); + decode += 4; + } + } + + #else + + while( decode < end_decode ) + { + float alpha = decode[3]; + decode[0] *= alpha; + decode[1] *= alpha; + decode[2] *= alpha; + decode += 4; + } + + #endif +} + +static void stbir__simple_alpha_weight_2ch( float * decode_buffer, int width_times_channels ) +{ + float STBIR_STREAMOUT_PTR(*) decode = decode_buffer; + float const * end_decode = decode_buffer + width_times_channels; + + #ifdef STBIR_SIMD + decode += 2 * stbir__simdfX_float_count; + STBIR_NO_UNROLL_LOOP_START + while ( decode <= end_decode ) + { + stbir__simdfX d0,a0,d1,a1; + STBIR_NO_UNROLL(decode); + stbir__simdfX_load( d0, decode-2*stbir__simdfX_float_count ); + stbir__simdfX_load( d1, decode-2*stbir__simdfX_float_count+stbir__simdfX_float_count ); + stbir__simdfX_a1a1( a0, d0, STBIR_onesX ); + stbir__simdfX_a1a1( a1, d1, STBIR_onesX ); + stbir__simdfX_mult( d0, d0, a0 ); + stbir__simdfX_mult( d1, d1, a1 ); + stbir__simdfX_store ( decode-2*stbir__simdfX_float_count, d0 ); + stbir__simdfX_store ( decode-2*stbir__simdfX_float_count+stbir__simdfX_float_count, d1 ); + decode += 2 * stbir__simdfX_float_count; + } + decode -= 2 * stbir__simdfX_float_count; + #endif + + STBIR_SIMD_NO_UNROLL_LOOP_START + while( decode < end_decode ) + { + float alpha = decode[1]; + STBIR_SIMD_NO_UNROLL(decode); + decode[0] *= alpha; + decode += 2; + } +} + +static void stbir__simple_alpha_unweight_4ch( float * encode_buffer, int width_times_channels ) +{ + float STBIR_SIMD_STREAMOUT_PTR(*) encode = encode_buffer; + float const * end_output = encode_buffer + width_times_channels; + + STBIR_SIMD_NO_UNROLL_LOOP_START + do { + float alpha = encode[3]; + +#ifdef STBIR_SIMD + stbir__simdf i,ia; + STBIR_SIMD_NO_UNROLL(encode); + if ( alpha >= stbir__small_float ) + { + stbir__simdf_load1frep4( ia, 1.0f / alpha ); + stbir__simdf_load( i, encode ); + stbir__simdf_mult( i, i, ia ); + stbir__simdf_store( encode, i ); + encode[3] = alpha; + } +#else + if ( alpha >= stbir__small_float ) + { + float ialpha = 1.0f / alpha; + encode[0] *= ialpha; + encode[1] *= ialpha; + encode[2] *= ialpha; + } +#endif + encode += 4; + } while ( encode < end_output ); +} + +static void stbir__simple_alpha_unweight_2ch( float * encode_buffer, int width_times_channels ) +{ + float STBIR_SIMD_STREAMOUT_PTR(*) encode = encode_buffer; + float const * end_output = encode_buffer + width_times_channels; + + do { + float alpha = encode[1]; + if ( alpha >= stbir__small_float ) + encode[0] /= alpha; + encode += 2; + } while ( encode < end_output ); +} + + +// only used in RGB->BGR or BGR->RGB +static void stbir__simple_flip_3ch( float * decode_buffer, int width_times_channels ) +{ + float STBIR_STREAMOUT_PTR(*) decode = decode_buffer; + float const * end_decode = decode_buffer + width_times_channels; + +#ifdef STBIR_SIMD + #ifdef stbir__simdf_swiz2 // do we have two argument swizzles? + end_decode -= 12; + STBIR_NO_UNROLL_LOOP_START + while( decode <= end_decode ) + { + // on arm64 8 instructions, no overlapping stores + stbir__simdf a,b,c,na,nb; + STBIR_SIMD_NO_UNROLL(decode); + stbir__simdf_load( a, decode ); + stbir__simdf_load( b, decode+4 ); + stbir__simdf_load( c, decode+8 ); + + na = stbir__simdf_swiz2( a, b, 2, 1, 0, 5 ); + b = stbir__simdf_swiz2( a, b, 4, 3, 6, 7 ); + nb = stbir__simdf_swiz2( b, c, 0, 1, 4, 3 ); + c = stbir__simdf_swiz2( b, c, 2, 7, 6, 5 ); + + stbir__simdf_store( decode, na ); + stbir__simdf_store( decode+4, nb ); + stbir__simdf_store( decode+8, c ); + decode += 12; + } + end_decode += 12; + #else + end_decode -= 24; + STBIR_NO_UNROLL_LOOP_START + while( decode <= end_decode ) + { + // 26 instructions on x64 + stbir__simdf a,b,c,d,e,f,g; + float i21, i23; + STBIR_SIMD_NO_UNROLL(decode); + stbir__simdf_load( a, decode ); + stbir__simdf_load( b, decode+3 ); + stbir__simdf_load( c, decode+6 ); + stbir__simdf_load( d, decode+9 ); + stbir__simdf_load( e, decode+12 ); + stbir__simdf_load( f, decode+15 ); + stbir__simdf_load( g, decode+18 ); + + a = stbir__simdf_swiz( a, 2, 1, 0, 3 ); + b = stbir__simdf_swiz( b, 2, 1, 0, 3 ); + c = stbir__simdf_swiz( c, 2, 1, 0, 3 ); + d = stbir__simdf_swiz( d, 2, 1, 0, 3 ); + e = stbir__simdf_swiz( e, 2, 1, 0, 3 ); + f = stbir__simdf_swiz( f, 2, 1, 0, 3 ); + g = stbir__simdf_swiz( g, 2, 1, 0, 3 ); + + // stores overlap, need to be in order, + stbir__simdf_store( decode, a ); + i21 = decode[21]; + stbir__simdf_store( decode+3, b ); + i23 = decode[23]; + stbir__simdf_store( decode+6, c ); + stbir__simdf_store( decode+9, d ); + stbir__simdf_store( decode+12, e ); + stbir__simdf_store( decode+15, f ); + stbir__simdf_store( decode+18, g ); + decode[21] = i23; + decode[23] = i21; + decode += 24; + } + end_decode += 24; + #endif +#else + end_decode -= 12; + STBIR_NO_UNROLL_LOOP_START + while( decode <= end_decode ) + { + // 16 instructions + float t0,t1,t2,t3; + STBIR_NO_UNROLL(decode); + t0 = decode[0]; t1 = decode[3]; t2 = decode[6]; t3 = decode[9]; + decode[0] = decode[2]; decode[3] = decode[5]; decode[6] = decode[8]; decode[9] = decode[11]; + decode[2] = t0; decode[5] = t1; decode[8] = t2; decode[11] = t3; + decode += 12; + } + end_decode += 12; +#endif + + STBIR_NO_UNROLL_LOOP_START + while( decode < end_decode ) + { + float t = decode[0]; + STBIR_NO_UNROLL(decode); + decode[0] = decode[2]; + decode[2] = t; + decode += 3; + } +} + + + +static void stbir__decode_scanline(stbir__info const * stbir_info, int n, float * output_buffer STBIR_ONLY_PROFILE_GET_SPLIT_INFO ) +{ + int channels = stbir_info->channels; + int effective_channels = stbir_info->effective_channels; + int input_sample_in_bytes = stbir__type_size[stbir_info->input_type] * channels; + stbir_edge edge_horizontal = stbir_info->horizontal.edge; + stbir_edge edge_vertical = stbir_info->vertical.edge; + int row = stbir__edge_wrap(edge_vertical, n, stbir_info->vertical.scale_info.input_full_size); + const void* input_plane_data = ( (char *) stbir_info->input_data ) + (size_t)row * (size_t) stbir_info->input_stride_bytes; + stbir__span const * spans = stbir_info->scanline_extents.spans; + float * full_decode_buffer = output_buffer - stbir_info->scanline_extents.conservative.n0 * effective_channels; + float * last_decoded = 0; + + // if we are on edge_zero, and we get in here with an out of bounds n, then the calculate filters has failed + STBIR_ASSERT( !(edge_vertical == STBIR_EDGE_ZERO && (n < 0 || n >= stbir_info->vertical.scale_info.input_full_size)) ); + + do + { + float * decode_buffer; + void const * input_data; + float * end_decode; + int width_times_channels; + int width; + + if ( spans->n1 < spans->n0 ) + break; + + width = spans->n1 + 1 - spans->n0; + decode_buffer = full_decode_buffer + spans->n0 * effective_channels; + end_decode = full_decode_buffer + ( spans->n1 + 1 ) * effective_channels; + width_times_channels = width * channels; + + // read directly out of input plane by default + input_data = ( (char*)input_plane_data ) + spans->pixel_offset_for_input * input_sample_in_bytes; + + // if we have an input callback, call it to get the input data + if ( stbir_info->in_pixels_cb ) + { + // call the callback with a temp buffer (that they can choose to use or not). the temp is just right aligned memory in the decode_buffer itself + input_data = stbir_info->in_pixels_cb( ( (char*) end_decode ) - ( width * input_sample_in_bytes ) + ( ( stbir_info->input_type != STBIR_TYPE_FLOAT ) ? ( sizeof(float)*STBIR_INPUT_CALLBACK_PADDING ) : 0 ), input_plane_data, width, spans->pixel_offset_for_input, row, stbir_info->user_data ); + } + + STBIR_PROFILE_START( decode ); + // convert the pixels info the float decode_buffer, (we index from end_decode, so that when channelsdecode_pixels( (float*)end_decode - width_times_channels, width_times_channels, input_data ); + STBIR_PROFILE_END( decode ); + + if (stbir_info->alpha_weight) + { + STBIR_PROFILE_START( alpha ); + stbir_info->alpha_weight( decode_buffer, width_times_channels ); + STBIR_PROFILE_END( alpha ); + } + + ++spans; + } while ( spans <= ( &stbir_info->scanline_extents.spans[1] ) ); + + // handle the edge_wrap filter (all other types are handled back out at the calculate_filter stage) + // basically the idea here is that if we have the whole scanline in memory, we don't redecode the + // wrapped edge pixels, and instead just memcpy them from the scanline into the edge positions + if ( ( edge_horizontal == STBIR_EDGE_WRAP ) && ( stbir_info->scanline_extents.edge_sizes[0] | stbir_info->scanline_extents.edge_sizes[1] ) ) + { + // this code only runs if we're in edge_wrap, and we're doing the entire scanline + int e, start_x[2]; + int input_full_size = stbir_info->horizontal.scale_info.input_full_size; + + start_x[0] = -stbir_info->scanline_extents.edge_sizes[0]; // left edge start x + start_x[1] = input_full_size; // right edge + + for( e = 0; e < 2 ; e++ ) + { + // do each margin + int margin = stbir_info->scanline_extents.edge_sizes[e]; + if ( margin ) + { + int x = start_x[e]; + float * marg = full_decode_buffer + x * effective_channels; + float const * src = full_decode_buffer + stbir__edge_wrap(edge_horizontal, x, input_full_size) * effective_channels; + STBIR_MEMCPY( marg, src, margin * effective_channels * sizeof(float) ); + if ( e == 1 ) last_decoded = marg + margin * effective_channels; + } + } + } + + // some of the horizontal gathers read one float off the edge (which is masked out), but we force a zero here to make sure no NaNs leak in + // (we can't pre-zero it, because the input callback can use that area as padding) + last_decoded[0] = 0.0f; + + // we clear this extra float, because the final output pixel filter kernel might have used one less coeff than the max filter width + // when this happens, we do read that pixel from the input, so it too could be Nan, so just zero an extra one. + // this fits because each scanline is padded by three floats (STBIR_INPUT_CALLBACK_PADDING) + last_decoded[1] = 0.0f; +} + + +//================= +// Do 1 channel horizontal routines + +#ifdef STBIR_SIMD + +#define stbir__1_coeff_only() \ + stbir__simdf tot,c; \ + STBIR_SIMD_NO_UNROLL(decode); \ + stbir__simdf_load1( c, hc ); \ + stbir__simdf_mult1_mem( tot, c, decode ); + +#define stbir__2_coeff_only() \ + stbir__simdf tot,c,d; \ + STBIR_SIMD_NO_UNROLL(decode); \ + stbir__simdf_load2z( c, hc ); \ + stbir__simdf_load2( d, decode ); \ + stbir__simdf_mult( tot, c, d ); \ + stbir__simdf_0123to1230( c, tot ); \ + stbir__simdf_add1( tot, tot, c ); + +#define stbir__3_coeff_only() \ + stbir__simdf tot,c,t; \ + STBIR_SIMD_NO_UNROLL(decode); \ + stbir__simdf_load( c, hc ); \ + stbir__simdf_mult_mem( tot, c, decode ); \ + stbir__simdf_0123to1230( c, tot ); \ + stbir__simdf_0123to2301( t, tot ); \ + stbir__simdf_add1( tot, tot, c ); \ + stbir__simdf_add1( tot, tot, t ); + +#define stbir__store_output_tiny() \ + stbir__simdf_store1( output, tot ); \ + horizontal_coefficients += coefficient_width; \ + ++horizontal_contributors; \ + output += 1; + +#define stbir__4_coeff_start() \ + stbir__simdf tot,c; \ + STBIR_SIMD_NO_UNROLL(decode); \ + stbir__simdf_load( c, hc ); \ + stbir__simdf_mult_mem( tot, c, decode ); \ + +#define stbir__4_coeff_continue_from_4( ofs ) \ + STBIR_SIMD_NO_UNROLL(decode); \ + stbir__simdf_load( c, hc + (ofs) ); \ + stbir__simdf_madd_mem( tot, tot, c, decode+(ofs) ); + +#define stbir__1_coeff_remnant( ofs ) \ + { stbir__simdf d; \ + stbir__simdf_load1z( c, hc + (ofs) ); \ + stbir__simdf_load1( d, decode + (ofs) ); \ + stbir__simdf_madd( tot, tot, d, c ); } + +#define stbir__2_coeff_remnant( ofs ) \ + { stbir__simdf d; \ + stbir__simdf_load2z( c, hc+(ofs) ); \ + stbir__simdf_load2( d, decode+(ofs) ); \ + stbir__simdf_madd( tot, tot, d, c ); } + +#define stbir__3_coeff_setup() \ + stbir__simdf mask; \ + stbir__simdf_load( mask, STBIR_mask + 3 ); + +#define stbir__3_coeff_remnant( ofs ) \ + stbir__simdf_load( c, hc+(ofs) ); \ + stbir__simdf_and( c, c, mask ); \ + stbir__simdf_madd_mem( tot, tot, c, decode+(ofs) ); + +#define stbir__store_output() \ + stbir__simdf_0123to2301( c, tot ); \ + stbir__simdf_add( tot, tot, c ); \ + stbir__simdf_0123to1230( c, tot ); \ + stbir__simdf_add1( tot, tot, c ); \ + stbir__simdf_store1( output, tot ); \ + horizontal_coefficients += coefficient_width; \ + ++horizontal_contributors; \ + output += 1; + +#else + +#define stbir__1_coeff_only() \ + float tot; \ + tot = decode[0]*hc[0]; + +#define stbir__2_coeff_only() \ + float tot; \ + tot = decode[0] * hc[0]; \ + tot += decode[1] * hc[1]; + +#define stbir__3_coeff_only() \ + float tot; \ + tot = decode[0] * hc[0]; \ + tot += decode[1] * hc[1]; \ + tot += decode[2] * hc[2]; + +#define stbir__store_output_tiny() \ + output[0] = tot; \ + horizontal_coefficients += coefficient_width; \ + ++horizontal_contributors; \ + output += 1; + +#define stbir__4_coeff_start() \ + float tot0,tot1,tot2,tot3; \ + tot0 = decode[0] * hc[0]; \ + tot1 = decode[1] * hc[1]; \ + tot2 = decode[2] * hc[2]; \ + tot3 = decode[3] * hc[3]; + +#define stbir__4_coeff_continue_from_4( ofs ) \ + tot0 += decode[0+(ofs)] * hc[0+(ofs)]; \ + tot1 += decode[1+(ofs)] * hc[1+(ofs)]; \ + tot2 += decode[2+(ofs)] * hc[2+(ofs)]; \ + tot3 += decode[3+(ofs)] * hc[3+(ofs)]; + +#define stbir__1_coeff_remnant( ofs ) \ + tot0 += decode[0+(ofs)] * hc[0+(ofs)]; + +#define stbir__2_coeff_remnant( ofs ) \ + tot0 += decode[0+(ofs)] * hc[0+(ofs)]; \ + tot1 += decode[1+(ofs)] * hc[1+(ofs)]; \ + +#define stbir__3_coeff_remnant( ofs ) \ + tot0 += decode[0+(ofs)] * hc[0+(ofs)]; \ + tot1 += decode[1+(ofs)] * hc[1+(ofs)]; \ + tot2 += decode[2+(ofs)] * hc[2+(ofs)]; + +#define stbir__store_output() \ + output[0] = (tot0+tot2)+(tot1+tot3); \ + horizontal_coefficients += coefficient_width; \ + ++horizontal_contributors; \ + output += 1; + +#endif + +#define STBIR__horizontal_channels 1 +#define STB_IMAGE_RESIZE_DO_HORIZONTALS +#include STBIR__HEADER_FILENAME + + +//================= +// Do 2 channel horizontal routines + +#ifdef STBIR_SIMD + +#define stbir__1_coeff_only() \ + stbir__simdf tot,c,d; \ + STBIR_SIMD_NO_UNROLL(decode); \ + stbir__simdf_load1z( c, hc ); \ + stbir__simdf_0123to0011( c, c ); \ + stbir__simdf_load2( d, decode ); \ + stbir__simdf_mult( tot, d, c ); + +#define stbir__2_coeff_only() \ + stbir__simdf tot,c; \ + STBIR_SIMD_NO_UNROLL(decode); \ + stbir__simdf_load2( c, hc ); \ + stbir__simdf_0123to0011( c, c ); \ + stbir__simdf_mult_mem( tot, c, decode ); + +#define stbir__3_coeff_only() \ + stbir__simdf tot,c,cs,d; \ + STBIR_SIMD_NO_UNROLL(decode); \ + stbir__simdf_load( cs, hc ); \ + stbir__simdf_0123to0011( c, cs ); \ + stbir__simdf_mult_mem( tot, c, decode ); \ + stbir__simdf_0123to2222( c, cs ); \ + stbir__simdf_load2z( d, decode+4 ); \ + stbir__simdf_madd( tot, tot, d, c ); + +#define stbir__store_output_tiny() \ + stbir__simdf_0123to2301( c, tot ); \ + stbir__simdf_add( tot, tot, c ); \ + stbir__simdf_store2( output, tot ); \ + horizontal_coefficients += coefficient_width; \ + ++horizontal_contributors; \ + output += 2; + +#ifdef STBIR_SIMD8 + +#define stbir__4_coeff_start() \ + stbir__simdf8 tot0,c,cs; \ + STBIR_SIMD_NO_UNROLL(decode); \ + stbir__simdf8_load4b( cs, hc ); \ + stbir__simdf8_0123to00112233( c, cs ); \ + stbir__simdf8_mult_mem( tot0, c, decode ); + +#define stbir__4_coeff_continue_from_4( ofs ) \ + STBIR_SIMD_NO_UNROLL(decode); \ + stbir__simdf8_load4b( cs, hc + (ofs) ); \ + stbir__simdf8_0123to00112233( c, cs ); \ + stbir__simdf8_madd_mem( tot0, tot0, c, decode+(ofs)*2 ); + +#define stbir__1_coeff_remnant( ofs ) \ + { stbir__simdf t,d; \ + stbir__simdf_load1z( t, hc + (ofs) ); \ + stbir__simdf_load2( d, decode + (ofs) * 2 ); \ + stbir__simdf_0123to0011( t, t ); \ + stbir__simdf_mult( t, t, d ); \ + stbir__simdf8_add4( tot0, tot0, t ); } + +#define stbir__2_coeff_remnant( ofs ) \ + { stbir__simdf t; \ + stbir__simdf_load2( t, hc + (ofs) ); \ + stbir__simdf_0123to0011( t, t ); \ + stbir__simdf_mult_mem( t, t, decode+(ofs)*2 ); \ + stbir__simdf8_add4( tot0, tot0, t ); } + +#define stbir__3_coeff_remnant( ofs ) \ + { stbir__simdf8 d; \ + stbir__simdf8_load4b( cs, hc + (ofs) ); \ + stbir__simdf8_0123to00112233( c, cs ); \ + stbir__simdf8_load6z( d, decode+(ofs)*2 ); \ + stbir__simdf8_madd( tot0, tot0, c, d ); } + +#define stbir__store_output() \ + { stbir__simdf t,d; \ + stbir__simdf8_add4halves( t, stbir__if_simdf8_cast_to_simdf4(tot0), tot0 ); \ + stbir__simdf_0123to2301( d, t ); \ + stbir__simdf_add( t, t, d ); \ + stbir__simdf_store2( output, t ); \ + horizontal_coefficients += coefficient_width; \ + ++horizontal_contributors; \ + output += 2; } + +#else + +#define stbir__4_coeff_start() \ + stbir__simdf tot0,tot1,c,cs; \ + STBIR_SIMD_NO_UNROLL(decode); \ + stbir__simdf_load( cs, hc ); \ + stbir__simdf_0123to0011( c, cs ); \ + stbir__simdf_mult_mem( tot0, c, decode ); \ + stbir__simdf_0123to2233( c, cs ); \ + stbir__simdf_mult_mem( tot1, c, decode+4 ); + +#define stbir__4_coeff_continue_from_4( ofs ) \ + STBIR_SIMD_NO_UNROLL(decode); \ + stbir__simdf_load( cs, hc + (ofs) ); \ + stbir__simdf_0123to0011( c, cs ); \ + stbir__simdf_madd_mem( tot0, tot0, c, decode+(ofs)*2 ); \ + stbir__simdf_0123to2233( c, cs ); \ + stbir__simdf_madd_mem( tot1, tot1, c, decode+(ofs)*2+4 ); + +#define stbir__1_coeff_remnant( ofs ) \ + { stbir__simdf d; \ + stbir__simdf_load1z( cs, hc + (ofs) ); \ + stbir__simdf_0123to0011( c, cs ); \ + stbir__simdf_load2( d, decode + (ofs) * 2 ); \ + stbir__simdf_madd( tot0, tot0, d, c ); } + +#define stbir__2_coeff_remnant( ofs ) \ + stbir__simdf_load2( cs, hc + (ofs) ); \ + stbir__simdf_0123to0011( c, cs ); \ + stbir__simdf_madd_mem( tot0, tot0, c, decode+(ofs)*2 ); + +#define stbir__3_coeff_remnant( ofs ) \ + { stbir__simdf d; \ + stbir__simdf_load( cs, hc + (ofs) ); \ + stbir__simdf_0123to0011( c, cs ); \ + stbir__simdf_madd_mem( tot0, tot0, c, decode+(ofs)*2 ); \ + stbir__simdf_0123to2222( c, cs ); \ + stbir__simdf_load2z( d, decode + (ofs) * 2 + 4 ); \ + stbir__simdf_madd( tot1, tot1, d, c ); } + +#define stbir__store_output() \ + stbir__simdf_add( tot0, tot0, tot1 ); \ + stbir__simdf_0123to2301( c, tot0 ); \ + stbir__simdf_add( tot0, tot0, c ); \ + stbir__simdf_store2( output, tot0 ); \ + horizontal_coefficients += coefficient_width; \ + ++horizontal_contributors; \ + output += 2; + +#endif + +#else + +#define stbir__1_coeff_only() \ + float tota,totb,c; \ + c = hc[0]; \ + tota = decode[0]*c; \ + totb = decode[1]*c; + +#define stbir__2_coeff_only() \ + float tota,totb,c; \ + c = hc[0]; \ + tota = decode[0]*c; \ + totb = decode[1]*c; \ + c = hc[1]; \ + tota += decode[2]*c; \ + totb += decode[3]*c; + +// this weird order of add matches the simd +#define stbir__3_coeff_only() \ + float tota,totb,c; \ + c = hc[0]; \ + tota = decode[0]*c; \ + totb = decode[1]*c; \ + c = hc[2]; \ + tota += decode[4]*c; \ + totb += decode[5]*c; \ + c = hc[1]; \ + tota += decode[2]*c; \ + totb += decode[3]*c; + +#define stbir__store_output_tiny() \ + output[0] = tota; \ + output[1] = totb; \ + horizontal_coefficients += coefficient_width; \ + ++horizontal_contributors; \ + output += 2; + +#define stbir__4_coeff_start() \ + float tota0,tota1,tota2,tota3,totb0,totb1,totb2,totb3,c; \ + c = hc[0]; \ + tota0 = decode[0]*c; \ + totb0 = decode[1]*c; \ + c = hc[1]; \ + tota1 = decode[2]*c; \ + totb1 = decode[3]*c; \ + c = hc[2]; \ + tota2 = decode[4]*c; \ + totb2 = decode[5]*c; \ + c = hc[3]; \ + tota3 = decode[6]*c; \ + totb3 = decode[7]*c; + +#define stbir__4_coeff_continue_from_4( ofs ) \ + c = hc[0+(ofs)]; \ + tota0 += decode[0+(ofs)*2]*c; \ + totb0 += decode[1+(ofs)*2]*c; \ + c = hc[1+(ofs)]; \ + tota1 += decode[2+(ofs)*2]*c; \ + totb1 += decode[3+(ofs)*2]*c; \ + c = hc[2+(ofs)]; \ + tota2 += decode[4+(ofs)*2]*c; \ + totb2 += decode[5+(ofs)*2]*c; \ + c = hc[3+(ofs)]; \ + tota3 += decode[6+(ofs)*2]*c; \ + totb3 += decode[7+(ofs)*2]*c; + +#define stbir__1_coeff_remnant( ofs ) \ + c = hc[0+(ofs)]; \ + tota0 += decode[0+(ofs)*2] * c; \ + totb0 += decode[1+(ofs)*2] * c; + +#define stbir__2_coeff_remnant( ofs ) \ + c = hc[0+(ofs)]; \ + tota0 += decode[0+(ofs)*2] * c; \ + totb0 += decode[1+(ofs)*2] * c; \ + c = hc[1+(ofs)]; \ + tota1 += decode[2+(ofs)*2] * c; \ + totb1 += decode[3+(ofs)*2] * c; + +#define stbir__3_coeff_remnant( ofs ) \ + c = hc[0+(ofs)]; \ + tota0 += decode[0+(ofs)*2] * c; \ + totb0 += decode[1+(ofs)*2] * c; \ + c = hc[1+(ofs)]; \ + tota1 += decode[2+(ofs)*2] * c; \ + totb1 += decode[3+(ofs)*2] * c; \ + c = hc[2+(ofs)]; \ + tota2 += decode[4+(ofs)*2] * c; \ + totb2 += decode[5+(ofs)*2] * c; + +#define stbir__store_output() \ + output[0] = (tota0+tota2)+(tota1+tota3); \ + output[1] = (totb0+totb2)+(totb1+totb3); \ + horizontal_coefficients += coefficient_width; \ + ++horizontal_contributors; \ + output += 2; + +#endif + +#define STBIR__horizontal_channels 2 +#define STB_IMAGE_RESIZE_DO_HORIZONTALS +#include STBIR__HEADER_FILENAME + + +//================= +// Do 3 channel horizontal routines + +#ifdef STBIR_SIMD + +#define stbir__1_coeff_only() \ + stbir__simdf tot,c,d; \ + STBIR_SIMD_NO_UNROLL(decode); \ + stbir__simdf_load1z( c, hc ); \ + stbir__simdf_0123to0001( c, c ); \ + stbir__simdf_load( d, decode ); \ + stbir__simdf_mult( tot, d, c ); + +#define stbir__2_coeff_only() \ + stbir__simdf tot,c,cs,d; \ + STBIR_SIMD_NO_UNROLL(decode); \ + stbir__simdf_load2( cs, hc ); \ + stbir__simdf_0123to0000( c, cs ); \ + stbir__simdf_load( d, decode ); \ + stbir__simdf_mult( tot, d, c ); \ + stbir__simdf_0123to1111( c, cs ); \ + stbir__simdf_load( d, decode+3 ); \ + stbir__simdf_madd( tot, tot, d, c ); + +#define stbir__3_coeff_only() \ + stbir__simdf tot,c,d,cs; \ + STBIR_SIMD_NO_UNROLL(decode); \ + stbir__simdf_load( cs, hc ); \ + stbir__simdf_0123to0000( c, cs ); \ + stbir__simdf_load( d, decode ); \ + stbir__simdf_mult( tot, d, c ); \ + stbir__simdf_0123to1111( c, cs ); \ + stbir__simdf_load( d, decode+3 ); \ + stbir__simdf_madd( tot, tot, d, c ); \ + stbir__simdf_0123to2222( c, cs ); \ + stbir__simdf_load( d, decode+6 ); \ + stbir__simdf_madd( tot, tot, d, c ); + +#define stbir__store_output_tiny() \ + stbir__simdf_store2( output, tot ); \ + stbir__simdf_0123to2301( tot, tot ); \ + stbir__simdf_store1( output+2, tot ); \ + horizontal_coefficients += coefficient_width; \ + ++horizontal_contributors; \ + output += 3; + +#ifdef STBIR_SIMD8 + +// we're loading from the XXXYYY decode by -1 to get the XXXYYY into different halves of the AVX reg fyi +#define stbir__4_coeff_start() \ + stbir__simdf8 tot0,tot1,c,cs; stbir__simdf t; \ + STBIR_SIMD_NO_UNROLL(decode); \ + stbir__simdf8_load4b( cs, hc ); \ + stbir__simdf8_0123to00001111( c, cs ); \ + stbir__simdf8_mult_mem( tot0, c, decode - 1 ); \ + stbir__simdf8_0123to22223333( c, cs ); \ + stbir__simdf8_mult_mem( tot1, c, decode+6 - 1 ); + +#define stbir__4_coeff_continue_from_4( ofs ) \ + STBIR_SIMD_NO_UNROLL(decode); \ + stbir__simdf8_load4b( cs, hc + (ofs) ); \ + stbir__simdf8_0123to00001111( c, cs ); \ + stbir__simdf8_madd_mem( tot0, tot0, c, decode+(ofs)*3 - 1 ); \ + stbir__simdf8_0123to22223333( c, cs ); \ + stbir__simdf8_madd_mem( tot1, tot1, c, decode+(ofs)*3 + 6 - 1 ); + +#define stbir__1_coeff_remnant( ofs ) \ + STBIR_SIMD_NO_UNROLL(decode); \ + stbir__simdf_load1rep4( t, hc + (ofs) ); \ + stbir__simdf8_madd_mem4( tot0, tot0, t, decode+(ofs)*3 - 1 ); + +#define stbir__2_coeff_remnant( ofs ) \ + STBIR_SIMD_NO_UNROLL(decode); \ + stbir__simdf8_load4b( cs, hc + (ofs) - 2 ); \ + stbir__simdf8_0123to22223333( c, cs ); \ + stbir__simdf8_madd_mem( tot0, tot0, c, decode+(ofs)*3 - 1 ); + + #define stbir__3_coeff_remnant( ofs ) \ + STBIR_SIMD_NO_UNROLL(decode); \ + stbir__simdf8_load4b( cs, hc + (ofs) ); \ + stbir__simdf8_0123to00001111( c, cs ); \ + stbir__simdf8_madd_mem( tot0, tot0, c, decode+(ofs)*3 - 1 ); \ + stbir__simdf8_0123to2222( t, cs ); \ + stbir__simdf8_madd_mem4( tot1, tot1, t, decode+(ofs)*3 + 6 - 1 ); + +#define stbir__store_output() \ + stbir__simdf8_add( tot0, tot0, tot1 ); \ + stbir__simdf_0123to1230( t, stbir__if_simdf8_cast_to_simdf4( tot0 ) ); \ + stbir__simdf8_add4halves( t, t, tot0 ); \ + horizontal_coefficients += coefficient_width; \ + ++horizontal_contributors; \ + output += 3; \ + if ( output < output_end ) \ + { \ + stbir__simdf_store( output-3, t ); \ + continue; \ + } \ + { stbir__simdf tt; stbir__simdf_0123to2301( tt, t ); \ + stbir__simdf_store2( output-3, t ); \ + stbir__simdf_store1( output+2-3, tt ); } \ + break; + + +#else + +#define stbir__4_coeff_start() \ + stbir__simdf tot0,tot1,tot2,c,cs; \ + STBIR_SIMD_NO_UNROLL(decode); \ + stbir__simdf_load( cs, hc ); \ + stbir__simdf_0123to0001( c, cs ); \ + stbir__simdf_mult_mem( tot0, c, decode ); \ + stbir__simdf_0123to1122( c, cs ); \ + stbir__simdf_mult_mem( tot1, c, decode+4 ); \ + stbir__simdf_0123to2333( c, cs ); \ + stbir__simdf_mult_mem( tot2, c, decode+8 ); + +#define stbir__4_coeff_continue_from_4( ofs ) \ + STBIR_SIMD_NO_UNROLL(decode); \ + stbir__simdf_load( cs, hc + (ofs) ); \ + stbir__simdf_0123to0001( c, cs ); \ + stbir__simdf_madd_mem( tot0, tot0, c, decode+(ofs)*3 ); \ + stbir__simdf_0123to1122( c, cs ); \ + stbir__simdf_madd_mem( tot1, tot1, c, decode+(ofs)*3+4 ); \ + stbir__simdf_0123to2333( c, cs ); \ + stbir__simdf_madd_mem( tot2, tot2, c, decode+(ofs)*3+8 ); + +#define stbir__1_coeff_remnant( ofs ) \ + STBIR_SIMD_NO_UNROLL(decode); \ + stbir__simdf_load1z( c, hc + (ofs) ); \ + stbir__simdf_0123to0001( c, c ); \ + stbir__simdf_madd_mem( tot0, tot0, c, decode+(ofs)*3 ); + +#define stbir__2_coeff_remnant( ofs ) \ + { stbir__simdf d; \ + STBIR_SIMD_NO_UNROLL(decode); \ + stbir__simdf_load2z( cs, hc + (ofs) ); \ + stbir__simdf_0123to0001( c, cs ); \ + stbir__simdf_madd_mem( tot0, tot0, c, decode+(ofs)*3 ); \ + stbir__simdf_0123to1122( c, cs ); \ + stbir__simdf_load2z( d, decode+(ofs)*3+4 ); \ + stbir__simdf_madd( tot1, tot1, c, d ); } + +#define stbir__3_coeff_remnant( ofs ) \ + { stbir__simdf d; \ + STBIR_SIMD_NO_UNROLL(decode); \ + stbir__simdf_load( cs, hc + (ofs) ); \ + stbir__simdf_0123to0001( c, cs ); \ + stbir__simdf_madd_mem( tot0, tot0, c, decode+(ofs)*3 ); \ + stbir__simdf_0123to1122( c, cs ); \ + stbir__simdf_madd_mem( tot1, tot1, c, decode+(ofs)*3+4 ); \ + stbir__simdf_0123to2222( c, cs ); \ + stbir__simdf_load1z( d, decode+(ofs)*3+8 ); \ + stbir__simdf_madd( tot2, tot2, c, d ); } + +#define stbir__store_output() \ + stbir__simdf_0123ABCDto3ABx( c, tot0, tot1 ); \ + stbir__simdf_0123ABCDto23Ax( cs, tot1, tot2 ); \ + stbir__simdf_0123to1230( tot2, tot2 ); \ + stbir__simdf_add( tot0, tot0, cs ); \ + stbir__simdf_add( c, c, tot2 ); \ + stbir__simdf_add( tot0, tot0, c ); \ + horizontal_coefficients += coefficient_width; \ + ++horizontal_contributors; \ + output += 3; \ + if ( output < output_end ) \ + { \ + stbir__simdf_store( output-3, tot0 ); \ + continue; \ + } \ + stbir__simdf_0123to2301( tot1, tot0 ); \ + stbir__simdf_store2( output-3, tot0 ); \ + stbir__simdf_store1( output+2-3, tot1 ); \ + break; + +#endif + +#else + +#define stbir__1_coeff_only() \ + float tot0, tot1, tot2, c; \ + c = hc[0]; \ + tot0 = decode[0]*c; \ + tot1 = decode[1]*c; \ + tot2 = decode[2]*c; + +#define stbir__2_coeff_only() \ + float tot0, tot1, tot2, c; \ + c = hc[0]; \ + tot0 = decode[0]*c; \ + tot1 = decode[1]*c; \ + tot2 = decode[2]*c; \ + c = hc[1]; \ + tot0 += decode[3]*c; \ + tot1 += decode[4]*c; \ + tot2 += decode[5]*c; + +#define stbir__3_coeff_only() \ + float tot0, tot1, tot2, c; \ + c = hc[0]; \ + tot0 = decode[0]*c; \ + tot1 = decode[1]*c; \ + tot2 = decode[2]*c; \ + c = hc[1]; \ + tot0 += decode[3]*c; \ + tot1 += decode[4]*c; \ + tot2 += decode[5]*c; \ + c = hc[2]; \ + tot0 += decode[6]*c; \ + tot1 += decode[7]*c; \ + tot2 += decode[8]*c; + +#define stbir__store_output_tiny() \ + output[0] = tot0; \ + output[1] = tot1; \ + output[2] = tot2; \ + horizontal_coefficients += coefficient_width; \ + ++horizontal_contributors; \ + output += 3; + +#define stbir__4_coeff_start() \ + float tota0,tota1,tota2,totb0,totb1,totb2,totc0,totc1,totc2,totd0,totd1,totd2,c; \ + c = hc[0]; \ + tota0 = decode[0]*c; \ + tota1 = decode[1]*c; \ + tota2 = decode[2]*c; \ + c = hc[1]; \ + totb0 = decode[3]*c; \ + totb1 = decode[4]*c; \ + totb2 = decode[5]*c; \ + c = hc[2]; \ + totc0 = decode[6]*c; \ + totc1 = decode[7]*c; \ + totc2 = decode[8]*c; \ + c = hc[3]; \ + totd0 = decode[9]*c; \ + totd1 = decode[10]*c; \ + totd2 = decode[11]*c; + +#define stbir__4_coeff_continue_from_4( ofs ) \ + c = hc[0+(ofs)]; \ + tota0 += decode[0+(ofs)*3]*c; \ + tota1 += decode[1+(ofs)*3]*c; \ + tota2 += decode[2+(ofs)*3]*c; \ + c = hc[1+(ofs)]; \ + totb0 += decode[3+(ofs)*3]*c; \ + totb1 += decode[4+(ofs)*3]*c; \ + totb2 += decode[5+(ofs)*3]*c; \ + c = hc[2+(ofs)]; \ + totc0 += decode[6+(ofs)*3]*c; \ + totc1 += decode[7+(ofs)*3]*c; \ + totc2 += decode[8+(ofs)*3]*c; \ + c = hc[3+(ofs)]; \ + totd0 += decode[9+(ofs)*3]*c; \ + totd1 += decode[10+(ofs)*3]*c; \ + totd2 += decode[11+(ofs)*3]*c; + +#define stbir__1_coeff_remnant( ofs ) \ + c = hc[0+(ofs)]; \ + tota0 += decode[0+(ofs)*3]*c; \ + tota1 += decode[1+(ofs)*3]*c; \ + tota2 += decode[2+(ofs)*3]*c; + +#define stbir__2_coeff_remnant( ofs ) \ + c = hc[0+(ofs)]; \ + tota0 += decode[0+(ofs)*3]*c; \ + tota1 += decode[1+(ofs)*3]*c; \ + tota2 += decode[2+(ofs)*3]*c; \ + c = hc[1+(ofs)]; \ + totb0 += decode[3+(ofs)*3]*c; \ + totb1 += decode[4+(ofs)*3]*c; \ + totb2 += decode[5+(ofs)*3]*c; \ + +#define stbir__3_coeff_remnant( ofs ) \ + c = hc[0+(ofs)]; \ + tota0 += decode[0+(ofs)*3]*c; \ + tota1 += decode[1+(ofs)*3]*c; \ + tota2 += decode[2+(ofs)*3]*c; \ + c = hc[1+(ofs)]; \ + totb0 += decode[3+(ofs)*3]*c; \ + totb1 += decode[4+(ofs)*3]*c; \ + totb2 += decode[5+(ofs)*3]*c; \ + c = hc[2+(ofs)]; \ + totc0 += decode[6+(ofs)*3]*c; \ + totc1 += decode[7+(ofs)*3]*c; \ + totc2 += decode[8+(ofs)*3]*c; + +#define stbir__store_output() \ + output[0] = (tota0+totc0)+(totb0+totd0); \ + output[1] = (tota1+totc1)+(totb1+totd1); \ + output[2] = (tota2+totc2)+(totb2+totd2); \ + horizontal_coefficients += coefficient_width; \ + ++horizontal_contributors; \ + output += 3; + +#endif + +#define STBIR__horizontal_channels 3 +#define STB_IMAGE_RESIZE_DO_HORIZONTALS +#include STBIR__HEADER_FILENAME + +//================= +// Do 4 channel horizontal routines + +#ifdef STBIR_SIMD + +#define stbir__1_coeff_only() \ + stbir__simdf tot,c; \ + STBIR_SIMD_NO_UNROLL(decode); \ + stbir__simdf_load1( c, hc ); \ + stbir__simdf_0123to0000( c, c ); \ + stbir__simdf_mult_mem( tot, c, decode ); + +#define stbir__2_coeff_only() \ + stbir__simdf tot,c,cs; \ + STBIR_SIMD_NO_UNROLL(decode); \ + stbir__simdf_load2( cs, hc ); \ + stbir__simdf_0123to0000( c, cs ); \ + stbir__simdf_mult_mem( tot, c, decode ); \ + stbir__simdf_0123to1111( c, cs ); \ + stbir__simdf_madd_mem( tot, tot, c, decode+4 ); + +#define stbir__3_coeff_only() \ + stbir__simdf tot,c,cs; \ + STBIR_SIMD_NO_UNROLL(decode); \ + stbir__simdf_load( cs, hc ); \ + stbir__simdf_0123to0000( c, cs ); \ + stbir__simdf_mult_mem( tot, c, decode ); \ + stbir__simdf_0123to1111( c, cs ); \ + stbir__simdf_madd_mem( tot, tot, c, decode+4 ); \ + stbir__simdf_0123to2222( c, cs ); \ + stbir__simdf_madd_mem( tot, tot, c, decode+8 ); + +#define stbir__store_output_tiny() \ + stbir__simdf_store( output, tot ); \ + horizontal_coefficients += coefficient_width; \ + ++horizontal_contributors; \ + output += 4; + +#ifdef STBIR_SIMD8 + +#define stbir__4_coeff_start() \ + stbir__simdf8 tot0,c,cs; stbir__simdf t; \ + STBIR_SIMD_NO_UNROLL(decode); \ + stbir__simdf8_load4b( cs, hc ); \ + stbir__simdf8_0123to00001111( c, cs ); \ + stbir__simdf8_mult_mem( tot0, c, decode ); \ + stbir__simdf8_0123to22223333( c, cs ); \ + stbir__simdf8_madd_mem( tot0, tot0, c, decode+8 ); + +#define stbir__4_coeff_continue_from_4( ofs ) \ + STBIR_SIMD_NO_UNROLL(decode); \ + stbir__simdf8_load4b( cs, hc + (ofs) ); \ + stbir__simdf8_0123to00001111( c, cs ); \ + stbir__simdf8_madd_mem( tot0, tot0, c, decode+(ofs)*4 ); \ + stbir__simdf8_0123to22223333( c, cs ); \ + stbir__simdf8_madd_mem( tot0, tot0, c, decode+(ofs)*4+8 ); + +#define stbir__1_coeff_remnant( ofs ) \ + STBIR_SIMD_NO_UNROLL(decode); \ + stbir__simdf_load1rep4( t, hc + (ofs) ); \ + stbir__simdf8_madd_mem4( tot0, tot0, t, decode+(ofs)*4 ); + +#define stbir__2_coeff_remnant( ofs ) \ + STBIR_SIMD_NO_UNROLL(decode); \ + stbir__simdf8_load4b( cs, hc + (ofs) - 2 ); \ + stbir__simdf8_0123to22223333( c, cs ); \ + stbir__simdf8_madd_mem( tot0, tot0, c, decode+(ofs)*4 ); + + #define stbir__3_coeff_remnant( ofs ) \ + STBIR_SIMD_NO_UNROLL(decode); \ + stbir__simdf8_load4b( cs, hc + (ofs) ); \ + stbir__simdf8_0123to00001111( c, cs ); \ + stbir__simdf8_madd_mem( tot0, tot0, c, decode+(ofs)*4 ); \ + stbir__simdf8_0123to2222( t, cs ); \ + stbir__simdf8_madd_mem4( tot0, tot0, t, decode+(ofs)*4+8 ); + +#define stbir__store_output() \ + stbir__simdf8_add4halves( t, stbir__if_simdf8_cast_to_simdf4(tot0), tot0 ); \ + stbir__simdf_store( output, t ); \ + horizontal_coefficients += coefficient_width; \ + ++horizontal_contributors; \ + output += 4; + +#else + +#define stbir__4_coeff_start() \ + stbir__simdf tot0,tot1,c,cs; \ + STBIR_SIMD_NO_UNROLL(decode); \ + stbir__simdf_load( cs, hc ); \ + stbir__simdf_0123to0000( c, cs ); \ + stbir__simdf_mult_mem( tot0, c, decode ); \ + stbir__simdf_0123to1111( c, cs ); \ + stbir__simdf_mult_mem( tot1, c, decode+4 ); \ + stbir__simdf_0123to2222( c, cs ); \ + stbir__simdf_madd_mem( tot0, tot0, c, decode+8 ); \ + stbir__simdf_0123to3333( c, cs ); \ + stbir__simdf_madd_mem( tot1, tot1, c, decode+12 ); + +#define stbir__4_coeff_continue_from_4( ofs ) \ + STBIR_SIMD_NO_UNROLL(decode); \ + stbir__simdf_load( cs, hc + (ofs) ); \ + stbir__simdf_0123to0000( c, cs ); \ + stbir__simdf_madd_mem( tot0, tot0, c, decode+(ofs)*4 ); \ + stbir__simdf_0123to1111( c, cs ); \ + stbir__simdf_madd_mem( tot1, tot1, c, decode+(ofs)*4+4 ); \ + stbir__simdf_0123to2222( c, cs ); \ + stbir__simdf_madd_mem( tot0, tot0, c, decode+(ofs)*4+8 ); \ + stbir__simdf_0123to3333( c, cs ); \ + stbir__simdf_madd_mem( tot1, tot1, c, decode+(ofs)*4+12 ); + +#define stbir__1_coeff_remnant( ofs ) \ + STBIR_SIMD_NO_UNROLL(decode); \ + stbir__simdf_load1( c, hc + (ofs) ); \ + stbir__simdf_0123to0000( c, c ); \ + stbir__simdf_madd_mem( tot0, tot0, c, decode+(ofs)*4 ); + +#define stbir__2_coeff_remnant( ofs ) \ + STBIR_SIMD_NO_UNROLL(decode); \ + stbir__simdf_load2( cs, hc + (ofs) ); \ + stbir__simdf_0123to0000( c, cs ); \ + stbir__simdf_madd_mem( tot0, tot0, c, decode+(ofs)*4 ); \ + stbir__simdf_0123to1111( c, cs ); \ + stbir__simdf_madd_mem( tot1, tot1, c, decode+(ofs)*4+4 ); + +#define stbir__3_coeff_remnant( ofs ) \ + STBIR_SIMD_NO_UNROLL(decode); \ + stbir__simdf_load( cs, hc + (ofs) ); \ + stbir__simdf_0123to0000( c, cs ); \ + stbir__simdf_madd_mem( tot0, tot0, c, decode+(ofs)*4 ); \ + stbir__simdf_0123to1111( c, cs ); \ + stbir__simdf_madd_mem( tot1, tot1, c, decode+(ofs)*4+4 ); \ + stbir__simdf_0123to2222( c, cs ); \ + stbir__simdf_madd_mem( tot0, tot0, c, decode+(ofs)*4+8 ); + +#define stbir__store_output() \ + stbir__simdf_add( tot0, tot0, tot1 ); \ + stbir__simdf_store( output, tot0 ); \ + horizontal_coefficients += coefficient_width; \ + ++horizontal_contributors; \ + output += 4; + +#endif + +#else + +#define stbir__1_coeff_only() \ + float p0,p1,p2,p3,c; \ + STBIR_SIMD_NO_UNROLL(decode); \ + c = hc[0]; \ + p0 = decode[0] * c; \ + p1 = decode[1] * c; \ + p2 = decode[2] * c; \ + p3 = decode[3] * c; + +#define stbir__2_coeff_only() \ + float p0,p1,p2,p3,c; \ + STBIR_SIMD_NO_UNROLL(decode); \ + c = hc[0]; \ + p0 = decode[0] * c; \ + p1 = decode[1] * c; \ + p2 = decode[2] * c; \ + p3 = decode[3] * c; \ + c = hc[1]; \ + p0 += decode[4] * c; \ + p1 += decode[5] * c; \ + p2 += decode[6] * c; \ + p3 += decode[7] * c; + +#define stbir__3_coeff_only() \ + float p0,p1,p2,p3,c; \ + STBIR_SIMD_NO_UNROLL(decode); \ + c = hc[0]; \ + p0 = decode[0] * c; \ + p1 = decode[1] * c; \ + p2 = decode[2] * c; \ + p3 = decode[3] * c; \ + c = hc[1]; \ + p0 += decode[4] * c; \ + p1 += decode[5] * c; \ + p2 += decode[6] * c; \ + p3 += decode[7] * c; \ + c = hc[2]; \ + p0 += decode[8] * c; \ + p1 += decode[9] * c; \ + p2 += decode[10] * c; \ + p3 += decode[11] * c; + +#define stbir__store_output_tiny() \ + output[0] = p0; \ + output[1] = p1; \ + output[2] = p2; \ + output[3] = p3; \ + horizontal_coefficients += coefficient_width; \ + ++horizontal_contributors; \ + output += 4; + +#define stbir__4_coeff_start() \ + float x0,x1,x2,x3,y0,y1,y2,y3,c; \ + STBIR_SIMD_NO_UNROLL(decode); \ + c = hc[0]; \ + x0 = decode[0] * c; \ + x1 = decode[1] * c; \ + x2 = decode[2] * c; \ + x3 = decode[3] * c; \ + c = hc[1]; \ + y0 = decode[4] * c; \ + y1 = decode[5] * c; \ + y2 = decode[6] * c; \ + y3 = decode[7] * c; \ + c = hc[2]; \ + x0 += decode[8] * c; \ + x1 += decode[9] * c; \ + x2 += decode[10] * c; \ + x3 += decode[11] * c; \ + c = hc[3]; \ + y0 += decode[12] * c; \ + y1 += decode[13] * c; \ + y2 += decode[14] * c; \ + y3 += decode[15] * c; + +#define stbir__4_coeff_continue_from_4( ofs ) \ + STBIR_SIMD_NO_UNROLL(decode); \ + c = hc[0+(ofs)]; \ + x0 += decode[0+(ofs)*4] * c; \ + x1 += decode[1+(ofs)*4] * c; \ + x2 += decode[2+(ofs)*4] * c; \ + x3 += decode[3+(ofs)*4] * c; \ + c = hc[1+(ofs)]; \ + y0 += decode[4+(ofs)*4] * c; \ + y1 += decode[5+(ofs)*4] * c; \ + y2 += decode[6+(ofs)*4] * c; \ + y3 += decode[7+(ofs)*4] * c; \ + c = hc[2+(ofs)]; \ + x0 += decode[8+(ofs)*4] * c; \ + x1 += decode[9+(ofs)*4] * c; \ + x2 += decode[10+(ofs)*4] * c; \ + x3 += decode[11+(ofs)*4] * c; \ + c = hc[3+(ofs)]; \ + y0 += decode[12+(ofs)*4] * c; \ + y1 += decode[13+(ofs)*4] * c; \ + y2 += decode[14+(ofs)*4] * c; \ + y3 += decode[15+(ofs)*4] * c; + +#define stbir__1_coeff_remnant( ofs ) \ + STBIR_SIMD_NO_UNROLL(decode); \ + c = hc[0+(ofs)]; \ + x0 += decode[0+(ofs)*4] * c; \ + x1 += decode[1+(ofs)*4] * c; \ + x2 += decode[2+(ofs)*4] * c; \ + x3 += decode[3+(ofs)*4] * c; + +#define stbir__2_coeff_remnant( ofs ) \ + STBIR_SIMD_NO_UNROLL(decode); \ + c = hc[0+(ofs)]; \ + x0 += decode[0+(ofs)*4] * c; \ + x1 += decode[1+(ofs)*4] * c; \ + x2 += decode[2+(ofs)*4] * c; \ + x3 += decode[3+(ofs)*4] * c; \ + c = hc[1+(ofs)]; \ + y0 += decode[4+(ofs)*4] * c; \ + y1 += decode[5+(ofs)*4] * c; \ + y2 += decode[6+(ofs)*4] * c; \ + y3 += decode[7+(ofs)*4] * c; + +#define stbir__3_coeff_remnant( ofs ) \ + STBIR_SIMD_NO_UNROLL(decode); \ + c = hc[0+(ofs)]; \ + x0 += decode[0+(ofs)*4] * c; \ + x1 += decode[1+(ofs)*4] * c; \ + x2 += decode[2+(ofs)*4] * c; \ + x3 += decode[3+(ofs)*4] * c; \ + c = hc[1+(ofs)]; \ + y0 += decode[4+(ofs)*4] * c; \ + y1 += decode[5+(ofs)*4] * c; \ + y2 += decode[6+(ofs)*4] * c; \ + y3 += decode[7+(ofs)*4] * c; \ + c = hc[2+(ofs)]; \ + x0 += decode[8+(ofs)*4] * c; \ + x1 += decode[9+(ofs)*4] * c; \ + x2 += decode[10+(ofs)*4] * c; \ + x3 += decode[11+(ofs)*4] * c; + +#define stbir__store_output() \ + output[0] = x0 + y0; \ + output[1] = x1 + y1; \ + output[2] = x2 + y2; \ + output[3] = x3 + y3; \ + horizontal_coefficients += coefficient_width; \ + ++horizontal_contributors; \ + output += 4; + +#endif + +#define STBIR__horizontal_channels 4 +#define STB_IMAGE_RESIZE_DO_HORIZONTALS +#include STBIR__HEADER_FILENAME + + + +//================= +// Do 7 channel horizontal routines + +#ifdef STBIR_SIMD + +#define stbir__1_coeff_only() \ + stbir__simdf tot0,tot1,c; \ + STBIR_SIMD_NO_UNROLL(decode); \ + stbir__simdf_load1( c, hc ); \ + stbir__simdf_0123to0000( c, c ); \ + stbir__simdf_mult_mem( tot0, c, decode ); \ + stbir__simdf_mult_mem( tot1, c, decode+3 ); + +#define stbir__2_coeff_only() \ + stbir__simdf tot0,tot1,c,cs; \ + STBIR_SIMD_NO_UNROLL(decode); \ + stbir__simdf_load2( cs, hc ); \ + stbir__simdf_0123to0000( c, cs ); \ + stbir__simdf_mult_mem( tot0, c, decode ); \ + stbir__simdf_mult_mem( tot1, c, decode+3 ); \ + stbir__simdf_0123to1111( c, cs ); \ + stbir__simdf_madd_mem( tot0, tot0, c, decode+7 ); \ + stbir__simdf_madd_mem( tot1, tot1, c,decode+10 ); + +#define stbir__3_coeff_only() \ + stbir__simdf tot0,tot1,c,cs; \ + STBIR_SIMD_NO_UNROLL(decode); \ + stbir__simdf_load( cs, hc ); \ + stbir__simdf_0123to0000( c, cs ); \ + stbir__simdf_mult_mem( tot0, c, decode ); \ + stbir__simdf_mult_mem( tot1, c, decode+3 ); \ + stbir__simdf_0123to1111( c, cs ); \ + stbir__simdf_madd_mem( tot0, tot0, c, decode+7 ); \ + stbir__simdf_madd_mem( tot1, tot1, c, decode+10 ); \ + stbir__simdf_0123to2222( c, cs ); \ + stbir__simdf_madd_mem( tot0, tot0, c, decode+14 ); \ + stbir__simdf_madd_mem( tot1, tot1, c, decode+17 ); + +#define stbir__store_output_tiny() \ + stbir__simdf_store( output+3, tot1 ); \ + stbir__simdf_store( output, tot0 ); \ + horizontal_coefficients += coefficient_width; \ + ++horizontal_contributors; \ + output += 7; + +#ifdef STBIR_SIMD8 + +#define stbir__4_coeff_start() \ + stbir__simdf8 tot0,tot1,c,cs; \ + STBIR_SIMD_NO_UNROLL(decode); \ + stbir__simdf8_load4b( cs, hc ); \ + stbir__simdf8_0123to00000000( c, cs ); \ + stbir__simdf8_mult_mem( tot0, c, decode ); \ + stbir__simdf8_0123to11111111( c, cs ); \ + stbir__simdf8_mult_mem( tot1, c, decode+7 ); \ + stbir__simdf8_0123to22222222( c, cs ); \ + stbir__simdf8_madd_mem( tot0, tot0, c, decode+14 ); \ + stbir__simdf8_0123to33333333( c, cs ); \ + stbir__simdf8_madd_mem( tot1, tot1, c, decode+21 ); + +#define stbir__4_coeff_continue_from_4( ofs ) \ + STBIR_SIMD_NO_UNROLL(decode); \ + stbir__simdf8_load4b( cs, hc + (ofs) ); \ + stbir__simdf8_0123to00000000( c, cs ); \ + stbir__simdf8_madd_mem( tot0, tot0, c, decode+(ofs)*7 ); \ + stbir__simdf8_0123to11111111( c, cs ); \ + stbir__simdf8_madd_mem( tot1, tot1, c, decode+(ofs)*7+7 ); \ + stbir__simdf8_0123to22222222( c, cs ); \ + stbir__simdf8_madd_mem( tot0, tot0, c, decode+(ofs)*7+14 ); \ + stbir__simdf8_0123to33333333( c, cs ); \ + stbir__simdf8_madd_mem( tot1, tot1, c, decode+(ofs)*7+21 ); + +#define stbir__1_coeff_remnant( ofs ) \ + STBIR_SIMD_NO_UNROLL(decode); \ + stbir__simdf8_load1b( c, hc + (ofs) ); \ + stbir__simdf8_madd_mem( tot0, tot0, c, decode+(ofs)*7 ); + +#define stbir__2_coeff_remnant( ofs ) \ + STBIR_SIMD_NO_UNROLL(decode); \ + stbir__simdf8_load1b( c, hc + (ofs) ); \ + stbir__simdf8_madd_mem( tot0, tot0, c, decode+(ofs)*7 ); \ + stbir__simdf8_load1b( c, hc + (ofs)+1 ); \ + stbir__simdf8_madd_mem( tot1, tot1, c, decode+(ofs)*7+7 ); + +#define stbir__3_coeff_remnant( ofs ) \ + STBIR_SIMD_NO_UNROLL(decode); \ + stbir__simdf8_load4b( cs, hc + (ofs) ); \ + stbir__simdf8_0123to00000000( c, cs ); \ + stbir__simdf8_madd_mem( tot0, tot0, c, decode+(ofs)*7 ); \ + stbir__simdf8_0123to11111111( c, cs ); \ + stbir__simdf8_madd_mem( tot1, tot1, c, decode+(ofs)*7+7 ); \ + stbir__simdf8_0123to22222222( c, cs ); \ + stbir__simdf8_madd_mem( tot0, tot0, c, decode+(ofs)*7+14 ); + +#define stbir__store_output() \ + stbir__simdf8_add( tot0, tot0, tot1 ); \ + horizontal_coefficients += coefficient_width; \ + ++horizontal_contributors; \ + output += 7; \ + if ( output < output_end ) \ + { \ + stbir__simdf8_store( output-7, tot0 ); \ + continue; \ + } \ + stbir__simdf_store( output-7+3, stbir__simdf_swiz(stbir__simdf8_gettop4(tot0),0,0,1,2) ); \ + stbir__simdf_store( output-7, stbir__if_simdf8_cast_to_simdf4(tot0) ); \ + break; + +#else + +#define stbir__4_coeff_start() \ + stbir__simdf tot0,tot1,tot2,tot3,c,cs; \ + STBIR_SIMD_NO_UNROLL(decode); \ + stbir__simdf_load( cs, hc ); \ + stbir__simdf_0123to0000( c, cs ); \ + stbir__simdf_mult_mem( tot0, c, decode ); \ + stbir__simdf_mult_mem( tot1, c, decode+3 ); \ + stbir__simdf_0123to1111( c, cs ); \ + stbir__simdf_mult_mem( tot2, c, decode+7 ); \ + stbir__simdf_mult_mem( tot3, c, decode+10 ); \ + stbir__simdf_0123to2222( c, cs ); \ + stbir__simdf_madd_mem( tot0, tot0, c, decode+14 ); \ + stbir__simdf_madd_mem( tot1, tot1, c, decode+17 ); \ + stbir__simdf_0123to3333( c, cs ); \ + stbir__simdf_madd_mem( tot2, tot2, c, decode+21 ); \ + stbir__simdf_madd_mem( tot3, tot3, c, decode+24 ); + +#define stbir__4_coeff_continue_from_4( ofs ) \ + STBIR_SIMD_NO_UNROLL(decode); \ + stbir__simdf_load( cs, hc + (ofs) ); \ + stbir__simdf_0123to0000( c, cs ); \ + stbir__simdf_madd_mem( tot0, tot0, c, decode+(ofs)*7 ); \ + stbir__simdf_madd_mem( tot1, tot1, c, decode+(ofs)*7+3 ); \ + stbir__simdf_0123to1111( c, cs ); \ + stbir__simdf_madd_mem( tot2, tot2, c, decode+(ofs)*7+7 ); \ + stbir__simdf_madd_mem( tot3, tot3, c, decode+(ofs)*7+10 ); \ + stbir__simdf_0123to2222( c, cs ); \ + stbir__simdf_madd_mem( tot0, tot0, c, decode+(ofs)*7+14 ); \ + stbir__simdf_madd_mem( tot1, tot1, c, decode+(ofs)*7+17 ); \ + stbir__simdf_0123to3333( c, cs ); \ + stbir__simdf_madd_mem( tot2, tot2, c, decode+(ofs)*7+21 ); \ + stbir__simdf_madd_mem( tot3, tot3, c, decode+(ofs)*7+24 ); + +#define stbir__1_coeff_remnant( ofs ) \ + STBIR_SIMD_NO_UNROLL(decode); \ + stbir__simdf_load1( c, hc + (ofs) ); \ + stbir__simdf_0123to0000( c, c ); \ + stbir__simdf_madd_mem( tot0, tot0, c, decode+(ofs)*7 ); \ + stbir__simdf_madd_mem( tot1, tot1, c, decode+(ofs)*7+3 ); \ + +#define stbir__2_coeff_remnant( ofs ) \ + STBIR_SIMD_NO_UNROLL(decode); \ + stbir__simdf_load2( cs, hc + (ofs) ); \ + stbir__simdf_0123to0000( c, cs ); \ + stbir__simdf_madd_mem( tot0, tot0, c, decode+(ofs)*7 ); \ + stbir__simdf_madd_mem( tot1, tot1, c, decode+(ofs)*7+3 ); \ + stbir__simdf_0123to1111( c, cs ); \ + stbir__simdf_madd_mem( tot2, tot2, c, decode+(ofs)*7+7 ); \ + stbir__simdf_madd_mem( tot3, tot3, c, decode+(ofs)*7+10 ); + +#define stbir__3_coeff_remnant( ofs ) \ + STBIR_SIMD_NO_UNROLL(decode); \ + stbir__simdf_load( cs, hc + (ofs) ); \ + stbir__simdf_0123to0000( c, cs ); \ + stbir__simdf_madd_mem( tot0, tot0, c, decode+(ofs)*7 ); \ + stbir__simdf_madd_mem( tot1, tot1, c, decode+(ofs)*7+3 ); \ + stbir__simdf_0123to1111( c, cs ); \ + stbir__simdf_madd_mem( tot2, tot2, c, decode+(ofs)*7+7 ); \ + stbir__simdf_madd_mem( tot3, tot3, c, decode+(ofs)*7+10 ); \ + stbir__simdf_0123to2222( c, cs ); \ + stbir__simdf_madd_mem( tot0, tot0, c, decode+(ofs)*7+14 ); \ + stbir__simdf_madd_mem( tot1, tot1, c, decode+(ofs)*7+17 ); + +#define stbir__store_output() \ + stbir__simdf_add( tot0, tot0, tot2 ); \ + stbir__simdf_add( tot1, tot1, tot3 ); \ + stbir__simdf_store( output+3, tot1 ); \ + stbir__simdf_store( output, tot0 ); \ + horizontal_coefficients += coefficient_width; \ + ++horizontal_contributors; \ + output += 7; + +#endif + +#else + +#define stbir__1_coeff_only() \ + float tot0, tot1, tot2, tot3, tot4, tot5, tot6, c; \ + c = hc[0]; \ + tot0 = decode[0]*c; \ + tot1 = decode[1]*c; \ + tot2 = decode[2]*c; \ + tot3 = decode[3]*c; \ + tot4 = decode[4]*c; \ + tot5 = decode[5]*c; \ + tot6 = decode[6]*c; + +#define stbir__2_coeff_only() \ + float tot0, tot1, tot2, tot3, tot4, tot5, tot6, c; \ + c = hc[0]; \ + tot0 = decode[0]*c; \ + tot1 = decode[1]*c; \ + tot2 = decode[2]*c; \ + tot3 = decode[3]*c; \ + tot4 = decode[4]*c; \ + tot5 = decode[5]*c; \ + tot6 = decode[6]*c; \ + c = hc[1]; \ + tot0 += decode[7]*c; \ + tot1 += decode[8]*c; \ + tot2 += decode[9]*c; \ + tot3 += decode[10]*c; \ + tot4 += decode[11]*c; \ + tot5 += decode[12]*c; \ + tot6 += decode[13]*c; \ + +#define stbir__3_coeff_only() \ + float tot0, tot1, tot2, tot3, tot4, tot5, tot6, c; \ + c = hc[0]; \ + tot0 = decode[0]*c; \ + tot1 = decode[1]*c; \ + tot2 = decode[2]*c; \ + tot3 = decode[3]*c; \ + tot4 = decode[4]*c; \ + tot5 = decode[5]*c; \ + tot6 = decode[6]*c; \ + c = hc[1]; \ + tot0 += decode[7]*c; \ + tot1 += decode[8]*c; \ + tot2 += decode[9]*c; \ + tot3 += decode[10]*c; \ + tot4 += decode[11]*c; \ + tot5 += decode[12]*c; \ + tot6 += decode[13]*c; \ + c = hc[2]; \ + tot0 += decode[14]*c; \ + tot1 += decode[15]*c; \ + tot2 += decode[16]*c; \ + tot3 += decode[17]*c; \ + tot4 += decode[18]*c; \ + tot5 += decode[19]*c; \ + tot6 += decode[20]*c; \ + +#define stbir__store_output_tiny() \ + output[0] = tot0; \ + output[1] = tot1; \ + output[2] = tot2; \ + output[3] = tot3; \ + output[4] = tot4; \ + output[5] = tot5; \ + output[6] = tot6; \ + horizontal_coefficients += coefficient_width; \ + ++horizontal_contributors; \ + output += 7; + +#define stbir__4_coeff_start() \ + float x0,x1,x2,x3,x4,x5,x6,y0,y1,y2,y3,y4,y5,y6,c; \ + STBIR_SIMD_NO_UNROLL(decode); \ + c = hc[0]; \ + x0 = decode[0] * c; \ + x1 = decode[1] * c; \ + x2 = decode[2] * c; \ + x3 = decode[3] * c; \ + x4 = decode[4] * c; \ + x5 = decode[5] * c; \ + x6 = decode[6] * c; \ + c = hc[1]; \ + y0 = decode[7] * c; \ + y1 = decode[8] * c; \ + y2 = decode[9] * c; \ + y3 = decode[10] * c; \ + y4 = decode[11] * c; \ + y5 = decode[12] * c; \ + y6 = decode[13] * c; \ + c = hc[2]; \ + x0 += decode[14] * c; \ + x1 += decode[15] * c; \ + x2 += decode[16] * c; \ + x3 += decode[17] * c; \ + x4 += decode[18] * c; \ + x5 += decode[19] * c; \ + x6 += decode[20] * c; \ + c = hc[3]; \ + y0 += decode[21] * c; \ + y1 += decode[22] * c; \ + y2 += decode[23] * c; \ + y3 += decode[24] * c; \ + y4 += decode[25] * c; \ + y5 += decode[26] * c; \ + y6 += decode[27] * c; + +#define stbir__4_coeff_continue_from_4( ofs ) \ + STBIR_SIMD_NO_UNROLL(decode); \ + c = hc[0+(ofs)]; \ + x0 += decode[0+(ofs)*7] * c; \ + x1 += decode[1+(ofs)*7] * c; \ + x2 += decode[2+(ofs)*7] * c; \ + x3 += decode[3+(ofs)*7] * c; \ + x4 += decode[4+(ofs)*7] * c; \ + x5 += decode[5+(ofs)*7] * c; \ + x6 += decode[6+(ofs)*7] * c; \ + c = hc[1+(ofs)]; \ + y0 += decode[7+(ofs)*7] * c; \ + y1 += decode[8+(ofs)*7] * c; \ + y2 += decode[9+(ofs)*7] * c; \ + y3 += decode[10+(ofs)*7] * c; \ + y4 += decode[11+(ofs)*7] * c; \ + y5 += decode[12+(ofs)*7] * c; \ + y6 += decode[13+(ofs)*7] * c; \ + c = hc[2+(ofs)]; \ + x0 += decode[14+(ofs)*7] * c; \ + x1 += decode[15+(ofs)*7] * c; \ + x2 += decode[16+(ofs)*7] * c; \ + x3 += decode[17+(ofs)*7] * c; \ + x4 += decode[18+(ofs)*7] * c; \ + x5 += decode[19+(ofs)*7] * c; \ + x6 += decode[20+(ofs)*7] * c; \ + c = hc[3+(ofs)]; \ + y0 += decode[21+(ofs)*7] * c; \ + y1 += decode[22+(ofs)*7] * c; \ + y2 += decode[23+(ofs)*7] * c; \ + y3 += decode[24+(ofs)*7] * c; \ + y4 += decode[25+(ofs)*7] * c; \ + y5 += decode[26+(ofs)*7] * c; \ + y6 += decode[27+(ofs)*7] * c; + +#define stbir__1_coeff_remnant( ofs ) \ + STBIR_SIMD_NO_UNROLL(decode); \ + c = hc[0+(ofs)]; \ + x0 += decode[0+(ofs)*7] * c; \ + x1 += decode[1+(ofs)*7] * c; \ + x2 += decode[2+(ofs)*7] * c; \ + x3 += decode[3+(ofs)*7] * c; \ + x4 += decode[4+(ofs)*7] * c; \ + x5 += decode[5+(ofs)*7] * c; \ + x6 += decode[6+(ofs)*7] * c; \ + +#define stbir__2_coeff_remnant( ofs ) \ + STBIR_SIMD_NO_UNROLL(decode); \ + c = hc[0+(ofs)]; \ + x0 += decode[0+(ofs)*7] * c; \ + x1 += decode[1+(ofs)*7] * c; \ + x2 += decode[2+(ofs)*7] * c; \ + x3 += decode[3+(ofs)*7] * c; \ + x4 += decode[4+(ofs)*7] * c; \ + x5 += decode[5+(ofs)*7] * c; \ + x6 += decode[6+(ofs)*7] * c; \ + c = hc[1+(ofs)]; \ + y0 += decode[7+(ofs)*7] * c; \ + y1 += decode[8+(ofs)*7] * c; \ + y2 += decode[9+(ofs)*7] * c; \ + y3 += decode[10+(ofs)*7] * c; \ + y4 += decode[11+(ofs)*7] * c; \ + y5 += decode[12+(ofs)*7] * c; \ + y6 += decode[13+(ofs)*7] * c; \ + +#define stbir__3_coeff_remnant( ofs ) \ + STBIR_SIMD_NO_UNROLL(decode); \ + c = hc[0+(ofs)]; \ + x0 += decode[0+(ofs)*7] * c; \ + x1 += decode[1+(ofs)*7] * c; \ + x2 += decode[2+(ofs)*7] * c; \ + x3 += decode[3+(ofs)*7] * c; \ + x4 += decode[4+(ofs)*7] * c; \ + x5 += decode[5+(ofs)*7] * c; \ + x6 += decode[6+(ofs)*7] * c; \ + c = hc[1+(ofs)]; \ + y0 += decode[7+(ofs)*7] * c; \ + y1 += decode[8+(ofs)*7] * c; \ + y2 += decode[9+(ofs)*7] * c; \ + y3 += decode[10+(ofs)*7] * c; \ + y4 += decode[11+(ofs)*7] * c; \ + y5 += decode[12+(ofs)*7] * c; \ + y6 += decode[13+(ofs)*7] * c; \ + c = hc[2+(ofs)]; \ + x0 += decode[14+(ofs)*7] * c; \ + x1 += decode[15+(ofs)*7] * c; \ + x2 += decode[16+(ofs)*7] * c; \ + x3 += decode[17+(ofs)*7] * c; \ + x4 += decode[18+(ofs)*7] * c; \ + x5 += decode[19+(ofs)*7] * c; \ + x6 += decode[20+(ofs)*7] * c; \ + +#define stbir__store_output() \ + output[0] = x0 + y0; \ + output[1] = x1 + y1; \ + output[2] = x2 + y2; \ + output[3] = x3 + y3; \ + output[4] = x4 + y4; \ + output[5] = x5 + y5; \ + output[6] = x6 + y6; \ + horizontal_coefficients += coefficient_width; \ + ++horizontal_contributors; \ + output += 7; + +#endif + +#define STBIR__horizontal_channels 7 +#define STB_IMAGE_RESIZE_DO_HORIZONTALS +#include STBIR__HEADER_FILENAME + + +// include all of the vertical resamplers (both scatter and gather versions) + +#define STBIR__vertical_channels 1 +#define STB_IMAGE_RESIZE_DO_VERTICALS +#include STBIR__HEADER_FILENAME + +#define STBIR__vertical_channels 1 +#define STB_IMAGE_RESIZE_DO_VERTICALS +#define STB_IMAGE_RESIZE_VERTICAL_CONTINUE +#include STBIR__HEADER_FILENAME + +#define STBIR__vertical_channels 2 +#define STB_IMAGE_RESIZE_DO_VERTICALS +#include STBIR__HEADER_FILENAME + +#define STBIR__vertical_channels 2 +#define STB_IMAGE_RESIZE_DO_VERTICALS +#define STB_IMAGE_RESIZE_VERTICAL_CONTINUE +#include STBIR__HEADER_FILENAME + +#define STBIR__vertical_channels 3 +#define STB_IMAGE_RESIZE_DO_VERTICALS +#include STBIR__HEADER_FILENAME + +#define STBIR__vertical_channels 3 +#define STB_IMAGE_RESIZE_DO_VERTICALS +#define STB_IMAGE_RESIZE_VERTICAL_CONTINUE +#include STBIR__HEADER_FILENAME + +#define STBIR__vertical_channels 4 +#define STB_IMAGE_RESIZE_DO_VERTICALS +#include STBIR__HEADER_FILENAME + +#define STBIR__vertical_channels 4 +#define STB_IMAGE_RESIZE_DO_VERTICALS +#define STB_IMAGE_RESIZE_VERTICAL_CONTINUE +#include STBIR__HEADER_FILENAME + +#define STBIR__vertical_channels 5 +#define STB_IMAGE_RESIZE_DO_VERTICALS +#include STBIR__HEADER_FILENAME + +#define STBIR__vertical_channels 5 +#define STB_IMAGE_RESIZE_DO_VERTICALS +#define STB_IMAGE_RESIZE_VERTICAL_CONTINUE +#include STBIR__HEADER_FILENAME + +#define STBIR__vertical_channels 6 +#define STB_IMAGE_RESIZE_DO_VERTICALS +#include STBIR__HEADER_FILENAME + +#define STBIR__vertical_channels 6 +#define STB_IMAGE_RESIZE_DO_VERTICALS +#define STB_IMAGE_RESIZE_VERTICAL_CONTINUE +#include STBIR__HEADER_FILENAME + +#define STBIR__vertical_channels 7 +#define STB_IMAGE_RESIZE_DO_VERTICALS +#include STBIR__HEADER_FILENAME + +#define STBIR__vertical_channels 7 +#define STB_IMAGE_RESIZE_DO_VERTICALS +#define STB_IMAGE_RESIZE_VERTICAL_CONTINUE +#include STBIR__HEADER_FILENAME + +#define STBIR__vertical_channels 8 +#define STB_IMAGE_RESIZE_DO_VERTICALS +#include STBIR__HEADER_FILENAME + +#define STBIR__vertical_channels 8 +#define STB_IMAGE_RESIZE_DO_VERTICALS +#define STB_IMAGE_RESIZE_VERTICAL_CONTINUE +#include STBIR__HEADER_FILENAME + +typedef void STBIR_VERTICAL_GATHERFUNC( float * output, float const * coeffs, float const ** inputs, float const * input0_end ); + +static STBIR_VERTICAL_GATHERFUNC * stbir__vertical_gathers[ 8 ] = +{ + stbir__vertical_gather_with_1_coeffs,stbir__vertical_gather_with_2_coeffs,stbir__vertical_gather_with_3_coeffs,stbir__vertical_gather_with_4_coeffs,stbir__vertical_gather_with_5_coeffs,stbir__vertical_gather_with_6_coeffs,stbir__vertical_gather_with_7_coeffs,stbir__vertical_gather_with_8_coeffs +}; + +static STBIR_VERTICAL_GATHERFUNC * stbir__vertical_gathers_continues[ 8 ] = +{ + stbir__vertical_gather_with_1_coeffs_cont,stbir__vertical_gather_with_2_coeffs_cont,stbir__vertical_gather_with_3_coeffs_cont,stbir__vertical_gather_with_4_coeffs_cont,stbir__vertical_gather_with_5_coeffs_cont,stbir__vertical_gather_with_6_coeffs_cont,stbir__vertical_gather_with_7_coeffs_cont,stbir__vertical_gather_with_8_coeffs_cont +}; + +typedef void STBIR_VERTICAL_SCATTERFUNC( float ** outputs, float const * coeffs, float const * input, float const * input_end ); + +static STBIR_VERTICAL_SCATTERFUNC * stbir__vertical_scatter_sets[ 8 ] = +{ + stbir__vertical_scatter_with_1_coeffs,stbir__vertical_scatter_with_2_coeffs,stbir__vertical_scatter_with_3_coeffs,stbir__vertical_scatter_with_4_coeffs,stbir__vertical_scatter_with_5_coeffs,stbir__vertical_scatter_with_6_coeffs,stbir__vertical_scatter_with_7_coeffs,stbir__vertical_scatter_with_8_coeffs +}; + +static STBIR_VERTICAL_SCATTERFUNC * stbir__vertical_scatter_blends[ 8 ] = +{ + stbir__vertical_scatter_with_1_coeffs_cont,stbir__vertical_scatter_with_2_coeffs_cont,stbir__vertical_scatter_with_3_coeffs_cont,stbir__vertical_scatter_with_4_coeffs_cont,stbir__vertical_scatter_with_5_coeffs_cont,stbir__vertical_scatter_with_6_coeffs_cont,stbir__vertical_scatter_with_7_coeffs_cont,stbir__vertical_scatter_with_8_coeffs_cont +}; + + +static void stbir__encode_scanline( stbir__info const * stbir_info, void *output_buffer_data, float * encode_buffer, int row STBIR_ONLY_PROFILE_GET_SPLIT_INFO ) +{ + int num_pixels = stbir_info->horizontal.scale_info.output_sub_size; + int channels = stbir_info->channels; + int width_times_channels = num_pixels * channels; + void * output_buffer; + + // un-alpha weight if we need to + if ( stbir_info->alpha_unweight ) + { + STBIR_PROFILE_START( unalpha ); + stbir_info->alpha_unweight( encode_buffer, width_times_channels ); + STBIR_PROFILE_END( unalpha ); + } + + // write directly into output by default + output_buffer = output_buffer_data; + + // if we have an output callback, we first convert the decode buffer in place (and then hand that to the callback) + if ( stbir_info->out_pixels_cb ) + output_buffer = encode_buffer; + + STBIR_PROFILE_START( encode ); + // convert into the output buffer + stbir_info->encode_pixels( output_buffer, width_times_channels, encode_buffer ); + STBIR_PROFILE_END( encode ); + + // if we have an output callback, call it to send the data + if ( stbir_info->out_pixels_cb ) + stbir_info->out_pixels_cb( output_buffer, num_pixels, row, stbir_info->user_data ); +} + + +// Get the ring buffer pointer for an index +static float* stbir__get_ring_buffer_entry(stbir__info const * stbir_info, stbir__per_split_info const * split_info, int index ) +{ + STBIR_ASSERT( index < stbir_info->ring_buffer_num_entries ); + + #ifdef STBIR__SEPARATE_ALLOCATIONS + return split_info->ring_buffers[ index ]; + #else + return (float*) ( ( (char*) split_info->ring_buffer ) + ( index * stbir_info->ring_buffer_length_bytes ) ); + #endif +} + +// Get the specified scan line from the ring buffer +static float* stbir__get_ring_buffer_scanline(stbir__info const * stbir_info, stbir__per_split_info const * split_info, int get_scanline) +{ + int ring_buffer_index = (split_info->ring_buffer_begin_index + (get_scanline - split_info->ring_buffer_first_scanline)) % stbir_info->ring_buffer_num_entries; + return stbir__get_ring_buffer_entry( stbir_info, split_info, ring_buffer_index ); +} + +static void stbir__resample_horizontal_gather(stbir__info const * stbir_info, float* output_buffer, float const * input_buffer STBIR_ONLY_PROFILE_GET_SPLIT_INFO ) +{ + float const * decode_buffer = input_buffer - ( stbir_info->scanline_extents.conservative.n0 * stbir_info->effective_channels ); + + STBIR_PROFILE_START( horizontal ); + if ( ( stbir_info->horizontal.filter_enum == STBIR_FILTER_POINT_SAMPLE ) && ( stbir_info->horizontal.scale_info.scale == 1.0f ) ) + STBIR_MEMCPY( output_buffer, input_buffer, stbir_info->horizontal.scale_info.output_sub_size * sizeof( float ) * stbir_info->effective_channels ); + else + stbir_info->horizontal_gather_channels( output_buffer, stbir_info->horizontal.scale_info.output_sub_size, decode_buffer, stbir_info->horizontal.contributors, stbir_info->horizontal.coefficients, stbir_info->horizontal.coefficient_width ); + STBIR_PROFILE_END( horizontal ); +} + +static void stbir__resample_vertical_gather(stbir__info const * stbir_info, stbir__per_split_info* split_info, int n, int contrib_n0, int contrib_n1, float const * vertical_coefficients ) +{ + float* encode_buffer = split_info->vertical_buffer; + float* decode_buffer = split_info->decode_buffer; + int vertical_first = stbir_info->vertical_first; + int width = (vertical_first) ? ( stbir_info->scanline_extents.conservative.n1-stbir_info->scanline_extents.conservative.n0+1 ) : stbir_info->horizontal.scale_info.output_sub_size; + int width_times_channels = stbir_info->effective_channels * width; + + STBIR_ASSERT( stbir_info->vertical.is_gather ); + + // loop over the contributing scanlines and scale into the buffer + STBIR_PROFILE_START( vertical ); + { + int k = 0, total = contrib_n1 - contrib_n0 + 1; + STBIR_ASSERT( total > 0 ); + do { + float const * inputs[8]; + int i, cnt = total; if ( cnt > 8 ) cnt = 8; + for( i = 0 ; i < cnt ; i++ ) + inputs[ i ] = stbir__get_ring_buffer_scanline(stbir_info, split_info, k+i+contrib_n0 ); + + // call the N scanlines at a time function (up to 8 scanlines of blending at once) + ((k==0)?stbir__vertical_gathers:stbir__vertical_gathers_continues)[cnt-1]( (vertical_first) ? decode_buffer : encode_buffer, vertical_coefficients + k, inputs, inputs[0] + width_times_channels ); + k += cnt; + total -= cnt; + } while ( total ); + } + STBIR_PROFILE_END( vertical ); + + if ( vertical_first ) + { + // Now resample the gathered vertical data in the horizontal axis into the encode buffer + decode_buffer[ width_times_channels ] = 0.0f; // clear two over for horizontals with a remnant of 3 + decode_buffer[ width_times_channels+1 ] = 0.0f; + stbir__resample_horizontal_gather(stbir_info, encode_buffer, decode_buffer STBIR_ONLY_PROFILE_SET_SPLIT_INFO ); + } + + stbir__encode_scanline( stbir_info, ( (char *) stbir_info->output_data ) + ((size_t)n * (size_t)stbir_info->output_stride_bytes), + encode_buffer, n STBIR_ONLY_PROFILE_SET_SPLIT_INFO ); +} + +static void stbir__decode_and_resample_for_vertical_gather_loop(stbir__info const * stbir_info, stbir__per_split_info* split_info, int n) +{ + int ring_buffer_index; + float* ring_buffer; + + // Decode the nth scanline from the source image into the decode buffer. + stbir__decode_scanline( stbir_info, n, split_info->decode_buffer STBIR_ONLY_PROFILE_SET_SPLIT_INFO ); + + // update new end scanline + split_info->ring_buffer_last_scanline = n; + + // get ring buffer + ring_buffer_index = (split_info->ring_buffer_begin_index + (split_info->ring_buffer_last_scanline - split_info->ring_buffer_first_scanline)) % stbir_info->ring_buffer_num_entries; + ring_buffer = stbir__get_ring_buffer_entry(stbir_info, split_info, ring_buffer_index); + + // Now resample it into the ring buffer. + stbir__resample_horizontal_gather( stbir_info, ring_buffer, split_info->decode_buffer STBIR_ONLY_PROFILE_SET_SPLIT_INFO ); + + // Now it's sitting in the ring buffer ready to be used as source for the vertical sampling. +} + +static void stbir__vertical_gather_loop( stbir__info const * stbir_info, stbir__per_split_info* split_info, int split_count ) +{ + int y, start_output_y, end_output_y; + stbir__contributors* vertical_contributors = stbir_info->vertical.contributors; + float const * vertical_coefficients = stbir_info->vertical.coefficients; + + STBIR_ASSERT( stbir_info->vertical.is_gather ); + + start_output_y = split_info->start_output_y; + end_output_y = split_info[split_count-1].end_output_y; + + vertical_contributors += start_output_y; + vertical_coefficients += start_output_y * stbir_info->vertical.coefficient_width; + + // initialize the ring buffer for gathering + split_info->ring_buffer_begin_index = 0; + split_info->ring_buffer_first_scanline = vertical_contributors->n0; + split_info->ring_buffer_last_scanline = split_info->ring_buffer_first_scanline - 1; // means "empty" + + for (y = start_output_y; y < end_output_y; y++) + { + int in_first_scanline, in_last_scanline; + + in_first_scanline = vertical_contributors->n0; + in_last_scanline = vertical_contributors->n1; + + // make sure the indexing hasn't broken + STBIR_ASSERT( in_first_scanline >= split_info->ring_buffer_first_scanline ); + + // Load in new scanlines + while (in_last_scanline > split_info->ring_buffer_last_scanline) + { + STBIR_ASSERT( ( split_info->ring_buffer_last_scanline - split_info->ring_buffer_first_scanline + 1 ) <= stbir_info->ring_buffer_num_entries ); + + // make sure there was room in the ring buffer when we add new scanlines + if ( ( split_info->ring_buffer_last_scanline - split_info->ring_buffer_first_scanline + 1 ) == stbir_info->ring_buffer_num_entries ) + { + split_info->ring_buffer_first_scanline++; + split_info->ring_buffer_begin_index++; + } + + if ( stbir_info->vertical_first ) + { + float * ring_buffer = stbir__get_ring_buffer_scanline( stbir_info, split_info, ++split_info->ring_buffer_last_scanline ); + // Decode the nth scanline from the source image into the decode buffer. + stbir__decode_scanline( stbir_info, split_info->ring_buffer_last_scanline, ring_buffer STBIR_ONLY_PROFILE_SET_SPLIT_INFO ); + } + else + { + stbir__decode_and_resample_for_vertical_gather_loop(stbir_info, split_info, split_info->ring_buffer_last_scanline + 1); + } + } + + // Now all buffers should be ready to write a row of vertical sampling, so do it. + stbir__resample_vertical_gather(stbir_info, split_info, y, in_first_scanline, in_last_scanline, vertical_coefficients ); + + ++vertical_contributors; + vertical_coefficients += stbir_info->vertical.coefficient_width; + } +} + +#define STBIR__FLOAT_EMPTY_MARKER 3.0e+38F +#define STBIR__FLOAT_BUFFER_IS_EMPTY(ptr) ((ptr)[0]==STBIR__FLOAT_EMPTY_MARKER) + +static void stbir__encode_first_scanline_from_scatter(stbir__info const * stbir_info, stbir__per_split_info* split_info) +{ + // evict a scanline out into the output buffer + float* ring_buffer_entry = stbir__get_ring_buffer_entry(stbir_info, split_info, split_info->ring_buffer_begin_index ); + + // dump the scanline out + stbir__encode_scanline( stbir_info, ( (char *)stbir_info->output_data ) + ( (size_t)split_info->ring_buffer_first_scanline * (size_t)stbir_info->output_stride_bytes ), ring_buffer_entry, split_info->ring_buffer_first_scanline STBIR_ONLY_PROFILE_SET_SPLIT_INFO ); + + // mark it as empty + ring_buffer_entry[ 0 ] = STBIR__FLOAT_EMPTY_MARKER; + + // advance the first scanline + split_info->ring_buffer_first_scanline++; + if ( ++split_info->ring_buffer_begin_index == stbir_info->ring_buffer_num_entries ) + split_info->ring_buffer_begin_index = 0; +} + +static void stbir__horizontal_resample_and_encode_first_scanline_from_scatter(stbir__info const * stbir_info, stbir__per_split_info* split_info) +{ + // evict a scanline out into the output buffer + + float* ring_buffer_entry = stbir__get_ring_buffer_entry(stbir_info, split_info, split_info->ring_buffer_begin_index ); + + // Now resample it into the buffer. + stbir__resample_horizontal_gather( stbir_info, split_info->vertical_buffer, ring_buffer_entry STBIR_ONLY_PROFILE_SET_SPLIT_INFO ); + + // dump the scanline out + stbir__encode_scanline( stbir_info, ( (char *)stbir_info->output_data ) + ( (size_t)split_info->ring_buffer_first_scanline * (size_t)stbir_info->output_stride_bytes ), split_info->vertical_buffer, split_info->ring_buffer_first_scanline STBIR_ONLY_PROFILE_SET_SPLIT_INFO ); + + // mark it as empty + ring_buffer_entry[ 0 ] = STBIR__FLOAT_EMPTY_MARKER; + + // advance the first scanline + split_info->ring_buffer_first_scanline++; + if ( ++split_info->ring_buffer_begin_index == stbir_info->ring_buffer_num_entries ) + split_info->ring_buffer_begin_index = 0; +} + +static void stbir__resample_vertical_scatter(stbir__info const * stbir_info, stbir__per_split_info* split_info, int n0, int n1, float const * vertical_coefficients, float const * vertical_buffer, float const * vertical_buffer_end ) +{ + STBIR_ASSERT( !stbir_info->vertical.is_gather ); + + STBIR_PROFILE_START( vertical ); + { + int k = 0, total = n1 - n0 + 1; + STBIR_ASSERT( total > 0 ); + do { + float * outputs[8]; + int i, n = total; if ( n > 8 ) n = 8; + for( i = 0 ; i < n ; i++ ) + { + outputs[ i ] = stbir__get_ring_buffer_scanline(stbir_info, split_info, k+i+n0 ); + if ( ( i ) && ( STBIR__FLOAT_BUFFER_IS_EMPTY( outputs[i] ) != STBIR__FLOAT_BUFFER_IS_EMPTY( outputs[0] ) ) ) // make sure runs are of the same type + { + n = i; + break; + } + } + // call the scatter to N scanlines at a time function (up to 8 scanlines of scattering at once) + ((STBIR__FLOAT_BUFFER_IS_EMPTY( outputs[0] ))?stbir__vertical_scatter_sets:stbir__vertical_scatter_blends)[n-1]( outputs, vertical_coefficients + k, vertical_buffer, vertical_buffer_end ); + k += n; + total -= n; + } while ( total ); + } + + STBIR_PROFILE_END( vertical ); +} + +typedef void stbir__handle_scanline_for_scatter_func(stbir__info const * stbir_info, stbir__per_split_info* split_info); + +static void stbir__vertical_scatter_loop( stbir__info const * stbir_info, stbir__per_split_info* split_info, int split_count ) +{ + int y, start_output_y, end_output_y, start_input_y, end_input_y; + stbir__contributors* vertical_contributors = stbir_info->vertical.contributors; + float const * vertical_coefficients = stbir_info->vertical.coefficients; + stbir__handle_scanline_for_scatter_func * handle_scanline_for_scatter; + void * scanline_scatter_buffer; + void * scanline_scatter_buffer_end; + int on_first_input_y, last_input_y; + int width = (stbir_info->vertical_first) ? ( stbir_info->scanline_extents.conservative.n1-stbir_info->scanline_extents.conservative.n0+1 ) : stbir_info->horizontal.scale_info.output_sub_size; + int width_times_channels = stbir_info->effective_channels * width; + + STBIR_ASSERT( !stbir_info->vertical.is_gather ); + + start_output_y = split_info->start_output_y; + end_output_y = split_info[split_count-1].end_output_y; // may do multiple split counts + + start_input_y = split_info->start_input_y; + end_input_y = split_info[split_count-1].end_input_y; + + // adjust for starting offset start_input_y + y = start_input_y + stbir_info->vertical.filter_pixel_margin; + vertical_contributors += y ; + vertical_coefficients += stbir_info->vertical.coefficient_width * y; + + if ( stbir_info->vertical_first ) + { + handle_scanline_for_scatter = stbir__horizontal_resample_and_encode_first_scanline_from_scatter; + scanline_scatter_buffer = split_info->decode_buffer; + scanline_scatter_buffer_end = ( (char*) scanline_scatter_buffer ) + sizeof( float ) * stbir_info->effective_channels * (stbir_info->scanline_extents.conservative.n1-stbir_info->scanline_extents.conservative.n0+1); + } + else + { + handle_scanline_for_scatter = stbir__encode_first_scanline_from_scatter; + scanline_scatter_buffer = split_info->vertical_buffer; + scanline_scatter_buffer_end = ( (char*) scanline_scatter_buffer ) + sizeof( float ) * stbir_info->effective_channels * stbir_info->horizontal.scale_info.output_sub_size; + } + + // initialize the ring buffer for scattering + split_info->ring_buffer_first_scanline = start_output_y; + split_info->ring_buffer_last_scanline = -1; + split_info->ring_buffer_begin_index = -1; + + // mark all the buffers as empty to start + for( y = 0 ; y < stbir_info->ring_buffer_num_entries ; y++ ) + { + float * decode_buffer = stbir__get_ring_buffer_entry( stbir_info, split_info, y ); + decode_buffer[ width_times_channels ] = 0.0f; // clear two over for horizontals with a remnant of 3 + decode_buffer[ width_times_channels+1 ] = 0.0f; + decode_buffer[0] = STBIR__FLOAT_EMPTY_MARKER; // only used on scatter + } + + // do the loop in input space + on_first_input_y = 1; last_input_y = start_input_y; + for (y = start_input_y ; y < end_input_y; y++) + { + int out_first_scanline, out_last_scanline; + + out_first_scanline = vertical_contributors->n0; + out_last_scanline = vertical_contributors->n1; + + STBIR_ASSERT(out_last_scanline - out_first_scanline + 1 <= stbir_info->ring_buffer_num_entries); + + if ( ( out_last_scanline >= out_first_scanline ) && ( ( ( out_first_scanline >= start_output_y ) && ( out_first_scanline < end_output_y ) ) || ( ( out_last_scanline >= start_output_y ) && ( out_last_scanline < end_output_y ) ) ) ) + { + float const * vc = vertical_coefficients; + + // keep track of the range actually seen for the next resize + last_input_y = y; + if ( ( on_first_input_y ) && ( y > start_input_y ) ) + split_info->start_input_y = y; + on_first_input_y = 0; + + // clip the region + if ( out_first_scanline < start_output_y ) + { + vc += start_output_y - out_first_scanline; + out_first_scanline = start_output_y; + } + + if ( out_last_scanline >= end_output_y ) + out_last_scanline = end_output_y - 1; + + // if very first scanline, init the index + if (split_info->ring_buffer_begin_index < 0) + split_info->ring_buffer_begin_index = out_first_scanline - start_output_y; + + STBIR_ASSERT( split_info->ring_buffer_begin_index <= out_first_scanline ); + + // Decode the nth scanline from the source image into the decode buffer. + stbir__decode_scanline( stbir_info, y, split_info->decode_buffer STBIR_ONLY_PROFILE_SET_SPLIT_INFO ); + + // When horizontal first, we resample horizontally into the vertical buffer before we scatter it out + if ( !stbir_info->vertical_first ) + stbir__resample_horizontal_gather( stbir_info, split_info->vertical_buffer, split_info->decode_buffer STBIR_ONLY_PROFILE_SET_SPLIT_INFO ); + + // Now it's sitting in the buffer ready to be distributed into the ring buffers. + + // evict from the ringbuffer, if we need are full + if ( ( ( split_info->ring_buffer_last_scanline - split_info->ring_buffer_first_scanline + 1 ) == stbir_info->ring_buffer_num_entries ) && + ( out_last_scanline > split_info->ring_buffer_last_scanline ) ) + handle_scanline_for_scatter( stbir_info, split_info ); + + // Now the horizontal buffer is ready to write to all ring buffer rows, so do it. + stbir__resample_vertical_scatter(stbir_info, split_info, out_first_scanline, out_last_scanline, vc, (float*)scanline_scatter_buffer, (float*)scanline_scatter_buffer_end ); + + // update the end of the buffer + if ( out_last_scanline > split_info->ring_buffer_last_scanline ) + split_info->ring_buffer_last_scanline = out_last_scanline; + } + ++vertical_contributors; + vertical_coefficients += stbir_info->vertical.coefficient_width; + } + + // now evict the scanlines that are left over in the ring buffer + while ( split_info->ring_buffer_first_scanline < end_output_y ) + handle_scanline_for_scatter(stbir_info, split_info); + + // update the end_input_y if we do multiple resizes with the same data + ++last_input_y; + for( y = 0 ; y < split_count; y++ ) + if ( split_info[y].end_input_y > last_input_y ) + split_info[y].end_input_y = last_input_y; +} + + +static stbir__kernel_callback * stbir__builtin_kernels[] = { 0, stbir__filter_trapezoid, stbir__filter_triangle, stbir__filter_cubic, stbir__filter_catmullrom, stbir__filter_mitchell, stbir__filter_point }; +static stbir__support_callback * stbir__builtin_supports[] = { 0, stbir__support_trapezoid, stbir__support_one, stbir__support_two, stbir__support_two, stbir__support_two, stbir__support_zeropoint5 }; + +static void stbir__set_sampler(stbir__sampler * samp, stbir_filter filter, stbir__kernel_callback * kernel, stbir__support_callback * support, stbir_edge edge, stbir__scale_info * scale_info, int always_gather, void * user_data ) +{ + // set filter + if (filter == 0) + { + filter = STBIR_DEFAULT_FILTER_DOWNSAMPLE; // default to downsample + if (scale_info->scale >= ( 1.0f - stbir__small_float ) ) + { + if ( (scale_info->scale <= ( 1.0f + stbir__small_float ) ) && ( STBIR_CEILF(scale_info->pixel_shift) == scale_info->pixel_shift ) ) + filter = STBIR_FILTER_POINT_SAMPLE; + else + filter = STBIR_DEFAULT_FILTER_UPSAMPLE; + } + } + samp->filter_enum = filter; + + STBIR_ASSERT(samp->filter_enum != 0); + STBIR_ASSERT((unsigned)samp->filter_enum < STBIR_FILTER_OTHER); + samp->filter_kernel = stbir__builtin_kernels[ filter ]; + samp->filter_support = stbir__builtin_supports[ filter ]; + + if ( kernel && support ) + { + samp->filter_kernel = kernel; + samp->filter_support = support; + samp->filter_enum = STBIR_FILTER_OTHER; + } + + samp->edge = edge; + samp->filter_pixel_width = stbir__get_filter_pixel_width (samp->filter_support, scale_info->scale, user_data ); + // Gather is always better, but in extreme downsamples, you have to most or all of the data in memory + // For horizontal, we always have all the pixels, so we always use gather here (always_gather==1). + // For vertical, we use gather if scaling up (which means we will have samp->filter_pixel_width + // scanlines in memory at once). + samp->is_gather = 0; + if ( scale_info->scale >= ( 1.0f - stbir__small_float ) ) + samp->is_gather = 1; + else if ( ( always_gather ) || ( samp->filter_pixel_width <= STBIR_FORCE_GATHER_FILTER_SCANLINES_AMOUNT ) ) + samp->is_gather = 2; + + // pre calculate stuff based on the above + samp->coefficient_width = stbir__get_coefficient_width(samp, samp->is_gather, user_data); + + // filter_pixel_width is the conservative size in pixels of input that affect an output pixel. + // In rare cases (only with 2 pix to 1 pix with the default filters), it's possible that the + // filter will extend before or after the scanline beyond just one extra entire copy of the + // scanline (we would hit the edge twice). We don't let you do that, so we clamp the total + // width to 3x the total of input pixel (once for the scanline, once for the left side + // overhang, and once for the right side). We only do this for edge mode, since the other + // modes can just re-edge clamp back in again. + if ( edge == STBIR_EDGE_WRAP ) + if ( samp->filter_pixel_width > ( scale_info->input_full_size * 3 ) ) + samp->filter_pixel_width = scale_info->input_full_size * 3; + + // This is how much to expand buffers to account for filters seeking outside + // the image boundaries. + samp->filter_pixel_margin = samp->filter_pixel_width / 2; + + // filter_pixel_margin is the amount that this filter can overhang on just one side of either + // end of the scanline (left or the right). Since we only allow you to overhang 1 scanline's + // worth of pixels, we clamp this one side of overhang to the input scanline size. Again, + // this clamping only happens in rare cases with the default filters (2 pix to 1 pix). + if ( edge == STBIR_EDGE_WRAP ) + if ( samp->filter_pixel_margin > scale_info->input_full_size ) + samp->filter_pixel_margin = scale_info->input_full_size; + + samp->num_contributors = stbir__get_contributors(samp, samp->is_gather); + + samp->contributors_size = samp->num_contributors * sizeof(stbir__contributors); + samp->coefficients_size = samp->num_contributors * samp->coefficient_width * sizeof(float) + sizeof(float)*STBIR_INPUT_CALLBACK_PADDING; // extra sizeof(float) is padding + + samp->gather_prescatter_contributors = 0; + samp->gather_prescatter_coefficients = 0; + if ( samp->is_gather == 0 ) + { + samp->gather_prescatter_coefficient_width = samp->filter_pixel_width; + samp->gather_prescatter_num_contributors = stbir__get_contributors(samp, 2); + samp->gather_prescatter_contributors_size = samp->gather_prescatter_num_contributors * sizeof(stbir__contributors); + samp->gather_prescatter_coefficients_size = samp->gather_prescatter_num_contributors * samp->gather_prescatter_coefficient_width * sizeof(float); + } +} + +static void stbir__get_conservative_extents( stbir__sampler * samp, stbir__contributors * range, void * user_data ) +{ + float scale = samp->scale_info.scale; + float out_shift = samp->scale_info.pixel_shift; + stbir__support_callback * support = samp->filter_support; + int input_full_size = samp->scale_info.input_full_size; + stbir_edge edge = samp->edge; + float inv_scale = samp->scale_info.inv_scale; + + STBIR_ASSERT( samp->is_gather != 0 ); + + if ( samp->is_gather == 1 ) + { + int in_first_pixel, in_last_pixel; + float out_filter_radius = support(inv_scale, user_data) * scale; + + stbir__calculate_in_pixel_range( &in_first_pixel, &in_last_pixel, 0.5, out_filter_radius, inv_scale, out_shift, input_full_size, edge ); + range->n0 = in_first_pixel; + stbir__calculate_in_pixel_range( &in_first_pixel, &in_last_pixel, ( (float)(samp->scale_info.output_sub_size-1) ) + 0.5f, out_filter_radius, inv_scale, out_shift, input_full_size, edge ); + range->n1 = in_last_pixel; + } + else if ( samp->is_gather == 2 ) // downsample gather, refine + { + float in_pixels_radius = support(scale, user_data) * inv_scale; + int filter_pixel_margin = samp->filter_pixel_margin; + int output_sub_size = samp->scale_info.output_sub_size; + int input_end; + int n; + int in_first_pixel, in_last_pixel; + + // get a conservative area of the input range + stbir__calculate_in_pixel_range( &in_first_pixel, &in_last_pixel, 0, 0, inv_scale, out_shift, input_full_size, edge ); + range->n0 = in_first_pixel; + stbir__calculate_in_pixel_range( &in_first_pixel, &in_last_pixel, (float)output_sub_size, 0, inv_scale, out_shift, input_full_size, edge ); + range->n1 = in_last_pixel; + + // now go through the margin to the start of area to find bottom + n = range->n0 + 1; + input_end = -filter_pixel_margin; + while( n >= input_end ) + { + int out_first_pixel, out_last_pixel; + stbir__calculate_out_pixel_range( &out_first_pixel, &out_last_pixel, ((float)n)+0.5f, in_pixels_radius, scale, out_shift, output_sub_size ); + if ( out_first_pixel > out_last_pixel ) + break; + + if ( ( out_first_pixel < output_sub_size ) || ( out_last_pixel >= 0 ) ) + range->n0 = n; + --n; + } + + // now go through the end of the area through the margin to find top + n = range->n1 - 1; + input_end = n + 1 + filter_pixel_margin; + while( n <= input_end ) + { + int out_first_pixel, out_last_pixel; + stbir__calculate_out_pixel_range( &out_first_pixel, &out_last_pixel, ((float)n)+0.5f, in_pixels_radius, scale, out_shift, output_sub_size ); + if ( out_first_pixel > out_last_pixel ) + break; + if ( ( out_first_pixel < output_sub_size ) || ( out_last_pixel >= 0 ) ) + range->n1 = n; + ++n; + } + } + + if ( samp->edge == STBIR_EDGE_WRAP ) + { + // if we are wrapping, and we are very close to the image size (so the edges might merge), just use the scanline up to the edge + if ( ( range->n0 > 0 ) && ( range->n1 >= input_full_size ) ) + { + int marg = range->n1 - input_full_size + 1; + if ( ( marg + STBIR__MERGE_RUNS_PIXEL_THRESHOLD ) >= range->n0 ) + range->n0 = 0; + } + if ( ( range->n0 < 0 ) && ( range->n1 < (input_full_size-1) ) ) + { + int marg = -range->n0; + if ( ( input_full_size - marg - STBIR__MERGE_RUNS_PIXEL_THRESHOLD - 1 ) <= range->n1 ) + range->n1 = input_full_size - 1; + } + } + else + { + // for non-edge-wrap modes, we never read over the edge, so clamp + if ( range->n0 < 0 ) + range->n0 = 0; + if ( range->n1 >= input_full_size ) + range->n1 = input_full_size - 1; + } +} + +static void stbir__get_split_info( stbir__per_split_info* split_info, int splits, int output_height, int vertical_pixel_margin, int input_full_height, int is_gather, stbir__contributors * contribs ) +{ + int i, cur; + int left = output_height; + + cur = 0; + for( i = 0 ; i < splits ; i++ ) + { + int each; + + split_info[i].start_output_y = cur; + each = left / ( splits - i ); + split_info[i].end_output_y = cur + each; + + // ok, when we are gathering, we need to make sure we are starting on a y offset that doesn't have + // a "special" set of coefficients. Basically, with exactly the right filter at exactly the right + // resize at exactly the right phase, some of the coefficents can be zero. When they are zero, we + // don't process them at all. But this leads to a tricky thing with the thread splits, where we + // might have a set of two coeffs like this for example: (4,4) and (3,6). The 4,4 means there was + // just one single coeff because things worked out perfectly (normally, they all have 4 coeffs + // like the range 3,6. The problem is that if we start right on the (4,4) on a brand new thread, + // then when we get to (3,6), we don't have the "3" sample in memory (because we didn't load + // it on the initial (4,4) range because it didn't have a 3 (we only add new samples that are + // larger than our existing samples - it's just how the eviction works). So, our solution here + // is pretty simple, if we start right on a range that has samples that start earlier, then we + // simply bump up our previous thread split range to include it, and then start this threads + // range with the smaller sample. It just moves one scanline from one thread split to another, + // so that we end with the unusual one, instead of start with it. To do this, we check 2-4 + // sample at each thread split start and then occassionally move them. + + if ( ( is_gather ) && ( i ) ) + { + stbir__contributors * small_contribs; + int j, smallest, stop, start_n0; + stbir__contributors * split_contribs = contribs + cur; + + // scan for a max of 3x the filter width or until the next thread split + stop = vertical_pixel_margin * 3; + if ( each < stop ) + stop = each; + + // loops a few times before early out + smallest = 0; + small_contribs = split_contribs; + start_n0 = small_contribs->n0; + for( j = 1 ; j <= stop ; j++ ) + { + ++split_contribs; + if ( split_contribs->n0 > start_n0 ) + break; + if ( split_contribs->n0 < small_contribs->n0 ) + { + small_contribs = split_contribs; + smallest = j; + } + } + + split_info[i-1].end_output_y += smallest; + split_info[i].start_output_y += smallest; + } + + cur += each; + left -= each; + + // scatter range (updated to minimum as you run it) + split_info[i].start_input_y = -vertical_pixel_margin; + split_info[i].end_input_y = input_full_height + vertical_pixel_margin; + } +} + +static void stbir__free_internal_mem( stbir__info *info ) +{ + #define STBIR__FREE_AND_CLEAR( ptr ) { if ( ptr ) { void * p = (ptr); (ptr) = 0; STBIR_FREE( p, info->user_data); } } + + if ( info ) + { + #ifndef STBIR__SEPARATE_ALLOCATIONS + STBIR__FREE_AND_CLEAR( info->alloced_mem ); + #else + int i,j; + + if ( ( info->vertical.gather_prescatter_contributors ) && ( (void*)info->vertical.gather_prescatter_contributors != (void*)info->split_info[0].decode_buffer ) ) + { + STBIR__FREE_AND_CLEAR( info->vertical.gather_prescatter_coefficients ); + STBIR__FREE_AND_CLEAR( info->vertical.gather_prescatter_contributors ); + } + for( i = 0 ; i < info->splits ; i++ ) + { + for( j = 0 ; j < info->alloc_ring_buffer_num_entries ; j++ ) + { + #ifdef STBIR_SIMD8 + if ( info->effective_channels == 3 ) + --info->split_info[i].ring_buffers[j]; // avx in 3 channel mode needs one float at the start of the buffer + #endif + STBIR__FREE_AND_CLEAR( info->split_info[i].ring_buffers[j] ); + } + + #ifdef STBIR_SIMD8 + if ( info->effective_channels == 3 ) + --info->split_info[i].decode_buffer; // avx in 3 channel mode needs one float at the start of the buffer + #endif + STBIR__FREE_AND_CLEAR( info->split_info[i].decode_buffer ); + STBIR__FREE_AND_CLEAR( info->split_info[i].ring_buffers ); + STBIR__FREE_AND_CLEAR( info->split_info[i].vertical_buffer ); + } + STBIR__FREE_AND_CLEAR( info->split_info ); + if ( info->vertical.coefficients != info->horizontal.coefficients ) + { + STBIR__FREE_AND_CLEAR( info->vertical.coefficients ); + STBIR__FREE_AND_CLEAR( info->vertical.contributors ); + } + STBIR__FREE_AND_CLEAR( info->horizontal.coefficients ); + STBIR__FREE_AND_CLEAR( info->horizontal.contributors ); + STBIR__FREE_AND_CLEAR( info->alloced_mem ); + STBIR_FREE( info, info->user_data ); + #endif + } + + #undef STBIR__FREE_AND_CLEAR +} + +static int stbir__get_max_split( int splits, int height ) +{ + int i; + int max = 0; + + for( i = 0 ; i < splits ; i++ ) + { + int each = height / ( splits - i ); + if ( each > max ) + max = each; + height -= each; + } + return max; +} + +static stbir__horizontal_gather_channels_func ** stbir__horizontal_gather_n_coeffs_funcs[8] = +{ + 0, stbir__horizontal_gather_1_channels_with_n_coeffs_funcs, stbir__horizontal_gather_2_channels_with_n_coeffs_funcs, stbir__horizontal_gather_3_channels_with_n_coeffs_funcs, stbir__horizontal_gather_4_channels_with_n_coeffs_funcs, 0,0, stbir__horizontal_gather_7_channels_with_n_coeffs_funcs +}; + +static stbir__horizontal_gather_channels_func ** stbir__horizontal_gather_channels_funcs[8] = +{ + 0, stbir__horizontal_gather_1_channels_funcs, stbir__horizontal_gather_2_channels_funcs, stbir__horizontal_gather_3_channels_funcs, stbir__horizontal_gather_4_channels_funcs, 0,0, stbir__horizontal_gather_7_channels_funcs +}; + +// there are six resize classifications: 0 == vertical scatter, 1 == vertical gather < 1x scale, 2 == vertical gather 1x-2x scale, 4 == vertical gather < 3x scale, 4 == vertical gather > 3x scale, 5 == <=4 pixel height, 6 == <=4 pixel wide column +#define STBIR_RESIZE_CLASSIFICATIONS 8 + +static float stbir__compute_weights[5][STBIR_RESIZE_CLASSIFICATIONS][4]= // 5 = 0=1chan, 1=2chan, 2=3chan, 3=4chan, 4=7chan +{ + { + { 1.00000f, 1.00000f, 0.31250f, 1.00000f }, + { 0.56250f, 0.59375f, 0.00000f, 0.96875f }, + { 1.00000f, 0.06250f, 0.00000f, 1.00000f }, + { 0.00000f, 0.09375f, 1.00000f, 1.00000f }, + { 1.00000f, 1.00000f, 0.31250f, 1.00000f }, + { 0.03125f, 0.12500f, 1.00000f, 1.00000f }, + { 1.00000f, 1.00000f, 0.06250f, 1.00000f }, + { 0.00000f, 1.00000f, 0.00000f, 0.03125f }, + }, { + { 0.00000f, 0.84375f, 0.00000f, 0.03125f }, + { 0.09375f, 0.93750f, 0.00000f, 0.78125f }, + { 0.87500f, 0.21875f, 0.00000f, 0.96875f }, + { 0.09375f, 0.09375f, 1.00000f, 1.00000f }, + { 0.00000f, 0.84375f, 0.00000f, 0.03125f }, + { 0.03125f, 0.12500f, 1.00000f, 1.00000f }, + { 1.00000f, 1.00000f, 0.06250f, 1.00000f }, + { 0.00000f, 1.00000f, 0.00000f, 0.53125f }, + }, { + { 0.00000f, 0.53125f, 0.00000f, 0.03125f }, + { 0.06250f, 0.96875f, 0.00000f, 0.53125f }, + { 0.87500f, 0.18750f, 0.00000f, 0.93750f }, + { 0.00000f, 0.09375f, 1.00000f, 1.00000f }, + { 0.00000f, 0.53125f, 0.00000f, 0.03125f }, + { 0.03125f, 0.12500f, 1.00000f, 1.00000f }, + { 1.00000f, 1.00000f, 0.06250f, 1.00000f }, + { 0.00000f, 1.00000f, 0.00000f, 0.56250f }, + }, { + { 0.00000f, 0.50000f, 0.00000f, 0.71875f }, + { 0.06250f, 0.84375f, 0.00000f, 0.87500f }, + { 1.00000f, 0.50000f, 0.50000f, 0.96875f }, + { 1.00000f, 0.09375f, 0.31250f, 0.50000f }, + { 0.00000f, 0.50000f, 0.00000f, 0.71875f }, + { 1.00000f, 0.03125f, 0.03125f, 0.53125f }, + { 1.00000f, 1.00000f, 0.06250f, 1.00000f }, + { 0.00000f, 1.00000f, 0.03125f, 0.18750f }, + }, { + { 0.00000f, 0.59375f, 0.00000f, 0.96875f }, + { 0.06250f, 0.81250f, 0.06250f, 0.59375f }, + { 0.75000f, 0.43750f, 0.12500f, 0.96875f }, + { 0.87500f, 0.06250f, 0.18750f, 0.43750f }, + { 0.00000f, 0.59375f, 0.00000f, 0.96875f }, + { 0.15625f, 0.12500f, 1.00000f, 1.00000f }, + { 1.00000f, 1.00000f, 0.06250f, 1.00000f }, + { 0.00000f, 1.00000f, 0.03125f, 0.34375f }, + } +}; + +// structure that allow us to query and override info for training the costs +typedef struct STBIR__V_FIRST_INFO +{ + double v_cost, h_cost; + int control_v_first; // 0 = no control, 1 = force hori, 2 = force vert + int v_first; + int v_resize_classification; + int is_gather; +} STBIR__V_FIRST_INFO; + +#ifdef STBIR__V_FIRST_INFO_BUFFER +static STBIR__V_FIRST_INFO STBIR__V_FIRST_INFO_BUFFER = {0}; +#define STBIR__V_FIRST_INFO_POINTER &STBIR__V_FIRST_INFO_BUFFER +#else +#define STBIR__V_FIRST_INFO_POINTER 0 +#endif + +// Figure out whether to scale along the horizontal or vertical first. +// This only *super* important when you are scaling by a massively +// different amount in the vertical vs the horizontal (for example, if +// you are scaling by 2x in the width, and 0.5x in the height, then you +// want to do the vertical scale first, because it's around 3x faster +// in that order. +// +// In more normal circumstances, this makes a 20-40% differences, so +// it's good to get right, but not critical. The normal way that you +// decide which direction goes first is just figuring out which +// direction does more multiplies. But with modern CPUs with their +// fancy caches and SIMD and high IPC abilities, so there's just a lot +// more that goes into it. +// +// My handwavy sort of solution is to have an app that does a whole +// bunch of timing for both vertical and horizontal first modes, +// and then another app that can read lots of these timing files +// and try to search for the best weights to use. Dotimings.c +// is the app that does a bunch of timings, and vf_train.c is the +// app that solves for the best weights (and shows how well it +// does currently). + +static int stbir__should_do_vertical_first( float weights_table[STBIR_RESIZE_CLASSIFICATIONS][4], int horizontal_filter_pixel_width, float horizontal_scale, int horizontal_output_size, int vertical_filter_pixel_width, float vertical_scale, int vertical_output_size, int is_gather, STBIR__V_FIRST_INFO * info ) +{ + double v_cost, h_cost; + float * weights; + int vertical_first; + int v_classification; + + // categorize the resize into buckets + if ( ( vertical_output_size <= 4 ) || ( horizontal_output_size <= 4 ) ) + v_classification = ( vertical_output_size < horizontal_output_size ) ? 6 : 7; + else if ( ( !is_gather ) && ( ( vertical_output_size <= 16 ) || ( horizontal_output_size <= 16 ) ) ) + v_classification = 4; + else if ( vertical_scale <= 1.0f ) + v_classification = ( is_gather ) ? 1 : 0; + else if ( vertical_scale <= 2.0f) + v_classification = 2; + else if ( vertical_scale <= 3.0f) + v_classification = 3; + else + v_classification = 5; // everything bigger than 3x + + // use the right weights + weights = weights_table[ v_classification ]; + + // this is the costs when you don't take into account modern CPUs with high ipc and simd and caches - wish we had a better estimate + h_cost = (float)horizontal_filter_pixel_width * weights[0] + horizontal_scale * (float)vertical_filter_pixel_width * weights[1]; + v_cost = (float)vertical_filter_pixel_width * weights[2] + vertical_scale * (float)horizontal_filter_pixel_width * weights[3]; + + // use computation estimate to decide vertical first or not + vertical_first = ( v_cost <= h_cost ) ? 1 : 0; + + // save these, if requested + if ( info ) + { + info->h_cost = h_cost; + info->v_cost = v_cost; + info->v_resize_classification = v_classification; + info->v_first = vertical_first; + info->is_gather = is_gather; + } + + // and this allows us to override everything for testing (see dotiming.c) + if ( ( info ) && ( info->control_v_first ) ) + vertical_first = ( info->control_v_first == 2 ) ? 1 : 0; + + return vertical_first; +} + +// layout lookups - must match stbir_internal_pixel_layout +static unsigned char stbir__pixel_channels[] = { + 1,2,3,3,4, // 1ch, 2ch, rgb, bgr, 4ch + 4,4,4,4,2,2, // RGBA,BGRA,ARGB,ABGR,RA,AR + 4,4,4,4,2,2, // RGBA_PM,BGRA_PM,ARGB_PM,ABGR_PM,RA_PM,AR_PM +}; + +// the internal pixel layout enums are in a different order, so we can easily do range comparisons of types +// the public pixel layout is ordered in a way that if you cast num_channels (1-4) to the enum, you get something sensible +static stbir_internal_pixel_layout stbir__pixel_layout_convert_public_to_internal[] = { + STBIRI_BGR, STBIRI_1CHANNEL, STBIRI_2CHANNEL, STBIRI_RGB, STBIRI_RGBA, + STBIRI_4CHANNEL, STBIRI_BGRA, STBIRI_ARGB, STBIRI_ABGR, STBIRI_RA, STBIRI_AR, + STBIRI_RGBA_PM, STBIRI_BGRA_PM, STBIRI_ARGB_PM, STBIRI_ABGR_PM, STBIRI_RA_PM, STBIRI_AR_PM, +}; + +static stbir__info * stbir__alloc_internal_mem_and_build_samplers( stbir__sampler * horizontal, stbir__sampler * vertical, stbir__contributors * conservative, stbir_pixel_layout input_pixel_layout_public, stbir_pixel_layout output_pixel_layout_public, int splits, int new_x, int new_y, int fast_alpha, void * user_data STBIR_ONLY_PROFILE_BUILD_GET_INFO ) +{ + static char stbir_channel_count_index[8]={ 9,0,1,2, 3,9,9,4 }; + + stbir__info * info = 0; + void * alloced = 0; + size_t alloced_total = 0; + int vertical_first; + size_t decode_buffer_size, ring_buffer_length_bytes, ring_buffer_size, vertical_buffer_size; + int alloc_ring_buffer_num_entries; + + int alpha_weighting_type = 0; // 0=none, 1=simple, 2=fancy + int conservative_split_output_size = stbir__get_max_split( splits, vertical->scale_info.output_sub_size ); + stbir_internal_pixel_layout input_pixel_layout = stbir__pixel_layout_convert_public_to_internal[ input_pixel_layout_public ]; + stbir_internal_pixel_layout output_pixel_layout = stbir__pixel_layout_convert_public_to_internal[ output_pixel_layout_public ]; + int channels = stbir__pixel_channels[ input_pixel_layout ]; + int effective_channels = channels; + + // first figure out what type of alpha weighting to use (if any) + if ( ( horizontal->filter_enum != STBIR_FILTER_POINT_SAMPLE ) || ( vertical->filter_enum != STBIR_FILTER_POINT_SAMPLE ) ) // no alpha weighting on point sampling + { + if ( ( input_pixel_layout >= STBIRI_RGBA ) && ( input_pixel_layout <= STBIRI_AR ) && ( output_pixel_layout >= STBIRI_RGBA ) && ( output_pixel_layout <= STBIRI_AR ) ) + { + if ( fast_alpha ) + { + alpha_weighting_type = 4; + } + else + { + static int fancy_alpha_effective_cnts[6] = { 7, 7, 7, 7, 3, 3 }; + alpha_weighting_type = 2; + effective_channels = fancy_alpha_effective_cnts[ input_pixel_layout - STBIRI_RGBA ]; + } + } + else if ( ( input_pixel_layout >= STBIRI_RGBA_PM ) && ( input_pixel_layout <= STBIRI_AR_PM ) && ( output_pixel_layout >= STBIRI_RGBA ) && ( output_pixel_layout <= STBIRI_AR ) ) + { + // input premult, output non-premult + alpha_weighting_type = 3; + } + else if ( ( input_pixel_layout >= STBIRI_RGBA ) && ( input_pixel_layout <= STBIRI_AR ) && ( output_pixel_layout >= STBIRI_RGBA_PM ) && ( output_pixel_layout <= STBIRI_AR_PM ) ) + { + // input non-premult, output premult + alpha_weighting_type = 1; + } + } + + // channel in and out count must match currently + if ( channels != stbir__pixel_channels[ output_pixel_layout ] ) + return 0; + + // get vertical first + vertical_first = stbir__should_do_vertical_first( stbir__compute_weights[ (int)stbir_channel_count_index[ effective_channels ] ], horizontal->filter_pixel_width, horizontal->scale_info.scale, horizontal->scale_info.output_sub_size, vertical->filter_pixel_width, vertical->scale_info.scale, vertical->scale_info.output_sub_size, vertical->is_gather, STBIR__V_FIRST_INFO_POINTER ); + + // sometimes read one float off in some of the unrolled loops (with a weight of zero coeff, so it doesn't have an effect) + // we use a few extra floats instead of just 1, so that input callback buffer can overlap with the decode buffer without + // the conversion routines overwriting the callback input data. + decode_buffer_size = ( conservative->n1 - conservative->n0 + 1 ) * effective_channels * sizeof(float) + sizeof(float)*STBIR_INPUT_CALLBACK_PADDING; // extra floats for input callback stagger + +#if defined( STBIR__SEPARATE_ALLOCATIONS ) && defined(STBIR_SIMD8) + if ( effective_channels == 3 ) + decode_buffer_size += sizeof(float); // avx in 3 channel mode needs one float at the start of the buffer (only with separate allocations) +#endif + + ring_buffer_length_bytes = (size_t)horizontal->scale_info.output_sub_size * (size_t)effective_channels * sizeof(float) + sizeof(float)*STBIR_INPUT_CALLBACK_PADDING; // extra floats for padding + + // if we do vertical first, the ring buffer holds a whole decoded line + if ( vertical_first ) + ring_buffer_length_bytes = ( decode_buffer_size + 15 ) & ~15; + + if ( ( ring_buffer_length_bytes & 4095 ) == 0 ) ring_buffer_length_bytes += 64*3; // avoid 4k alias + + // One extra entry because floating point precision problems sometimes cause an extra to be necessary. + alloc_ring_buffer_num_entries = vertical->filter_pixel_width + 1; + + // we never need more ring buffer entries than the scanlines we're outputting when in scatter mode + if ( ( !vertical->is_gather ) && ( alloc_ring_buffer_num_entries > conservative_split_output_size ) ) + alloc_ring_buffer_num_entries = conservative_split_output_size; + + ring_buffer_size = (size_t)alloc_ring_buffer_num_entries * (size_t)ring_buffer_length_bytes; + + // The vertical buffer is used differently, depending on whether we are scattering + // the vertical scanlines, or gathering them. + // If scattering, it's used at the temp buffer to accumulate each output. + // If gathering, it's just the output buffer. + vertical_buffer_size = (size_t)horizontal->scale_info.output_sub_size * (size_t)effective_channels * sizeof(float) + sizeof(float); // extra float for padding + + // we make two passes through this loop, 1st to add everything up, 2nd to allocate and init + for(;;) + { + int i; + void * advance_mem = alloced; + int copy_horizontal = 0; + stbir__sampler * possibly_use_horizontal_for_pivot = 0; + +#ifdef STBIR__SEPARATE_ALLOCATIONS + #define STBIR__NEXT_PTR( ptr, size, ntype ) if ( alloced ) { void * p = STBIR_MALLOC( size, user_data); if ( p == 0 ) { stbir__free_internal_mem( info ); return 0; } (ptr) = (ntype*)p; } +#else + #define STBIR__NEXT_PTR( ptr, size, ntype ) advance_mem = (void*) ( ( ((size_t)advance_mem) + 15 ) & ~15 ); if ( alloced ) ptr = (ntype*)advance_mem; advance_mem = (char*)(((size_t)advance_mem) + (size)); +#endif + + STBIR__NEXT_PTR( info, sizeof( stbir__info ), stbir__info ); + + STBIR__NEXT_PTR( info->split_info, sizeof( stbir__per_split_info ) * splits, stbir__per_split_info ); + + if ( info ) + { + static stbir__alpha_weight_func * fancy_alpha_weights[6] = { stbir__fancy_alpha_weight_4ch, stbir__fancy_alpha_weight_4ch, stbir__fancy_alpha_weight_4ch, stbir__fancy_alpha_weight_4ch, stbir__fancy_alpha_weight_2ch, stbir__fancy_alpha_weight_2ch }; + static stbir__alpha_unweight_func * fancy_alpha_unweights[6] = { stbir__fancy_alpha_unweight_4ch, stbir__fancy_alpha_unweight_4ch, stbir__fancy_alpha_unweight_4ch, stbir__fancy_alpha_unweight_4ch, stbir__fancy_alpha_unweight_2ch, stbir__fancy_alpha_unweight_2ch }; + static stbir__alpha_weight_func * simple_alpha_weights[6] = { stbir__simple_alpha_weight_4ch, stbir__simple_alpha_weight_4ch, stbir__simple_alpha_weight_4ch, stbir__simple_alpha_weight_4ch, stbir__simple_alpha_weight_2ch, stbir__simple_alpha_weight_2ch }; + static stbir__alpha_unweight_func * simple_alpha_unweights[6] = { stbir__simple_alpha_unweight_4ch, stbir__simple_alpha_unweight_4ch, stbir__simple_alpha_unweight_4ch, stbir__simple_alpha_unweight_4ch, stbir__simple_alpha_unweight_2ch, stbir__simple_alpha_unweight_2ch }; + + // initialize info fields + info->alloced_mem = alloced; + info->alloced_total = alloced_total; + + info->channels = channels; + info->effective_channels = effective_channels; + + info->offset_x = new_x; + info->offset_y = new_y; + info->alloc_ring_buffer_num_entries = (int)alloc_ring_buffer_num_entries; + info->ring_buffer_num_entries = 0; + info->ring_buffer_length_bytes = (int)ring_buffer_length_bytes; + info->splits = splits; + info->vertical_first = vertical_first; + + info->input_pixel_layout_internal = input_pixel_layout; + info->output_pixel_layout_internal = output_pixel_layout; + + // setup alpha weight functions + info->alpha_weight = 0; + info->alpha_unweight = 0; + + // handle alpha weighting functions and overrides + if ( alpha_weighting_type == 2 ) + { + // high quality alpha multiplying on the way in, dividing on the way out + info->alpha_weight = fancy_alpha_weights[ input_pixel_layout - STBIRI_RGBA ]; + info->alpha_unweight = fancy_alpha_unweights[ output_pixel_layout - STBIRI_RGBA ]; + } + else if ( alpha_weighting_type == 4 ) + { + // fast alpha multiplying on the way in, dividing on the way out + info->alpha_weight = simple_alpha_weights[ input_pixel_layout - STBIRI_RGBA ]; + info->alpha_unweight = simple_alpha_unweights[ output_pixel_layout - STBIRI_RGBA ]; + } + else if ( alpha_weighting_type == 1 ) + { + // fast alpha on the way in, leave in premultiplied form on way out + info->alpha_weight = simple_alpha_weights[ input_pixel_layout - STBIRI_RGBA ]; + } + else if ( alpha_weighting_type == 3 ) + { + // incoming is premultiplied, fast alpha dividing on the way out - non-premultiplied output + info->alpha_unweight = simple_alpha_unweights[ output_pixel_layout - STBIRI_RGBA ]; + } + + // handle 3-chan color flipping, using the alpha weight path + if ( ( ( input_pixel_layout == STBIRI_RGB ) && ( output_pixel_layout == STBIRI_BGR ) ) || + ( ( input_pixel_layout == STBIRI_BGR ) && ( output_pixel_layout == STBIRI_RGB ) ) ) + { + // do the flipping on the smaller of the two ends + if ( horizontal->scale_info.scale < 1.0f ) + info->alpha_unweight = stbir__simple_flip_3ch; + else + info->alpha_weight = stbir__simple_flip_3ch; + } + + } + + // get all the per-split buffers + for( i = 0 ; i < splits ; i++ ) + { + STBIR__NEXT_PTR( info->split_info[i].decode_buffer, decode_buffer_size, float ); + +#ifdef STBIR__SEPARATE_ALLOCATIONS + + #ifdef STBIR_SIMD8 + if ( ( info ) && ( effective_channels == 3 ) ) + ++info->split_info[i].decode_buffer; // avx in 3 channel mode needs one float at the start of the buffer + #endif + + STBIR__NEXT_PTR( info->split_info[i].ring_buffers, alloc_ring_buffer_num_entries * sizeof(float*), float* ); + { + int j; + for( j = 0 ; j < alloc_ring_buffer_num_entries ; j++ ) + { + STBIR__NEXT_PTR( info->split_info[i].ring_buffers[j], ring_buffer_length_bytes, float ); + #ifdef STBIR_SIMD8 + if ( ( info ) && ( effective_channels == 3 ) ) + ++info->split_info[i].ring_buffers[j]; // avx in 3 channel mode needs one float at the start of the buffer + #endif + } + } +#else + STBIR__NEXT_PTR( info->split_info[i].ring_buffer, ring_buffer_size, float ); +#endif + STBIR__NEXT_PTR( info->split_info[i].vertical_buffer, vertical_buffer_size, float ); + } + + // alloc memory for to-be-pivoted coeffs (if necessary) + if ( vertical->is_gather == 0 ) + { + size_t both; + size_t temp_mem_amt; + + // when in vertical scatter mode, we first build the coefficients in gather mode, and then pivot after, + // that means we need two buffers, so we try to use the decode buffer and ring buffer for this. if that + // is too small, we just allocate extra memory to use as this temp. + + both = (size_t)vertical->gather_prescatter_contributors_size + (size_t)vertical->gather_prescatter_coefficients_size; + +#ifdef STBIR__SEPARATE_ALLOCATIONS + temp_mem_amt = decode_buffer_size; + + #ifdef STBIR_SIMD8 + if ( effective_channels == 3 ) + --temp_mem_amt; // avx in 3 channel mode needs one float at the start of the buffer + #endif +#else + temp_mem_amt = (size_t)( decode_buffer_size + ring_buffer_size + vertical_buffer_size ) * (size_t)splits; +#endif + if ( temp_mem_amt >= both ) + { + if ( info ) + { + vertical->gather_prescatter_contributors = (stbir__contributors*)info->split_info[0].decode_buffer; + vertical->gather_prescatter_coefficients = (float*) ( ( (char*)info->split_info[0].decode_buffer ) + vertical->gather_prescatter_contributors_size ); + } + } + else + { + // ring+decode memory is too small, so allocate temp memory + STBIR__NEXT_PTR( vertical->gather_prescatter_contributors, vertical->gather_prescatter_contributors_size, stbir__contributors ); + STBIR__NEXT_PTR( vertical->gather_prescatter_coefficients, vertical->gather_prescatter_coefficients_size, float ); + } + } + + STBIR__NEXT_PTR( horizontal->contributors, horizontal->contributors_size, stbir__contributors ); + STBIR__NEXT_PTR( horizontal->coefficients, horizontal->coefficients_size, float ); + + // are the two filters identical?? (happens a lot with mipmap generation) + if ( ( horizontal->filter_kernel == vertical->filter_kernel ) && ( horizontal->filter_support == vertical->filter_support ) && ( horizontal->edge == vertical->edge ) && ( horizontal->scale_info.output_sub_size == vertical->scale_info.output_sub_size ) ) + { + float diff_scale = horizontal->scale_info.scale - vertical->scale_info.scale; + float diff_shift = horizontal->scale_info.pixel_shift - vertical->scale_info.pixel_shift; + if ( diff_scale < 0.0f ) diff_scale = -diff_scale; + if ( diff_shift < 0.0f ) diff_shift = -diff_shift; + if ( ( diff_scale <= stbir__small_float ) && ( diff_shift <= stbir__small_float ) ) + { + if ( horizontal->is_gather == vertical->is_gather ) + { + copy_horizontal = 1; + goto no_vert_alloc; + } + // everything matches, but vertical is scatter, horizontal is gather, use horizontal coeffs for vertical pivot coeffs + possibly_use_horizontal_for_pivot = horizontal; + } + } + + STBIR__NEXT_PTR( vertical->contributors, vertical->contributors_size, stbir__contributors ); + STBIR__NEXT_PTR( vertical->coefficients, vertical->coefficients_size, float ); + + no_vert_alloc: + + if ( info ) + { + STBIR_PROFILE_BUILD_START( horizontal ); + + stbir__calculate_filters( horizontal, 0, user_data STBIR_ONLY_PROFILE_BUILD_SET_INFO ); + + // setup the horizontal gather functions + // start with defaulting to the n_coeffs functions (specialized on channels and remnant leftover) + info->horizontal_gather_channels = stbir__horizontal_gather_n_coeffs_funcs[ effective_channels ][ horizontal->extent_info.widest & 3 ]; + // but if the number of coeffs <= 12, use another set of special cases. <=12 coeffs is any enlarging resize, or shrinking resize down to about 1/3 size + if ( horizontal->extent_info.widest <= 12 ) + info->horizontal_gather_channels = stbir__horizontal_gather_channels_funcs[ effective_channels ][ horizontal->extent_info.widest - 1 ]; + + info->scanline_extents.conservative.n0 = conservative->n0; + info->scanline_extents.conservative.n1 = conservative->n1; + + // get exact extents + stbir__get_extents( horizontal, &info->scanline_extents ); + + // pack the horizontal coeffs + horizontal->coefficient_width = stbir__pack_coefficients(horizontal->num_contributors, horizontal->contributors, horizontal->coefficients, horizontal->coefficient_width, horizontal->extent_info.widest, info->scanline_extents.conservative.n0, info->scanline_extents.conservative.n1 ); + + STBIR_MEMCPY( &info->horizontal, horizontal, sizeof( stbir__sampler ) ); + + STBIR_PROFILE_BUILD_END( horizontal ); + + if ( copy_horizontal ) + { + STBIR_MEMCPY( &info->vertical, horizontal, sizeof( stbir__sampler ) ); + } + else + { + STBIR_PROFILE_BUILD_START( vertical ); + + stbir__calculate_filters( vertical, possibly_use_horizontal_for_pivot, user_data STBIR_ONLY_PROFILE_BUILD_SET_INFO ); + STBIR_MEMCPY( &info->vertical, vertical, sizeof( stbir__sampler ) ); + + STBIR_PROFILE_BUILD_END( vertical ); + } + + // setup the vertical split ranges + stbir__get_split_info( info->split_info, info->splits, info->vertical.scale_info.output_sub_size, info->vertical.filter_pixel_margin, info->vertical.scale_info.input_full_size, info->vertical.is_gather, info->vertical.contributors ); + + // now we know precisely how many entries we need + info->ring_buffer_num_entries = info->vertical.extent_info.widest; + + // we never need more ring buffer entries than the scanlines we're outputting + if ( ( !info->vertical.is_gather ) && ( info->ring_buffer_num_entries > conservative_split_output_size ) ) + info->ring_buffer_num_entries = conservative_split_output_size; + STBIR_ASSERT( info->ring_buffer_num_entries <= info->alloc_ring_buffer_num_entries ); + } + #undef STBIR__NEXT_PTR + + + // is this the first time through loop? + if ( info == 0 ) + { + alloced_total = ( 15 + (size_t)advance_mem ); + alloced = STBIR_MALLOC( alloced_total, user_data ); + if ( alloced == 0 ) + return 0; + } + else + return info; // success + } +} + +static int stbir__perform_resize( stbir__info const * info, int split_start, int split_count ) +{ + stbir__per_split_info * split_info = info->split_info + split_start; + + STBIR_PROFILE_CLEAR_EXTRAS(); + + STBIR_PROFILE_FIRST_START( looping ); + if (info->vertical.is_gather) + stbir__vertical_gather_loop( info, split_info, split_count ); + else + stbir__vertical_scatter_loop( info, split_info, split_count ); + STBIR_PROFILE_END( looping ); + + return 1; +} + +static void stbir__update_info_from_resize( stbir__info * info, STBIR_RESIZE * resize ) +{ + static stbir__decode_pixels_func * decode_simple[STBIR_TYPE_HALF_FLOAT-STBIR_TYPE_UINT8_SRGB+1]= + { + /* 1ch-4ch */ stbir__decode_uint8_srgb, stbir__decode_uint8_srgb, 0, stbir__decode_float_linear, stbir__decode_half_float_linear, + }; + + static stbir__decode_pixels_func * decode_alphas[STBIRI_AR-STBIRI_RGBA+1][STBIR_TYPE_HALF_FLOAT-STBIR_TYPE_UINT8_SRGB+1]= + { + { /* RGBA */ stbir__decode_uint8_srgb4_linearalpha, stbir__decode_uint8_srgb, 0, stbir__decode_float_linear, stbir__decode_half_float_linear }, + { /* BGRA */ stbir__decode_uint8_srgb4_linearalpha_BGRA, stbir__decode_uint8_srgb_BGRA, 0, stbir__decode_float_linear_BGRA, stbir__decode_half_float_linear_BGRA }, + { /* ARGB */ stbir__decode_uint8_srgb4_linearalpha_ARGB, stbir__decode_uint8_srgb_ARGB, 0, stbir__decode_float_linear_ARGB, stbir__decode_half_float_linear_ARGB }, + { /* ABGR */ stbir__decode_uint8_srgb4_linearalpha_ABGR, stbir__decode_uint8_srgb_ABGR, 0, stbir__decode_float_linear_ABGR, stbir__decode_half_float_linear_ABGR }, + { /* RA */ stbir__decode_uint8_srgb2_linearalpha, stbir__decode_uint8_srgb, 0, stbir__decode_float_linear, stbir__decode_half_float_linear }, + { /* AR */ stbir__decode_uint8_srgb2_linearalpha_AR, stbir__decode_uint8_srgb_AR, 0, stbir__decode_float_linear_AR, stbir__decode_half_float_linear_AR }, + }; + + static stbir__decode_pixels_func * decode_simple_scaled_or_not[2][2]= + { + { stbir__decode_uint8_linear_scaled, stbir__decode_uint8_linear }, { stbir__decode_uint16_linear_scaled, stbir__decode_uint16_linear }, + }; + + static stbir__decode_pixels_func * decode_alphas_scaled_or_not[STBIRI_AR-STBIRI_RGBA+1][2][2]= + { + { /* RGBA */ { stbir__decode_uint8_linear_scaled, stbir__decode_uint8_linear }, { stbir__decode_uint16_linear_scaled, stbir__decode_uint16_linear } }, + { /* BGRA */ { stbir__decode_uint8_linear_scaled_BGRA, stbir__decode_uint8_linear_BGRA }, { stbir__decode_uint16_linear_scaled_BGRA, stbir__decode_uint16_linear_BGRA } }, + { /* ARGB */ { stbir__decode_uint8_linear_scaled_ARGB, stbir__decode_uint8_linear_ARGB }, { stbir__decode_uint16_linear_scaled_ARGB, stbir__decode_uint16_linear_ARGB } }, + { /* ABGR */ { stbir__decode_uint8_linear_scaled_ABGR, stbir__decode_uint8_linear_ABGR }, { stbir__decode_uint16_linear_scaled_ABGR, stbir__decode_uint16_linear_ABGR } }, + { /* RA */ { stbir__decode_uint8_linear_scaled, stbir__decode_uint8_linear }, { stbir__decode_uint16_linear_scaled, stbir__decode_uint16_linear } }, + { /* AR */ { stbir__decode_uint8_linear_scaled_AR, stbir__decode_uint8_linear_AR }, { stbir__decode_uint16_linear_scaled_AR, stbir__decode_uint16_linear_AR } } + }; + + static stbir__encode_pixels_func * encode_simple[STBIR_TYPE_HALF_FLOAT-STBIR_TYPE_UINT8_SRGB+1]= + { + /* 1ch-4ch */ stbir__encode_uint8_srgb, stbir__encode_uint8_srgb, 0, stbir__encode_float_linear, stbir__encode_half_float_linear, + }; + + static stbir__encode_pixels_func * encode_alphas[STBIRI_AR-STBIRI_RGBA+1][STBIR_TYPE_HALF_FLOAT-STBIR_TYPE_UINT8_SRGB+1]= + { + { /* RGBA */ stbir__encode_uint8_srgb4_linearalpha, stbir__encode_uint8_srgb, 0, stbir__encode_float_linear, stbir__encode_half_float_linear }, + { /* BGRA */ stbir__encode_uint8_srgb4_linearalpha_BGRA, stbir__encode_uint8_srgb_BGRA, 0, stbir__encode_float_linear_BGRA, stbir__encode_half_float_linear_BGRA }, + { /* ARGB */ stbir__encode_uint8_srgb4_linearalpha_ARGB, stbir__encode_uint8_srgb_ARGB, 0, stbir__encode_float_linear_ARGB, stbir__encode_half_float_linear_ARGB }, + { /* ABGR */ stbir__encode_uint8_srgb4_linearalpha_ABGR, stbir__encode_uint8_srgb_ABGR, 0, stbir__encode_float_linear_ABGR, stbir__encode_half_float_linear_ABGR }, + { /* RA */ stbir__encode_uint8_srgb2_linearalpha, stbir__encode_uint8_srgb, 0, stbir__encode_float_linear, stbir__encode_half_float_linear }, + { /* AR */ stbir__encode_uint8_srgb2_linearalpha_AR, stbir__encode_uint8_srgb_AR, 0, stbir__encode_float_linear_AR, stbir__encode_half_float_linear_AR } + }; + + static stbir__encode_pixels_func * encode_simple_scaled_or_not[2][2]= + { + { stbir__encode_uint8_linear_scaled, stbir__encode_uint8_linear }, { stbir__encode_uint16_linear_scaled, stbir__encode_uint16_linear }, + }; + + static stbir__encode_pixels_func * encode_alphas_scaled_or_not[STBIRI_AR-STBIRI_RGBA+1][2][2]= + { + { /* RGBA */ { stbir__encode_uint8_linear_scaled, stbir__encode_uint8_linear }, { stbir__encode_uint16_linear_scaled, stbir__encode_uint16_linear } }, + { /* BGRA */ { stbir__encode_uint8_linear_scaled_BGRA, stbir__encode_uint8_linear_BGRA }, { stbir__encode_uint16_linear_scaled_BGRA, stbir__encode_uint16_linear_BGRA } }, + { /* ARGB */ { stbir__encode_uint8_linear_scaled_ARGB, stbir__encode_uint8_linear_ARGB }, { stbir__encode_uint16_linear_scaled_ARGB, stbir__encode_uint16_linear_ARGB } }, + { /* ABGR */ { stbir__encode_uint8_linear_scaled_ABGR, stbir__encode_uint8_linear_ABGR }, { stbir__encode_uint16_linear_scaled_ABGR, stbir__encode_uint16_linear_ABGR } }, + { /* RA */ { stbir__encode_uint8_linear_scaled, stbir__encode_uint8_linear }, { stbir__encode_uint16_linear_scaled, stbir__encode_uint16_linear } }, + { /* AR */ { stbir__encode_uint8_linear_scaled_AR, stbir__encode_uint8_linear_AR }, { stbir__encode_uint16_linear_scaled_AR, stbir__encode_uint16_linear_AR } } + }; + + stbir__decode_pixels_func * decode_pixels = 0; + stbir__encode_pixels_func * encode_pixels = 0; + stbir_datatype input_type, output_type; + + input_type = resize->input_data_type; + output_type = resize->output_data_type; + info->input_data = resize->input_pixels; + info->input_stride_bytes = resize->input_stride_in_bytes; + info->output_stride_bytes = resize->output_stride_in_bytes; + + // if we're completely point sampling, then we can turn off SRGB + if ( ( info->horizontal.filter_enum == STBIR_FILTER_POINT_SAMPLE ) && ( info->vertical.filter_enum == STBIR_FILTER_POINT_SAMPLE ) ) + { + if ( ( ( input_type == STBIR_TYPE_UINT8_SRGB ) || ( input_type == STBIR_TYPE_UINT8_SRGB_ALPHA ) ) && + ( ( output_type == STBIR_TYPE_UINT8_SRGB ) || ( output_type == STBIR_TYPE_UINT8_SRGB_ALPHA ) ) ) + { + input_type = STBIR_TYPE_UINT8; + output_type = STBIR_TYPE_UINT8; + } + } + + // recalc the output and input strides + if ( info->input_stride_bytes == 0 ) + info->input_stride_bytes = info->channels * info->horizontal.scale_info.input_full_size * stbir__type_size[input_type]; + + if ( info->output_stride_bytes == 0 ) + info->output_stride_bytes = info->channels * info->horizontal.scale_info.output_sub_size * stbir__type_size[output_type]; + + // calc offset + info->output_data = ( (char*) resize->output_pixels ) + ( (size_t) info->offset_y * (size_t) resize->output_stride_in_bytes ) + ( info->offset_x * info->channels * stbir__type_size[output_type] ); + + info->in_pixels_cb = resize->input_cb; + info->user_data = resize->user_data; + info->out_pixels_cb = resize->output_cb; + + // setup the input format converters + if ( ( input_type == STBIR_TYPE_UINT8 ) || ( input_type == STBIR_TYPE_UINT16 ) ) + { + int non_scaled = 0; + + // check if we can run unscaled - 0-255.0/0-65535.0 instead of 0-1.0 (which is a tiny bit faster when doing linear 8->8 or 16->16) + if ( ( !info->alpha_weight ) && ( !info->alpha_unweight ) ) // don't short circuit when alpha weighting (get everything to 0-1.0 as usual) + if ( ( ( input_type == STBIR_TYPE_UINT8 ) && ( output_type == STBIR_TYPE_UINT8 ) ) || ( ( input_type == STBIR_TYPE_UINT16 ) && ( output_type == STBIR_TYPE_UINT16 ) ) ) + non_scaled = 1; + + if ( info->input_pixel_layout_internal <= STBIRI_4CHANNEL ) + decode_pixels = decode_simple_scaled_or_not[ input_type == STBIR_TYPE_UINT16 ][ non_scaled ]; + else + decode_pixels = decode_alphas_scaled_or_not[ ( info->input_pixel_layout_internal - STBIRI_RGBA ) % ( STBIRI_AR-STBIRI_RGBA+1 ) ][ input_type == STBIR_TYPE_UINT16 ][ non_scaled ]; + } + else + { + if ( info->input_pixel_layout_internal <= STBIRI_4CHANNEL ) + decode_pixels = decode_simple[ input_type - STBIR_TYPE_UINT8_SRGB ]; + else + decode_pixels = decode_alphas[ ( info->input_pixel_layout_internal - STBIRI_RGBA ) % ( STBIRI_AR-STBIRI_RGBA+1 ) ][ input_type - STBIR_TYPE_UINT8_SRGB ]; + } + + // setup the output format converters + if ( ( output_type == STBIR_TYPE_UINT8 ) || ( output_type == STBIR_TYPE_UINT16 ) ) + { + int non_scaled = 0; + + // check if we can run unscaled - 0-255.0/0-65535.0 instead of 0-1.0 (which is a tiny bit faster when doing linear 8->8 or 16->16) + if ( ( !info->alpha_weight ) && ( !info->alpha_unweight ) ) // don't short circuit when alpha weighting (get everything to 0-1.0 as usual) + if ( ( ( input_type == STBIR_TYPE_UINT8 ) && ( output_type == STBIR_TYPE_UINT8 ) ) || ( ( input_type == STBIR_TYPE_UINT16 ) && ( output_type == STBIR_TYPE_UINT16 ) ) ) + non_scaled = 1; + + if ( info->output_pixel_layout_internal <= STBIRI_4CHANNEL ) + encode_pixels = encode_simple_scaled_or_not[ output_type == STBIR_TYPE_UINT16 ][ non_scaled ]; + else + encode_pixels = encode_alphas_scaled_or_not[ ( info->output_pixel_layout_internal - STBIRI_RGBA ) % ( STBIRI_AR-STBIRI_RGBA+1 ) ][ output_type == STBIR_TYPE_UINT16 ][ non_scaled ]; + } + else + { + if ( info->output_pixel_layout_internal <= STBIRI_4CHANNEL ) + encode_pixels = encode_simple[ output_type - STBIR_TYPE_UINT8_SRGB ]; + else + encode_pixels = encode_alphas[ ( info->output_pixel_layout_internal - STBIRI_RGBA ) % ( STBIRI_AR-STBIRI_RGBA+1 ) ][ output_type - STBIR_TYPE_UINT8_SRGB ]; + } + + info->input_type = input_type; + info->output_type = output_type; + info->decode_pixels = decode_pixels; + info->encode_pixels = encode_pixels; +} + +static void stbir__clip( int * outx, int * outsubw, int outw, double * u0, double * u1 ) +{ + double per, adj; + int over; + + // do left/top edge + if ( *outx < 0 ) + { + per = ( (double)*outx ) / ( (double)*outsubw ); // is negative + adj = per * ( *u1 - *u0 ); + *u0 -= adj; // increases u0 + *outx = 0; + } + + // do right/bot edge + over = outw - ( *outx + *outsubw ); + if ( over < 0 ) + { + per = ( (double)over ) / ( (double)*outsubw ); // is negative + adj = per * ( *u1 - *u0 ); + *u1 += adj; // decrease u1 + *outsubw = outw - *outx; + } +} + +// converts a double to a rational that has less than one float bit of error (returns 0 if unable to do so) +static int stbir__double_to_rational(double f, stbir_uint32 limit, stbir_uint32 *numer, stbir_uint32 *denom, int limit_denom ) // limit_denom (1) or limit numer (0) +{ + double err; + stbir_uint64 top, bot; + stbir_uint64 numer_last = 0; + stbir_uint64 denom_last = 1; + stbir_uint64 numer_estimate = 1; + stbir_uint64 denom_estimate = 0; + + // scale to past float error range + top = (stbir_uint64)( f * (double)(1 << 25) ); + bot = 1 << 25; + + // keep refining, but usually stops in a few loops - usually 5 for bad cases + for(;;) + { + stbir_uint64 est, temp; + + // hit limit, break out and do best full range estimate + if ( ( ( limit_denom ) ? denom_estimate : numer_estimate ) >= limit ) + break; + + // is the current error less than 1 bit of a float? if so, we're done + if ( denom_estimate ) + { + err = ( (double)numer_estimate / (double)denom_estimate ) - f; + if ( err < 0.0 ) err = -err; + if ( err < ( 1.0 / (double)(1<<24) ) ) + { + // yup, found it + *numer = (stbir_uint32) numer_estimate; + *denom = (stbir_uint32) denom_estimate; + return 1; + } + } + + // no more refinement bits left? break out and do full range estimate + if ( bot == 0 ) + break; + + // gcd the estimate bits + est = top / bot; + temp = top % bot; + top = bot; + bot = temp; + + // move remainders + temp = est * denom_estimate + denom_last; + denom_last = denom_estimate; + denom_estimate = temp; + + // move remainders + temp = est * numer_estimate + numer_last; + numer_last = numer_estimate; + numer_estimate = temp; + } + + // we didn't find anything good enough for float, use a full range estimate + if ( limit_denom ) + { + numer_estimate= (stbir_uint64)( f * (double)limit + 0.5 ); + denom_estimate = limit; + } + else + { + numer_estimate = limit; + denom_estimate = (stbir_uint64)( ( (double)limit / f ) + 0.5 ); + } + + *numer = (stbir_uint32) numer_estimate; + *denom = (stbir_uint32) denom_estimate; + + err = ( denom_estimate ) ? ( ( (double)(stbir_uint32)numer_estimate / (double)(stbir_uint32)denom_estimate ) - f ) : 1.0; + if ( err < 0.0 ) err = -err; + return ( err < ( 1.0 / (double)(1<<24) ) ) ? 1 : 0; +} + +static int stbir__calculate_region_transform( stbir__scale_info * scale_info, int output_full_range, int * output_offset, int output_sub_range, int input_full_range, double input_s0, double input_s1 ) +{ + double output_range, input_range, output_s, input_s, ratio, scale; + + input_s = input_s1 - input_s0; + + // null area + if ( ( output_full_range == 0 ) || ( input_full_range == 0 ) || + ( output_sub_range == 0 ) || ( input_s <= stbir__small_float ) ) + return 0; + + // are either of the ranges completely out of bounds? + if ( ( *output_offset >= output_full_range ) || ( ( *output_offset + output_sub_range ) <= 0 ) || ( input_s0 >= (1.0f-stbir__small_float) ) || ( input_s1 <= stbir__small_float ) ) + return 0; + + output_range = (double)output_full_range; + input_range = (double)input_full_range; + + output_s = ( (double)output_sub_range) / output_range; + + // figure out the scaling to use + ratio = output_s / input_s; + + // save scale before clipping + scale = ( output_range / input_range ) * ratio; + scale_info->scale = (float)scale; + scale_info->inv_scale = (float)( 1.0 / scale ); + + // clip output area to left/right output edges (and adjust input area) + stbir__clip( output_offset, &output_sub_range, output_full_range, &input_s0, &input_s1 ); + + // recalc input area + input_s = input_s1 - input_s0; + + // after clipping do we have zero input area? + if ( input_s <= stbir__small_float ) + return 0; + + // calculate and store the starting source offsets in output pixel space + scale_info->pixel_shift = (float) ( input_s0 * ratio * output_range ); + + scale_info->scale_is_rational = stbir__double_to_rational( scale, ( scale <= 1.0 ) ? output_full_range : input_full_range, &scale_info->scale_numerator, &scale_info->scale_denominator, ( scale >= 1.0 ) ); + + scale_info->input_full_size = input_full_range; + scale_info->output_sub_size = output_sub_range; + + return 1; +} + + +static void stbir__init_and_set_layout( STBIR_RESIZE * resize, stbir_pixel_layout pixel_layout, stbir_datatype data_type ) +{ + resize->input_cb = 0; + resize->output_cb = 0; + resize->user_data = resize; + resize->samplers = 0; + resize->called_alloc = 0; + resize->horizontal_filter = STBIR_FILTER_DEFAULT; + resize->horizontal_filter_kernel = 0; resize->horizontal_filter_support = 0; + resize->vertical_filter = STBIR_FILTER_DEFAULT; + resize->vertical_filter_kernel = 0; resize->vertical_filter_support = 0; + resize->horizontal_edge = STBIR_EDGE_CLAMP; + resize->vertical_edge = STBIR_EDGE_CLAMP; + resize->input_s0 = 0; resize->input_t0 = 0; resize->input_s1 = 1; resize->input_t1 = 1; + resize->output_subx = 0; resize->output_suby = 0; resize->output_subw = resize->output_w; resize->output_subh = resize->output_h; + resize->input_data_type = data_type; + resize->output_data_type = data_type; + resize->input_pixel_layout_public = pixel_layout; + resize->output_pixel_layout_public = pixel_layout; + resize->needs_rebuild = 1; +} + +STBIRDEF void stbir_resize_init( STBIR_RESIZE * resize, + const void *input_pixels, int input_w, int input_h, int input_stride_in_bytes, // stride can be zero + void *output_pixels, int output_w, int output_h, int output_stride_in_bytes, // stride can be zero + stbir_pixel_layout pixel_layout, stbir_datatype data_type ) +{ + resize->input_pixels = input_pixels; + resize->input_w = input_w; + resize->input_h = input_h; + resize->input_stride_in_bytes = input_stride_in_bytes; + resize->output_pixels = output_pixels; + resize->output_w = output_w; + resize->output_h = output_h; + resize->output_stride_in_bytes = output_stride_in_bytes; + resize->fast_alpha = 0; + + stbir__init_and_set_layout( resize, pixel_layout, data_type ); +} + +// You can update parameters any time after resize_init +STBIRDEF void stbir_set_datatypes( STBIR_RESIZE * resize, stbir_datatype input_type, stbir_datatype output_type ) // by default, datatype from resize_init +{ + resize->input_data_type = input_type; + resize->output_data_type = output_type; + if ( ( resize->samplers ) && ( !resize->needs_rebuild ) ) + stbir__update_info_from_resize( resize->samplers, resize ); +} + +STBIRDEF void stbir_set_pixel_callbacks( STBIR_RESIZE * resize, stbir_input_callback * input_cb, stbir_output_callback * output_cb ) // no callbacks by default +{ + resize->input_cb = input_cb; + resize->output_cb = output_cb; + + if ( ( resize->samplers ) && ( !resize->needs_rebuild ) ) + { + resize->samplers->in_pixels_cb = input_cb; + resize->samplers->out_pixels_cb = output_cb; + } +} + +STBIRDEF void stbir_set_user_data( STBIR_RESIZE * resize, void * user_data ) // pass back STBIR_RESIZE* by default +{ + resize->user_data = user_data; + if ( ( resize->samplers ) && ( !resize->needs_rebuild ) ) + resize->samplers->user_data = user_data; +} + +STBIRDEF void stbir_set_buffer_ptrs( STBIR_RESIZE * resize, const void * input_pixels, int input_stride_in_bytes, void * output_pixels, int output_stride_in_bytes ) +{ + resize->input_pixels = input_pixels; + resize->input_stride_in_bytes = input_stride_in_bytes; + resize->output_pixels = output_pixels; + resize->output_stride_in_bytes = output_stride_in_bytes; + if ( ( resize->samplers ) && ( !resize->needs_rebuild ) ) + stbir__update_info_from_resize( resize->samplers, resize ); +} + + +STBIRDEF int stbir_set_edgemodes( STBIR_RESIZE * resize, stbir_edge horizontal_edge, stbir_edge vertical_edge ) // CLAMP by default +{ + resize->horizontal_edge = horizontal_edge; + resize->vertical_edge = vertical_edge; + resize->needs_rebuild = 1; + return 1; +} + +STBIRDEF int stbir_set_filters( STBIR_RESIZE * resize, stbir_filter horizontal_filter, stbir_filter vertical_filter ) // STBIR_DEFAULT_FILTER_UPSAMPLE/DOWNSAMPLE by default +{ + resize->horizontal_filter = horizontal_filter; + resize->vertical_filter = vertical_filter; + resize->needs_rebuild = 1; + return 1; +} + +STBIRDEF int stbir_set_filter_callbacks( STBIR_RESIZE * resize, stbir__kernel_callback * horizontal_filter, stbir__support_callback * horizontal_support, stbir__kernel_callback * vertical_filter, stbir__support_callback * vertical_support ) +{ + resize->horizontal_filter_kernel = horizontal_filter; resize->horizontal_filter_support = horizontal_support; + resize->vertical_filter_kernel = vertical_filter; resize->vertical_filter_support = vertical_support; + resize->needs_rebuild = 1; + return 1; +} + +STBIRDEF int stbir_set_pixel_layouts( STBIR_RESIZE * resize, stbir_pixel_layout input_pixel_layout, stbir_pixel_layout output_pixel_layout ) // sets new pixel layouts +{ + resize->input_pixel_layout_public = input_pixel_layout; + resize->output_pixel_layout_public = output_pixel_layout; + resize->needs_rebuild = 1; + return 1; +} + + +STBIRDEF int stbir_set_non_pm_alpha_speed_over_quality( STBIR_RESIZE * resize, int non_pma_alpha_speed_over_quality ) // sets alpha speed +{ + resize->fast_alpha = non_pma_alpha_speed_over_quality; + resize->needs_rebuild = 1; + return 1; +} + +STBIRDEF int stbir_set_input_subrect( STBIR_RESIZE * resize, double s0, double t0, double s1, double t1 ) // sets input region (full region by default) +{ + resize->input_s0 = s0; + resize->input_t0 = t0; + resize->input_s1 = s1; + resize->input_t1 = t1; + resize->needs_rebuild = 1; + + // are we inbounds? + if ( ( s1 < stbir__small_float ) || ( (s1-s0) < stbir__small_float ) || + ( t1 < stbir__small_float ) || ( (t1-t0) < stbir__small_float ) || + ( s0 > (1.0f-stbir__small_float) ) || + ( t0 > (1.0f-stbir__small_float) ) ) + return 0; + + return 1; +} + +STBIRDEF int stbir_set_output_pixel_subrect( STBIR_RESIZE * resize, int subx, int suby, int subw, int subh ) // sets input region (full region by default) +{ + resize->output_subx = subx; + resize->output_suby = suby; + resize->output_subw = subw; + resize->output_subh = subh; + resize->needs_rebuild = 1; + + // are we inbounds? + if ( ( subx >= resize->output_w ) || ( ( subx + subw ) <= 0 ) || ( suby >= resize->output_h ) || ( ( suby + subh ) <= 0 ) || ( subw == 0 ) || ( subh == 0 ) ) + return 0; + + return 1; +} + +STBIRDEF int stbir_set_pixel_subrect( STBIR_RESIZE * resize, int subx, int suby, int subw, int subh ) // sets both regions (full regions by default) +{ + double s0, t0, s1, t1; + + s0 = ( (double)subx ) / ( (double)resize->output_w ); + t0 = ( (double)suby ) / ( (double)resize->output_h ); + s1 = ( (double)(subx+subw) ) / ( (double)resize->output_w ); + t1 = ( (double)(suby+subh) ) / ( (double)resize->output_h ); + + resize->input_s0 = s0; + resize->input_t0 = t0; + resize->input_s1 = s1; + resize->input_t1 = t1; + resize->output_subx = subx; + resize->output_suby = suby; + resize->output_subw = subw; + resize->output_subh = subh; + resize->needs_rebuild = 1; + + // are we inbounds? + if ( ( subx >= resize->output_w ) || ( ( subx + subw ) <= 0 ) || ( suby >= resize->output_h ) || ( ( suby + subh ) <= 0 ) || ( subw == 0 ) || ( subh == 0 ) ) + return 0; + + return 1; +} + +static int stbir__perform_build( STBIR_RESIZE * resize, int splits ) +{ + stbir__contributors conservative = { 0, 0 }; + stbir__sampler horizontal, vertical; + int new_output_subx, new_output_suby; + stbir__info * out_info; + #ifdef STBIR_PROFILE + stbir__info profile_infod; // used to contain building profile info before everything is allocated + stbir__info * profile_info = &profile_infod; + #endif + + // have we already built the samplers? + if ( resize->samplers ) + return 0; + + #define STBIR_RETURN_ERROR_AND_ASSERT( exp ) STBIR_ASSERT( !(exp) ); if (exp) return 0; + STBIR_RETURN_ERROR_AND_ASSERT( (unsigned)resize->horizontal_filter >= STBIR_FILTER_OTHER) + STBIR_RETURN_ERROR_AND_ASSERT( (unsigned)resize->vertical_filter >= STBIR_FILTER_OTHER) + #undef STBIR_RETURN_ERROR_AND_ASSERT + + if ( splits <= 0 ) + return 0; + + STBIR_PROFILE_BUILD_FIRST_START( build ); + + new_output_subx = resize->output_subx; + new_output_suby = resize->output_suby; + + // do horizontal clip and scale calcs + if ( !stbir__calculate_region_transform( &horizontal.scale_info, resize->output_w, &new_output_subx, resize->output_subw, resize->input_w, resize->input_s0, resize->input_s1 ) ) + return 0; + + // do vertical clip and scale calcs + if ( !stbir__calculate_region_transform( &vertical.scale_info, resize->output_h, &new_output_suby, resize->output_subh, resize->input_h, resize->input_t0, resize->input_t1 ) ) + return 0; + + // if nothing to do, just return + if ( ( horizontal.scale_info.output_sub_size == 0 ) || ( vertical.scale_info.output_sub_size == 0 ) ) + return 0; + + stbir__set_sampler(&horizontal, resize->horizontal_filter, resize->horizontal_filter_kernel, resize->horizontal_filter_support, resize->horizontal_edge, &horizontal.scale_info, 1, resize->user_data ); + stbir__get_conservative_extents( &horizontal, &conservative, resize->user_data ); + stbir__set_sampler(&vertical, resize->vertical_filter, resize->vertical_filter_kernel, resize->vertical_filter_support, resize->vertical_edge, &vertical.scale_info, 0, resize->user_data ); + + if ( ( vertical.scale_info.output_sub_size / splits ) < STBIR_FORCE_MINIMUM_SCANLINES_FOR_SPLITS ) // each split should be a minimum of 4 scanlines (handwavey choice) + { + splits = vertical.scale_info.output_sub_size / STBIR_FORCE_MINIMUM_SCANLINES_FOR_SPLITS; + if ( splits == 0 ) splits = 1; + } + + STBIR_PROFILE_BUILD_START( alloc ); + out_info = stbir__alloc_internal_mem_and_build_samplers( &horizontal, &vertical, &conservative, resize->input_pixel_layout_public, resize->output_pixel_layout_public, splits, new_output_subx, new_output_suby, resize->fast_alpha, resize->user_data STBIR_ONLY_PROFILE_BUILD_SET_INFO ); + STBIR_PROFILE_BUILD_END( alloc ); + STBIR_PROFILE_BUILD_END( build ); + + if ( out_info ) + { + resize->splits = splits; + resize->samplers = out_info; + resize->needs_rebuild = 0; + #ifdef STBIR_PROFILE + STBIR_MEMCPY( &out_info->profile, &profile_infod.profile, sizeof( out_info->profile ) ); + #endif + + // update anything that can be changed without recalcing samplers + stbir__update_info_from_resize( out_info, resize ); + + return splits; + } + + return 0; +} + +STBIRDEF void stbir_free_samplers( STBIR_RESIZE * resize ) +{ + if ( resize->samplers ) + { + stbir__free_internal_mem( resize->samplers ); + resize->samplers = 0; + resize->called_alloc = 0; + } +} + +STBIRDEF int stbir_build_samplers_with_splits( STBIR_RESIZE * resize, int splits ) +{ + if ( ( resize->samplers == 0 ) || ( resize->needs_rebuild ) ) + { + if ( resize->samplers ) + stbir_free_samplers( resize ); + + resize->called_alloc = 1; + return stbir__perform_build( resize, splits ); + } + + STBIR_PROFILE_BUILD_CLEAR( resize->samplers ); + + return 1; +} + +STBIRDEF int stbir_build_samplers( STBIR_RESIZE * resize ) +{ + return stbir_build_samplers_with_splits( resize, 1 ); +} + +STBIRDEF int stbir_resize_extended( STBIR_RESIZE * resize ) +{ + int result; + + if ( ( resize->samplers == 0 ) || ( resize->needs_rebuild ) ) + { + int alloc_state = resize->called_alloc; // remember allocated state + + if ( resize->samplers ) + { + stbir__free_internal_mem( resize->samplers ); + resize->samplers = 0; + } + + if ( !stbir_build_samplers( resize ) ) + return 0; + + resize->called_alloc = alloc_state; + + // if build_samplers succeeded (above), but there are no samplers set, then + // the area to stretch into was zero pixels, so don't do anything and return + // success + if ( resize->samplers == 0 ) + return 1; + } + else + { + // didn't build anything - clear it + STBIR_PROFILE_BUILD_CLEAR( resize->samplers ); + } + + // do resize + result = stbir__perform_resize( resize->samplers, 0, resize->splits ); + + // if we alloced, then free + if ( !resize->called_alloc ) + { + stbir_free_samplers( resize ); + resize->samplers = 0; + } + + return result; +} + +STBIRDEF int stbir_resize_extended_split( STBIR_RESIZE * resize, int split_start, int split_count ) +{ + STBIR_ASSERT( resize->samplers ); + + // if we're just doing the whole thing, call full + if ( ( split_start == -1 ) || ( ( split_start == 0 ) && ( split_count == resize->splits ) ) ) + return stbir_resize_extended( resize ); + + // you **must** build samplers first when using split resize + if ( ( resize->samplers == 0 ) || ( resize->needs_rebuild ) ) + return 0; + + if ( ( split_start >= resize->splits ) || ( split_start < 0 ) || ( ( split_start + split_count ) > resize->splits ) || ( split_count <= 0 ) ) + return 0; + + // do resize + return stbir__perform_resize( resize->samplers, split_start, split_count ); +} + + +static void * stbir_quick_resize_helper( const void *input_pixels , int input_w , int input_h, int input_stride_in_bytes, + void *output_pixels, int output_w, int output_h, int output_stride_in_bytes, + stbir_pixel_layout pixel_layout, stbir_datatype data_type, stbir_edge edge, stbir_filter filter ) +{ + STBIR_RESIZE resize; + int scanline_output_in_bytes; + int positive_output_stride_in_bytes; + void * start_ptr; + void * free_ptr; + + scanline_output_in_bytes = output_w * stbir__type_size[ data_type ] * stbir__pixel_channels[ stbir__pixel_layout_convert_public_to_internal[ pixel_layout ] ]; + if ( scanline_output_in_bytes == 0 ) + return 0; + + // if zero stride, use scanline output + if ( output_stride_in_bytes == 0 ) + output_stride_in_bytes = scanline_output_in_bytes; + + // abs value for inverted images (negative pitches) + positive_output_stride_in_bytes = output_stride_in_bytes; + if ( positive_output_stride_in_bytes < 0 ) + positive_output_stride_in_bytes = -positive_output_stride_in_bytes; + + // is the requested stride smaller than the scanline output? if so, just fail + if ( positive_output_stride_in_bytes < scanline_output_in_bytes ) + return 0; + + start_ptr = output_pixels; + free_ptr = 0; // no free pointer, since they passed buffer to use + + // did they pass a zero for the dest? if so, allocate the buffer + if ( output_pixels == 0 ) + { + size_t size; + char * ptr; + + size = (size_t)positive_output_stride_in_bytes * (size_t)output_h; + if ( size == 0 ) + return 0; + + ptr = (char*) STBIR_MALLOC( size, 0 ); + if ( ptr == 0 ) + return 0; + + free_ptr = ptr; + + // point at the last scanline, if they requested a flipped image + if ( output_stride_in_bytes < 0 ) + start_ptr = ptr + ( (size_t)positive_output_stride_in_bytes * (size_t)( output_h - 1 ) ); + else + start_ptr = ptr; + } + + // ok, now do the resize + stbir_resize_init( &resize, + input_pixels, input_w, input_h, input_stride_in_bytes, + start_ptr, output_w, output_h, output_stride_in_bytes, + pixel_layout, data_type ); + + resize.horizontal_edge = edge; + resize.vertical_edge = edge; + resize.horizontal_filter = filter; + resize.vertical_filter = filter; + + if ( !stbir_resize_extended( &resize ) ) + { + if ( free_ptr ) + STBIR_FREE( free_ptr, 0 ); + return 0; + } + + return (free_ptr) ? free_ptr : start_ptr; +} + + + +STBIRDEF unsigned char * stbir_resize_uint8_linear( const unsigned char *input_pixels , int input_w , int input_h, int input_stride_in_bytes, + unsigned char *output_pixels, int output_w, int output_h, int output_stride_in_bytes, + stbir_pixel_layout pixel_layout ) +{ + return (unsigned char *) stbir_quick_resize_helper( input_pixels , input_w , input_h, input_stride_in_bytes, + output_pixels, output_w, output_h, output_stride_in_bytes, + pixel_layout, STBIR_TYPE_UINT8, STBIR_EDGE_CLAMP, STBIR_FILTER_DEFAULT ); +} + +STBIRDEF unsigned char * stbir_resize_uint8_srgb( const unsigned char *input_pixels , int input_w , int input_h, int input_stride_in_bytes, + unsigned char *output_pixels, int output_w, int output_h, int output_stride_in_bytes, + stbir_pixel_layout pixel_layout ) +{ + return (unsigned char *) stbir_quick_resize_helper( input_pixels , input_w , input_h, input_stride_in_bytes, + output_pixels, output_w, output_h, output_stride_in_bytes, + pixel_layout, STBIR_TYPE_UINT8_SRGB, STBIR_EDGE_CLAMP, STBIR_FILTER_DEFAULT ); +} + + +STBIRDEF float * stbir_resize_float_linear( const float *input_pixels , int input_w , int input_h, int input_stride_in_bytes, + float *output_pixels, int output_w, int output_h, int output_stride_in_bytes, + stbir_pixel_layout pixel_layout ) +{ + return (float *) stbir_quick_resize_helper( input_pixels , input_w , input_h, input_stride_in_bytes, + output_pixels, output_w, output_h, output_stride_in_bytes, + pixel_layout, STBIR_TYPE_FLOAT, STBIR_EDGE_CLAMP, STBIR_FILTER_DEFAULT ); +} + + +STBIRDEF void * stbir_resize( const void *input_pixels , int input_w , int input_h, int input_stride_in_bytes, + void *output_pixels, int output_w, int output_h, int output_stride_in_bytes, + stbir_pixel_layout pixel_layout, stbir_datatype data_type, + stbir_edge edge, stbir_filter filter ) +{ + return (void *) stbir_quick_resize_helper( input_pixels , input_w , input_h, input_stride_in_bytes, + output_pixels, output_w, output_h, output_stride_in_bytes, + pixel_layout, data_type, edge, filter ); +} + +#ifdef STBIR_PROFILE + +STBIRDEF void stbir_resize_build_profile_info( STBIR_PROFILE_INFO * info, STBIR_RESIZE const * resize ) +{ + static char const * bdescriptions[6] = { "Building", "Allocating", "Horizontal sampler", "Vertical sampler", "Coefficient cleanup", "Coefficient pivot" } ; + stbir__info* samp = resize->samplers; + int i; + + typedef int testa[ (STBIR__ARRAY_SIZE( bdescriptions ) == (STBIR__ARRAY_SIZE( samp->profile.array )-1) )?1:-1]; + typedef int testb[ (sizeof( samp->profile.array ) == (sizeof(samp->profile.named)) )?1:-1]; + typedef int testc[ (sizeof( info->clocks ) >= (sizeof(samp->profile.named)) )?1:-1]; + + for( i = 0 ; i < STBIR__ARRAY_SIZE( bdescriptions ) ; i++) + info->clocks[i] = samp->profile.array[i+1]; + + info->total_clocks = samp->profile.named.total; + info->descriptions = bdescriptions; + info->count = STBIR__ARRAY_SIZE( bdescriptions ); +} + +STBIRDEF void stbir_resize_split_profile_info( STBIR_PROFILE_INFO * info, STBIR_RESIZE const * resize, int split_start, int split_count ) +{ + static char const * descriptions[7] = { "Looping", "Vertical sampling", "Horizontal sampling", "Scanline input", "Scanline output", "Alpha weighting", "Alpha unweighting" }; + stbir__per_split_info * split_info; + int s, i; + + typedef int testa[ (STBIR__ARRAY_SIZE( descriptions ) == (STBIR__ARRAY_SIZE( split_info->profile.array )-1) )?1:-1]; + typedef int testb[ (sizeof( split_info->profile.array ) == (sizeof(split_info->profile.named)) )?1:-1]; + typedef int testc[ (sizeof( info->clocks ) >= (sizeof(split_info->profile.named)) )?1:-1]; + + if ( split_start == -1 ) + { + split_start = 0; + split_count = resize->samplers->splits; + } + + if ( ( split_start >= resize->splits ) || ( split_start < 0 ) || ( ( split_start + split_count ) > resize->splits ) || ( split_count <= 0 ) ) + { + info->total_clocks = 0; + info->descriptions = 0; + info->count = 0; + return; + } + + split_info = resize->samplers->split_info + split_start; + + // sum up the profile from all the splits + for( i = 0 ; i < STBIR__ARRAY_SIZE( descriptions ) ; i++ ) + { + stbir_uint64 sum = 0; + for( s = 0 ; s < split_count ; s++ ) + sum += split_info[s].profile.array[i+1]; + info->clocks[i] = sum; + } + + info->total_clocks = split_info->profile.named.total; + info->descriptions = descriptions; + info->count = STBIR__ARRAY_SIZE( descriptions ); +} + +STBIRDEF void stbir_resize_extended_profile_info( STBIR_PROFILE_INFO * info, STBIR_RESIZE const * resize ) +{ + stbir_resize_split_profile_info( info, resize, -1, 0 ); +} + +#endif // STBIR_PROFILE + +#undef STBIR_BGR +#undef STBIR_1CHANNEL +#undef STBIR_2CHANNEL +#undef STBIR_RGB +#undef STBIR_RGBA +#undef STBIR_4CHANNEL +#undef STBIR_BGRA +#undef STBIR_ARGB +#undef STBIR_ABGR +#undef STBIR_RA +#undef STBIR_AR +#undef STBIR_RGBA_PM +#undef STBIR_BGRA_PM +#undef STBIR_ARGB_PM +#undef STBIR_ABGR_PM +#undef STBIR_RA_PM +#undef STBIR_AR_PM + +#endif // STB_IMAGE_RESIZE_IMPLEMENTATION + +#else // STB_IMAGE_RESIZE_HORIZONTALS&STB_IMAGE_RESIZE_DO_VERTICALS + +// we reinclude the header file to define all the horizontal functions +// specializing each function for the number of coeffs is 20-40% faster *OVERALL* + +// by including the header file again this way, we can still debug the functions + +#define STBIR_strs_join2( start, mid, end ) start##mid##end +#define STBIR_strs_join1( start, mid, end ) STBIR_strs_join2( start, mid, end ) + +#define STBIR_strs_join24( start, mid1, mid2, end ) start##mid1##mid2##end +#define STBIR_strs_join14( start, mid1, mid2, end ) STBIR_strs_join24( start, mid1, mid2, end ) + +#ifdef STB_IMAGE_RESIZE_DO_CODERS + +#ifdef stbir__decode_suffix +#define STBIR__CODER_NAME( name ) STBIR_strs_join1( name, _, stbir__decode_suffix ) +#else +#define STBIR__CODER_NAME( name ) name +#endif + +#ifdef stbir__decode_swizzle +#define stbir__decode_simdf8_flip(reg) STBIR_strs_join1( STBIR_strs_join1( STBIR_strs_join1( STBIR_strs_join1( stbir__simdf8_0123to,stbir__decode_order0,stbir__decode_order1),stbir__decode_order2,stbir__decode_order3),stbir__decode_order0,stbir__decode_order1),stbir__decode_order2,stbir__decode_order3)(reg, reg) +#define stbir__decode_simdf4_flip(reg) STBIR_strs_join1( STBIR_strs_join1( stbir__simdf_0123to,stbir__decode_order0,stbir__decode_order1),stbir__decode_order2,stbir__decode_order3)(reg, reg) +#define stbir__encode_simdf8_unflip(reg) STBIR_strs_join1( STBIR_strs_join1( STBIR_strs_join1( STBIR_strs_join1( stbir__simdf8_0123to,stbir__encode_order0,stbir__encode_order1),stbir__encode_order2,stbir__encode_order3),stbir__encode_order0,stbir__encode_order1),stbir__encode_order2,stbir__encode_order3)(reg, reg) +#define stbir__encode_simdf4_unflip(reg) STBIR_strs_join1( STBIR_strs_join1( stbir__simdf_0123to,stbir__encode_order0,stbir__encode_order1),stbir__encode_order2,stbir__encode_order3)(reg, reg) +#else +#define stbir__decode_order0 0 +#define stbir__decode_order1 1 +#define stbir__decode_order2 2 +#define stbir__decode_order3 3 +#define stbir__encode_order0 0 +#define stbir__encode_order1 1 +#define stbir__encode_order2 2 +#define stbir__encode_order3 3 +#define stbir__decode_simdf8_flip(reg) +#define stbir__decode_simdf4_flip(reg) +#define stbir__encode_simdf8_unflip(reg) +#define stbir__encode_simdf4_unflip(reg) +#endif + +#ifdef STBIR_SIMD8 +#define stbir__encode_simdfX_unflip stbir__encode_simdf8_unflip +#else +#define stbir__encode_simdfX_unflip stbir__encode_simdf4_unflip +#endif + +static float * STBIR__CODER_NAME( stbir__decode_uint8_linear_scaled )( float * decodep, int width_times_channels, void const * inputp ) +{ + float STBIR_STREAMOUT_PTR( * ) decode = decodep; + float * decode_end = (float*) decode + width_times_channels; + unsigned char const * input = (unsigned char const*)inputp; + + #ifdef STBIR_SIMD + unsigned char const * end_input_m16 = input + width_times_channels - 16; + if ( width_times_channels >= 16 ) + { + decode_end -= 16; + STBIR_NO_UNROLL_LOOP_START_INF_FOR + for(;;) + { + #ifdef STBIR_SIMD8 + stbir__simdi i; stbir__simdi8 o0,o1; + stbir__simdf8 of0, of1; + STBIR_NO_UNROLL(decode); + stbir__simdi_load( i, input ); + stbir__simdi8_expand_u8_to_u32( o0, o1, i ); + stbir__simdi8_convert_i32_to_float( of0, o0 ); + stbir__simdi8_convert_i32_to_float( of1, o1 ); + stbir__simdf8_mult( of0, of0, STBIR_max_uint8_as_float_inverted8); + stbir__simdf8_mult( of1, of1, STBIR_max_uint8_as_float_inverted8); + stbir__decode_simdf8_flip( of0 ); + stbir__decode_simdf8_flip( of1 ); + stbir__simdf8_store( decode + 0, of0 ); + stbir__simdf8_store( decode + 8, of1 ); + #else + stbir__simdi i, o0, o1, o2, o3; + stbir__simdf of0, of1, of2, of3; + STBIR_NO_UNROLL(decode); + stbir__simdi_load( i, input ); + stbir__simdi_expand_u8_to_u32( o0,o1,o2,o3,i); + stbir__simdi_convert_i32_to_float( of0, o0 ); + stbir__simdi_convert_i32_to_float( of1, o1 ); + stbir__simdi_convert_i32_to_float( of2, o2 ); + stbir__simdi_convert_i32_to_float( of3, o3 ); + stbir__simdf_mult( of0, of0, STBIR__CONSTF(STBIR_max_uint8_as_float_inverted) ); + stbir__simdf_mult( of1, of1, STBIR__CONSTF(STBIR_max_uint8_as_float_inverted) ); + stbir__simdf_mult( of2, of2, STBIR__CONSTF(STBIR_max_uint8_as_float_inverted) ); + stbir__simdf_mult( of3, of3, STBIR__CONSTF(STBIR_max_uint8_as_float_inverted) ); + stbir__decode_simdf4_flip( of0 ); + stbir__decode_simdf4_flip( of1 ); + stbir__decode_simdf4_flip( of2 ); + stbir__decode_simdf4_flip( of3 ); + stbir__simdf_store( decode + 0, of0 ); + stbir__simdf_store( decode + 4, of1 ); + stbir__simdf_store( decode + 8, of2 ); + stbir__simdf_store( decode + 12, of3 ); + #endif + decode += 16; + input += 16; + if ( decode <= decode_end ) + continue; + if ( decode == ( decode_end + 16 ) ) + break; + decode = decode_end; // backup and do last couple + input = end_input_m16; + } + return decode_end + 16; + } + #endif + + // try to do blocks of 4 when you can + #if stbir__coder_min_num != 3 // doesn't divide cleanly by four + decode += 4; + STBIR_SIMD_NO_UNROLL_LOOP_START + while( decode <= decode_end ) + { + STBIR_SIMD_NO_UNROLL(decode); + decode[0-4] = ((float)(input[stbir__decode_order0])) * stbir__max_uint8_as_float_inverted; + decode[1-4] = ((float)(input[stbir__decode_order1])) * stbir__max_uint8_as_float_inverted; + decode[2-4] = ((float)(input[stbir__decode_order2])) * stbir__max_uint8_as_float_inverted; + decode[3-4] = ((float)(input[stbir__decode_order3])) * stbir__max_uint8_as_float_inverted; + decode += 4; + input += 4; + } + decode -= 4; + #endif + + // do the remnants + #if stbir__coder_min_num < 4 + STBIR_NO_UNROLL_LOOP_START + while( decode < decode_end ) + { + STBIR_NO_UNROLL(decode); + decode[0] = ((float)(input[stbir__decode_order0])) * stbir__max_uint8_as_float_inverted; + #if stbir__coder_min_num >= 2 + decode[1] = ((float)(input[stbir__decode_order1])) * stbir__max_uint8_as_float_inverted; + #endif + #if stbir__coder_min_num >= 3 + decode[2] = ((float)(input[stbir__decode_order2])) * stbir__max_uint8_as_float_inverted; + #endif + decode += stbir__coder_min_num; + input += stbir__coder_min_num; + } + #endif + + return decode_end; +} + +static void STBIR__CODER_NAME( stbir__encode_uint8_linear_scaled )( void * outputp, int width_times_channels, float const * encode ) +{ + unsigned char STBIR_SIMD_STREAMOUT_PTR( * ) output = (unsigned char *) outputp; + unsigned char * end_output = ( (unsigned char *) output ) + width_times_channels; + + #ifdef STBIR_SIMD + if ( width_times_channels >= stbir__simdfX_float_count*2 ) + { + float const * end_encode_m8 = encode + width_times_channels - stbir__simdfX_float_count*2; + end_output -= stbir__simdfX_float_count*2; + STBIR_NO_UNROLL_LOOP_START_INF_FOR + for(;;) + { + stbir__simdfX e0, e1; + stbir__simdi i; + STBIR_SIMD_NO_UNROLL(encode); + stbir__simdfX_madd_mem( e0, STBIR_simd_point5X, STBIR_max_uint8_as_floatX, encode ); + stbir__simdfX_madd_mem( e1, STBIR_simd_point5X, STBIR_max_uint8_as_floatX, encode+stbir__simdfX_float_count ); + stbir__encode_simdfX_unflip( e0 ); + stbir__encode_simdfX_unflip( e1 ); + #ifdef STBIR_SIMD8 + stbir__simdf8_pack_to_16bytes( i, e0, e1 ); + stbir__simdi_store( output, i ); + #else + stbir__simdf_pack_to_8bytes( i, e0, e1 ); + stbir__simdi_store2( output, i ); + #endif + encode += stbir__simdfX_float_count*2; + output += stbir__simdfX_float_count*2; + if ( output <= end_output ) + continue; + if ( output == ( end_output + stbir__simdfX_float_count*2 ) ) + break; + output = end_output; // backup and do last couple + encode = end_encode_m8; + } + return; + } + + // try to do blocks of 4 when you can + #if stbir__coder_min_num != 3 // doesn't divide cleanly by four + output += 4; + STBIR_NO_UNROLL_LOOP_START + while( output <= end_output ) + { + stbir__simdf e0; + stbir__simdi i0; + STBIR_NO_UNROLL(encode); + stbir__simdf_load( e0, encode ); + stbir__simdf_madd( e0, STBIR__CONSTF(STBIR_simd_point5), STBIR__CONSTF(STBIR_max_uint8_as_float), e0 ); + stbir__encode_simdf4_unflip( e0 ); + stbir__simdf_pack_to_8bytes( i0, e0, e0 ); // only use first 4 + *(int*)(output-4) = stbir__simdi_to_int( i0 ); + output += 4; + encode += 4; + } + output -= 4; + #endif + + // do the remnants + #if stbir__coder_min_num < 4 + STBIR_NO_UNROLL_LOOP_START + while( output < end_output ) + { + stbir__simdf e0; + STBIR_NO_UNROLL(encode); + stbir__simdf_madd1_mem( e0, STBIR__CONSTF(STBIR_simd_point5), STBIR__CONSTF(STBIR_max_uint8_as_float), encode+stbir__encode_order0 ); output[0] = stbir__simdf_convert_float_to_uint8( e0 ); + #if stbir__coder_min_num >= 2 + stbir__simdf_madd1_mem( e0, STBIR__CONSTF(STBIR_simd_point5), STBIR__CONSTF(STBIR_max_uint8_as_float), encode+stbir__encode_order1 ); output[1] = stbir__simdf_convert_float_to_uint8( e0 ); + #endif + #if stbir__coder_min_num >= 3 + stbir__simdf_madd1_mem( e0, STBIR__CONSTF(STBIR_simd_point5), STBIR__CONSTF(STBIR_max_uint8_as_float), encode+stbir__encode_order2 ); output[2] = stbir__simdf_convert_float_to_uint8( e0 ); + #endif + output += stbir__coder_min_num; + encode += stbir__coder_min_num; + } + #endif + + #else + + // try to do blocks of 4 when you can + #if stbir__coder_min_num != 3 // doesn't divide cleanly by four + output += 4; + while( output <= end_output ) + { + float f; + f = encode[stbir__encode_order0] * stbir__max_uint8_as_float + 0.5f; STBIR_CLAMP(f, 0, 255); output[0-4] = (unsigned char)f; + f = encode[stbir__encode_order1] * stbir__max_uint8_as_float + 0.5f; STBIR_CLAMP(f, 0, 255); output[1-4] = (unsigned char)f; + f = encode[stbir__encode_order2] * stbir__max_uint8_as_float + 0.5f; STBIR_CLAMP(f, 0, 255); output[2-4] = (unsigned char)f; + f = encode[stbir__encode_order3] * stbir__max_uint8_as_float + 0.5f; STBIR_CLAMP(f, 0, 255); output[3-4] = (unsigned char)f; + output += 4; + encode += 4; + } + output -= 4; + #endif + + // do the remnants + #if stbir__coder_min_num < 4 + STBIR_NO_UNROLL_LOOP_START + while( output < end_output ) + { + float f; + STBIR_NO_UNROLL(encode); + f = encode[stbir__encode_order0] * stbir__max_uint8_as_float + 0.5f; STBIR_CLAMP(f, 0, 255); output[0] = (unsigned char)f; + #if stbir__coder_min_num >= 2 + f = encode[stbir__encode_order1] * stbir__max_uint8_as_float + 0.5f; STBIR_CLAMP(f, 0, 255); output[1] = (unsigned char)f; + #endif + #if stbir__coder_min_num >= 3 + f = encode[stbir__encode_order2] * stbir__max_uint8_as_float + 0.5f; STBIR_CLAMP(f, 0, 255); output[2] = (unsigned char)f; + #endif + output += stbir__coder_min_num; + encode += stbir__coder_min_num; + } + #endif + #endif +} + +static float * STBIR__CODER_NAME(stbir__decode_uint8_linear)( float * decodep, int width_times_channels, void const * inputp ) +{ + float STBIR_STREAMOUT_PTR( * ) decode = decodep; + float * decode_end = (float*) decode + width_times_channels; + unsigned char const * input = (unsigned char const*)inputp; + + #ifdef STBIR_SIMD + unsigned char const * end_input_m16 = input + width_times_channels - 16; + if ( width_times_channels >= 16 ) + { + decode_end -= 16; + STBIR_NO_UNROLL_LOOP_START_INF_FOR + for(;;) + { + #ifdef STBIR_SIMD8 + stbir__simdi i; stbir__simdi8 o0,o1; + stbir__simdf8 of0, of1; + STBIR_NO_UNROLL(decode); + stbir__simdi_load( i, input ); + stbir__simdi8_expand_u8_to_u32( o0, o1, i ); + stbir__simdi8_convert_i32_to_float( of0, o0 ); + stbir__simdi8_convert_i32_to_float( of1, o1 ); + stbir__decode_simdf8_flip( of0 ); + stbir__decode_simdf8_flip( of1 ); + stbir__simdf8_store( decode + 0, of0 ); + stbir__simdf8_store( decode + 8, of1 ); + #else + stbir__simdi i, o0, o1, o2, o3; + stbir__simdf of0, of1, of2, of3; + STBIR_NO_UNROLL(decode); + stbir__simdi_load( i, input ); + stbir__simdi_expand_u8_to_u32( o0,o1,o2,o3,i); + stbir__simdi_convert_i32_to_float( of0, o0 ); + stbir__simdi_convert_i32_to_float( of1, o1 ); + stbir__simdi_convert_i32_to_float( of2, o2 ); + stbir__simdi_convert_i32_to_float( of3, o3 ); + stbir__decode_simdf4_flip( of0 ); + stbir__decode_simdf4_flip( of1 ); + stbir__decode_simdf4_flip( of2 ); + stbir__decode_simdf4_flip( of3 ); + stbir__simdf_store( decode + 0, of0 ); + stbir__simdf_store( decode + 4, of1 ); + stbir__simdf_store( decode + 8, of2 ); + stbir__simdf_store( decode + 12, of3 ); +#endif + decode += 16; + input += 16; + if ( decode <= decode_end ) + continue; + if ( decode == ( decode_end + 16 ) ) + break; + decode = decode_end; // backup and do last couple + input = end_input_m16; + } + return decode_end + 16; + } + #endif + + // try to do blocks of 4 when you can + #if stbir__coder_min_num != 3 // doesn't divide cleanly by four + decode += 4; + STBIR_SIMD_NO_UNROLL_LOOP_START + while( decode <= decode_end ) + { + STBIR_SIMD_NO_UNROLL(decode); + decode[0-4] = ((float)(input[stbir__decode_order0])); + decode[1-4] = ((float)(input[stbir__decode_order1])); + decode[2-4] = ((float)(input[stbir__decode_order2])); + decode[3-4] = ((float)(input[stbir__decode_order3])); + decode += 4; + input += 4; + } + decode -= 4; + #endif + + // do the remnants + #if stbir__coder_min_num < 4 + STBIR_NO_UNROLL_LOOP_START + while( decode < decode_end ) + { + STBIR_NO_UNROLL(decode); + decode[0] = ((float)(input[stbir__decode_order0])); + #if stbir__coder_min_num >= 2 + decode[1] = ((float)(input[stbir__decode_order1])); + #endif + #if stbir__coder_min_num >= 3 + decode[2] = ((float)(input[stbir__decode_order2])); + #endif + decode += stbir__coder_min_num; + input += stbir__coder_min_num; + } + #endif + return decode_end; +} + +static void STBIR__CODER_NAME( stbir__encode_uint8_linear )( void * outputp, int width_times_channels, float const * encode ) +{ + unsigned char STBIR_SIMD_STREAMOUT_PTR( * ) output = (unsigned char *) outputp; + unsigned char * end_output = ( (unsigned char *) output ) + width_times_channels; + + #ifdef STBIR_SIMD + if ( width_times_channels >= stbir__simdfX_float_count*2 ) + { + float const * end_encode_m8 = encode + width_times_channels - stbir__simdfX_float_count*2; + end_output -= stbir__simdfX_float_count*2; + STBIR_SIMD_NO_UNROLL_LOOP_START_INF_FOR + for(;;) + { + stbir__simdfX e0, e1; + stbir__simdi i; + STBIR_SIMD_NO_UNROLL(encode); + stbir__simdfX_add_mem( e0, STBIR_simd_point5X, encode ); + stbir__simdfX_add_mem( e1, STBIR_simd_point5X, encode+stbir__simdfX_float_count ); + stbir__encode_simdfX_unflip( e0 ); + stbir__encode_simdfX_unflip( e1 ); + #ifdef STBIR_SIMD8 + stbir__simdf8_pack_to_16bytes( i, e0, e1 ); + stbir__simdi_store( output, i ); + #else + stbir__simdf_pack_to_8bytes( i, e0, e1 ); + stbir__simdi_store2( output, i ); + #endif + encode += stbir__simdfX_float_count*2; + output += stbir__simdfX_float_count*2; + if ( output <= end_output ) + continue; + if ( output == ( end_output + stbir__simdfX_float_count*2 ) ) + break; + output = end_output; // backup and do last couple + encode = end_encode_m8; + } + return; + } + + // try to do blocks of 4 when you can + #if stbir__coder_min_num != 3 // doesn't divide cleanly by four + output += 4; + STBIR_NO_UNROLL_LOOP_START + while( output <= end_output ) + { + stbir__simdf e0; + stbir__simdi i0; + STBIR_NO_UNROLL(encode); + stbir__simdf_load( e0, encode ); + stbir__simdf_add( e0, STBIR__CONSTF(STBIR_simd_point5), e0 ); + stbir__encode_simdf4_unflip( e0 ); + stbir__simdf_pack_to_8bytes( i0, e0, e0 ); // only use first 4 + *(int*)(output-4) = stbir__simdi_to_int( i0 ); + output += 4; + encode += 4; + } + output -= 4; + #endif + + #else + + // try to do blocks of 4 when you can + #if stbir__coder_min_num != 3 // doesn't divide cleanly by four + output += 4; + while( output <= end_output ) + { + float f; + f = encode[stbir__encode_order0] + 0.5f; STBIR_CLAMP(f, 0, 255); output[0-4] = (unsigned char)f; + f = encode[stbir__encode_order1] + 0.5f; STBIR_CLAMP(f, 0, 255); output[1-4] = (unsigned char)f; + f = encode[stbir__encode_order2] + 0.5f; STBIR_CLAMP(f, 0, 255); output[2-4] = (unsigned char)f; + f = encode[stbir__encode_order3] + 0.5f; STBIR_CLAMP(f, 0, 255); output[3-4] = (unsigned char)f; + output += 4; + encode += 4; + } + output -= 4; + #endif + + #endif + + // do the remnants + #if stbir__coder_min_num < 4 + STBIR_NO_UNROLL_LOOP_START + while( output < end_output ) + { + float f; + STBIR_NO_UNROLL(encode); + f = encode[stbir__encode_order0] + 0.5f; STBIR_CLAMP(f, 0, 255); output[0] = (unsigned char)f; + #if stbir__coder_min_num >= 2 + f = encode[stbir__encode_order1] + 0.5f; STBIR_CLAMP(f, 0, 255); output[1] = (unsigned char)f; + #endif + #if stbir__coder_min_num >= 3 + f = encode[stbir__encode_order2] + 0.5f; STBIR_CLAMP(f, 0, 255); output[2] = (unsigned char)f; + #endif + output += stbir__coder_min_num; + encode += stbir__coder_min_num; + } + #endif +} + +static float * STBIR__CODER_NAME(stbir__decode_uint8_srgb)( float * decodep, int width_times_channels, void const * inputp ) +{ + float STBIR_STREAMOUT_PTR( * ) decode = decodep; + float * decode_end = (float*) decode + width_times_channels; + unsigned char const * input = (unsigned char const *)inputp; + + // try to do blocks of 4 when you can + #if stbir__coder_min_num != 3 // doesn't divide cleanly by four + decode += 4; + while( decode <= decode_end ) + { + decode[0-4] = stbir__srgb_uchar_to_linear_float[ input[ stbir__decode_order0 ] ]; + decode[1-4] = stbir__srgb_uchar_to_linear_float[ input[ stbir__decode_order1 ] ]; + decode[2-4] = stbir__srgb_uchar_to_linear_float[ input[ stbir__decode_order2 ] ]; + decode[3-4] = stbir__srgb_uchar_to_linear_float[ input[ stbir__decode_order3 ] ]; + decode += 4; + input += 4; + } + decode -= 4; + #endif + + // do the remnants + #if stbir__coder_min_num < 4 + STBIR_NO_UNROLL_LOOP_START + while( decode < decode_end ) + { + STBIR_NO_UNROLL(decode); + decode[0] = stbir__srgb_uchar_to_linear_float[ input[ stbir__decode_order0 ] ]; + #if stbir__coder_min_num >= 2 + decode[1] = stbir__srgb_uchar_to_linear_float[ input[ stbir__decode_order1 ] ]; + #endif + #if stbir__coder_min_num >= 3 + decode[2] = stbir__srgb_uchar_to_linear_float[ input[ stbir__decode_order2 ] ]; + #endif + decode += stbir__coder_min_num; + input += stbir__coder_min_num; + } + #endif + return decode_end; +} + +#define stbir__min_max_shift20( i, f ) \ + stbir__simdf_max( f, f, stbir_simdf_casti(STBIR__CONSTI( STBIR_almost_zero )) ); \ + stbir__simdf_min( f, f, stbir_simdf_casti(STBIR__CONSTI( STBIR_almost_one )) ); \ + stbir__simdi_32shr( i, stbir_simdi_castf( f ), 20 ); + +#define stbir__scale_and_convert( i, f ) \ + stbir__simdf_madd( f, STBIR__CONSTF( STBIR_simd_point5 ), STBIR__CONSTF( STBIR_max_uint8_as_float ), f ); \ + stbir__simdf_max( f, f, stbir__simdf_zeroP() ); \ + stbir__simdf_min( f, f, STBIR__CONSTF( STBIR_max_uint8_as_float ) ); \ + stbir__simdf_convert_float_to_i32( i, f ); + +#define stbir__linear_to_srgb_finish( i, f ) \ +{ \ + stbir__simdi temp; \ + stbir__simdi_32shr( temp, stbir_simdi_castf( f ), 12 ) ; \ + stbir__simdi_and( temp, temp, STBIR__CONSTI(STBIR_mantissa_mask) ); \ + stbir__simdi_or( temp, temp, STBIR__CONSTI(STBIR_topscale) ); \ + stbir__simdi_16madd( i, i, temp ); \ + stbir__simdi_32shr( i, i, 16 ); \ +} + +#define stbir__simdi_table_lookup2( v0,v1, table ) \ +{ \ + stbir__simdi_u32 temp0,temp1; \ + temp0.m128i_i128 = v0; \ + temp1.m128i_i128 = v1; \ + temp0.m128i_u32[0] = table[temp0.m128i_i32[0]]; temp0.m128i_u32[1] = table[temp0.m128i_i32[1]]; temp0.m128i_u32[2] = table[temp0.m128i_i32[2]]; temp0.m128i_u32[3] = table[temp0.m128i_i32[3]]; \ + temp1.m128i_u32[0] = table[temp1.m128i_i32[0]]; temp1.m128i_u32[1] = table[temp1.m128i_i32[1]]; temp1.m128i_u32[2] = table[temp1.m128i_i32[2]]; temp1.m128i_u32[3] = table[temp1.m128i_i32[3]]; \ + v0 = temp0.m128i_i128; \ + v1 = temp1.m128i_i128; \ +} + +#define stbir__simdi_table_lookup3( v0,v1,v2, table ) \ +{ \ + stbir__simdi_u32 temp0,temp1,temp2; \ + temp0.m128i_i128 = v0; \ + temp1.m128i_i128 = v1; \ + temp2.m128i_i128 = v2; \ + temp0.m128i_u32[0] = table[temp0.m128i_i32[0]]; temp0.m128i_u32[1] = table[temp0.m128i_i32[1]]; temp0.m128i_u32[2] = table[temp0.m128i_i32[2]]; temp0.m128i_u32[3] = table[temp0.m128i_i32[3]]; \ + temp1.m128i_u32[0] = table[temp1.m128i_i32[0]]; temp1.m128i_u32[1] = table[temp1.m128i_i32[1]]; temp1.m128i_u32[2] = table[temp1.m128i_i32[2]]; temp1.m128i_u32[3] = table[temp1.m128i_i32[3]]; \ + temp2.m128i_u32[0] = table[temp2.m128i_i32[0]]; temp2.m128i_u32[1] = table[temp2.m128i_i32[1]]; temp2.m128i_u32[2] = table[temp2.m128i_i32[2]]; temp2.m128i_u32[3] = table[temp2.m128i_i32[3]]; \ + v0 = temp0.m128i_i128; \ + v1 = temp1.m128i_i128; \ + v2 = temp2.m128i_i128; \ +} + +#define stbir__simdi_table_lookup4( v0,v1,v2,v3, table ) \ +{ \ + stbir__simdi_u32 temp0,temp1,temp2,temp3; \ + temp0.m128i_i128 = v0; \ + temp1.m128i_i128 = v1; \ + temp2.m128i_i128 = v2; \ + temp3.m128i_i128 = v3; \ + temp0.m128i_u32[0] = table[temp0.m128i_i32[0]]; temp0.m128i_u32[1] = table[temp0.m128i_i32[1]]; temp0.m128i_u32[2] = table[temp0.m128i_i32[2]]; temp0.m128i_u32[3] = table[temp0.m128i_i32[3]]; \ + temp1.m128i_u32[0] = table[temp1.m128i_i32[0]]; temp1.m128i_u32[1] = table[temp1.m128i_i32[1]]; temp1.m128i_u32[2] = table[temp1.m128i_i32[2]]; temp1.m128i_u32[3] = table[temp1.m128i_i32[3]]; \ + temp2.m128i_u32[0] = table[temp2.m128i_i32[0]]; temp2.m128i_u32[1] = table[temp2.m128i_i32[1]]; temp2.m128i_u32[2] = table[temp2.m128i_i32[2]]; temp2.m128i_u32[3] = table[temp2.m128i_i32[3]]; \ + temp3.m128i_u32[0] = table[temp3.m128i_i32[0]]; temp3.m128i_u32[1] = table[temp3.m128i_i32[1]]; temp3.m128i_u32[2] = table[temp3.m128i_i32[2]]; temp3.m128i_u32[3] = table[temp3.m128i_i32[3]]; \ + v0 = temp0.m128i_i128; \ + v1 = temp1.m128i_i128; \ + v2 = temp2.m128i_i128; \ + v3 = temp3.m128i_i128; \ +} + +static void STBIR__CODER_NAME( stbir__encode_uint8_srgb )( void * outputp, int width_times_channels, float const * encode ) +{ + unsigned char STBIR_SIMD_STREAMOUT_PTR( * ) output = (unsigned char*) outputp; + unsigned char * end_output = ( (unsigned char*) output ) + width_times_channels; + + #ifdef STBIR_SIMD + + if ( width_times_channels >= 16 ) + { + float const * end_encode_m16 = encode + width_times_channels - 16; + end_output -= 16; + STBIR_SIMD_NO_UNROLL_LOOP_START_INF_FOR + for(;;) + { + stbir__simdf f0, f1, f2, f3; + stbir__simdi i0, i1, i2, i3; + STBIR_SIMD_NO_UNROLL(encode); + + stbir__simdf_load4_transposed( f0, f1, f2, f3, encode ); + + stbir__min_max_shift20( i0, f0 ); + stbir__min_max_shift20( i1, f1 ); + stbir__min_max_shift20( i2, f2 ); + stbir__min_max_shift20( i3, f3 ); + + stbir__simdi_table_lookup4( i0, i1, i2, i3, ( fp32_to_srgb8_tab4 - (127-13)*8 ) ); + + stbir__linear_to_srgb_finish( i0, f0 ); + stbir__linear_to_srgb_finish( i1, f1 ); + stbir__linear_to_srgb_finish( i2, f2 ); + stbir__linear_to_srgb_finish( i3, f3 ); + + stbir__interleave_pack_and_store_16_u8( output, STBIR_strs_join1(i, ,stbir__encode_order0), STBIR_strs_join1(i, ,stbir__encode_order1), STBIR_strs_join1(i, ,stbir__encode_order2), STBIR_strs_join1(i, ,stbir__encode_order3) ); + + encode += 16; + output += 16; + if ( output <= end_output ) + continue; + if ( output == ( end_output + 16 ) ) + break; + output = end_output; // backup and do last couple + encode = end_encode_m16; + } + return; + } + #endif + + // try to do blocks of 4 when you can + #if stbir__coder_min_num != 3 // doesn't divide cleanly by four + output += 4; + STBIR_SIMD_NO_UNROLL_LOOP_START + while ( output <= end_output ) + { + STBIR_SIMD_NO_UNROLL(encode); + + output[0-4] = stbir__linear_to_srgb_uchar( encode[stbir__encode_order0] ); + output[1-4] = stbir__linear_to_srgb_uchar( encode[stbir__encode_order1] ); + output[2-4] = stbir__linear_to_srgb_uchar( encode[stbir__encode_order2] ); + output[3-4] = stbir__linear_to_srgb_uchar( encode[stbir__encode_order3] ); + + output += 4; + encode += 4; + } + output -= 4; + #endif + + // do the remnants + #if stbir__coder_min_num < 4 + STBIR_NO_UNROLL_LOOP_START + while( output < end_output ) + { + STBIR_NO_UNROLL(encode); + output[0] = stbir__linear_to_srgb_uchar( encode[stbir__encode_order0] ); + #if stbir__coder_min_num >= 2 + output[1] = stbir__linear_to_srgb_uchar( encode[stbir__encode_order1] ); + #endif + #if stbir__coder_min_num >= 3 + output[2] = stbir__linear_to_srgb_uchar( encode[stbir__encode_order2] ); + #endif + output += stbir__coder_min_num; + encode += stbir__coder_min_num; + } + #endif +} + +#if ( stbir__coder_min_num == 4 ) || ( ( stbir__coder_min_num == 1 ) && ( !defined(stbir__decode_swizzle) ) ) + +static float * STBIR__CODER_NAME(stbir__decode_uint8_srgb4_linearalpha)( float * decodep, int width_times_channels, void const * inputp ) +{ + float STBIR_STREAMOUT_PTR( * ) decode = decodep; + float * decode_end = (float*) decode + width_times_channels; + unsigned char const * input = (unsigned char const *)inputp; + + do { + decode[0] = stbir__srgb_uchar_to_linear_float[ input[stbir__decode_order0] ]; + decode[1] = stbir__srgb_uchar_to_linear_float[ input[stbir__decode_order1] ]; + decode[2] = stbir__srgb_uchar_to_linear_float[ input[stbir__decode_order2] ]; + decode[3] = ( (float) input[stbir__decode_order3] ) * stbir__max_uint8_as_float_inverted; + input += 4; + decode += 4; + } while( decode < decode_end ); + return decode_end; +} + + +static void STBIR__CODER_NAME( stbir__encode_uint8_srgb4_linearalpha )( void * outputp, int width_times_channels, float const * encode ) +{ + unsigned char STBIR_SIMD_STREAMOUT_PTR( * ) output = (unsigned char*) outputp; + unsigned char * end_output = ( (unsigned char*) output ) + width_times_channels; + + #ifdef STBIR_SIMD + + if ( width_times_channels >= 16 ) + { + float const * end_encode_m16 = encode + width_times_channels - 16; + end_output -= 16; + STBIR_SIMD_NO_UNROLL_LOOP_START_INF_FOR + for(;;) + { + stbir__simdf f0, f1, f2, f3; + stbir__simdi i0, i1, i2, i3; + + STBIR_SIMD_NO_UNROLL(encode); + stbir__simdf_load4_transposed( f0, f1, f2, f3, encode ); + + stbir__min_max_shift20( i0, f0 ); + stbir__min_max_shift20( i1, f1 ); + stbir__min_max_shift20( i2, f2 ); + stbir__scale_and_convert( i3, f3 ); + + stbir__simdi_table_lookup3( i0, i1, i2, ( fp32_to_srgb8_tab4 - (127-13)*8 ) ); + + stbir__linear_to_srgb_finish( i0, f0 ); + stbir__linear_to_srgb_finish( i1, f1 ); + stbir__linear_to_srgb_finish( i2, f2 ); + + stbir__interleave_pack_and_store_16_u8( output, STBIR_strs_join1(i, ,stbir__encode_order0), STBIR_strs_join1(i, ,stbir__encode_order1), STBIR_strs_join1(i, ,stbir__encode_order2), STBIR_strs_join1(i, ,stbir__encode_order3) ); + + output += 16; + encode += 16; + + if ( output <= end_output ) + continue; + if ( output == ( end_output + 16 ) ) + break; + output = end_output; // backup and do last couple + encode = end_encode_m16; + } + return; + } + #endif + + STBIR_SIMD_NO_UNROLL_LOOP_START + do { + float f; + STBIR_SIMD_NO_UNROLL(encode); + + output[stbir__decode_order0] = stbir__linear_to_srgb_uchar( encode[0] ); + output[stbir__decode_order1] = stbir__linear_to_srgb_uchar( encode[1] ); + output[stbir__decode_order2] = stbir__linear_to_srgb_uchar( encode[2] ); + + f = encode[3] * stbir__max_uint8_as_float + 0.5f; + STBIR_CLAMP(f, 0, 255); + output[stbir__decode_order3] = (unsigned char) f; + + output += 4; + encode += 4; + } while( output < end_output ); +} + +#endif + +#if ( stbir__coder_min_num == 2 ) || ( ( stbir__coder_min_num == 1 ) && ( !defined(stbir__decode_swizzle) ) ) + +static float * STBIR__CODER_NAME(stbir__decode_uint8_srgb2_linearalpha)( float * decodep, int width_times_channels, void const * inputp ) +{ + float STBIR_STREAMOUT_PTR( * ) decode = decodep; + float * decode_end = (float*) decode + width_times_channels; + unsigned char const * input = (unsigned char const *)inputp; + + decode += 4; + while( decode <= decode_end ) + { + decode[0-4] = stbir__srgb_uchar_to_linear_float[ input[stbir__decode_order0] ]; + decode[1-4] = ( (float) input[stbir__decode_order1] ) * stbir__max_uint8_as_float_inverted; + decode[2-4] = stbir__srgb_uchar_to_linear_float[ input[stbir__decode_order0+2] ]; + decode[3-4] = ( (float) input[stbir__decode_order1+2] ) * stbir__max_uint8_as_float_inverted; + input += 4; + decode += 4; + } + decode -= 4; + if( decode < decode_end ) + { + decode[0] = stbir__srgb_uchar_to_linear_float[ input[stbir__decode_order0] ]; + decode[1] = ( (float) input[stbir__decode_order1] ) * stbir__max_uint8_as_float_inverted; + } + return decode_end; +} + +static void STBIR__CODER_NAME( stbir__encode_uint8_srgb2_linearalpha )( void * outputp, int width_times_channels, float const * encode ) +{ + unsigned char STBIR_SIMD_STREAMOUT_PTR( * ) output = (unsigned char*) outputp; + unsigned char * end_output = ( (unsigned char*) output ) + width_times_channels; + + #ifdef STBIR_SIMD + + if ( width_times_channels >= 16 ) + { + float const * end_encode_m16 = encode + width_times_channels - 16; + end_output -= 16; + STBIR_SIMD_NO_UNROLL_LOOP_START_INF_FOR + for(;;) + { + stbir__simdf f0, f1, f2, f3; + stbir__simdi i0, i1, i2, i3; + + STBIR_SIMD_NO_UNROLL(encode); + stbir__simdf_load4_transposed( f0, f1, f2, f3, encode ); + + stbir__min_max_shift20( i0, f0 ); + stbir__scale_and_convert( i1, f1 ); + stbir__min_max_shift20( i2, f2 ); + stbir__scale_and_convert( i3, f3 ); + + stbir__simdi_table_lookup2( i0, i2, ( fp32_to_srgb8_tab4 - (127-13)*8 ) ); + + stbir__linear_to_srgb_finish( i0, f0 ); + stbir__linear_to_srgb_finish( i2, f2 ); + + stbir__interleave_pack_and_store_16_u8( output, STBIR_strs_join1(i, ,stbir__encode_order0), STBIR_strs_join1(i, ,stbir__encode_order1), STBIR_strs_join1(i, ,stbir__encode_order2), STBIR_strs_join1(i, ,stbir__encode_order3) ); + + output += 16; + encode += 16; + if ( output <= end_output ) + continue; + if ( output == ( end_output + 16 ) ) + break; + output = end_output; // backup and do last couple + encode = end_encode_m16; + } + return; + } + #endif + + STBIR_SIMD_NO_UNROLL_LOOP_START + do { + float f; + STBIR_SIMD_NO_UNROLL(encode); + + output[stbir__decode_order0] = stbir__linear_to_srgb_uchar( encode[0] ); + + f = encode[1] * stbir__max_uint8_as_float + 0.5f; + STBIR_CLAMP(f, 0, 255); + output[stbir__decode_order1] = (unsigned char) f; + + output += 2; + encode += 2; + } while( output < end_output ); +} + +#endif + +static float * STBIR__CODER_NAME(stbir__decode_uint16_linear_scaled)( float * decodep, int width_times_channels, void const * inputp ) +{ + float STBIR_STREAMOUT_PTR( * ) decode = decodep; + float * decode_end = (float*) decode + width_times_channels; + unsigned short const * input = (unsigned short const *)inputp; + + #ifdef STBIR_SIMD + unsigned short const * end_input_m8 = input + width_times_channels - 8; + if ( width_times_channels >= 8 ) + { + decode_end -= 8; + STBIR_NO_UNROLL_LOOP_START_INF_FOR + for(;;) + { + #ifdef STBIR_SIMD8 + stbir__simdi i; stbir__simdi8 o; + stbir__simdf8 of; + STBIR_NO_UNROLL(decode); + stbir__simdi_load( i, input ); + stbir__simdi8_expand_u16_to_u32( o, i ); + stbir__simdi8_convert_i32_to_float( of, o ); + stbir__simdf8_mult( of, of, STBIR_max_uint16_as_float_inverted8); + stbir__decode_simdf8_flip( of ); + stbir__simdf8_store( decode + 0, of ); + #else + stbir__simdi i, o0, o1; + stbir__simdf of0, of1; + STBIR_NO_UNROLL(decode); + stbir__simdi_load( i, input ); + stbir__simdi_expand_u16_to_u32( o0,o1,i ); + stbir__simdi_convert_i32_to_float( of0, o0 ); + stbir__simdi_convert_i32_to_float( of1, o1 ); + stbir__simdf_mult( of0, of0, STBIR__CONSTF(STBIR_max_uint16_as_float_inverted) ); + stbir__simdf_mult( of1, of1, STBIR__CONSTF(STBIR_max_uint16_as_float_inverted)); + stbir__decode_simdf4_flip( of0 ); + stbir__decode_simdf4_flip( of1 ); + stbir__simdf_store( decode + 0, of0 ); + stbir__simdf_store( decode + 4, of1 ); + #endif + decode += 8; + input += 8; + if ( decode <= decode_end ) + continue; + if ( decode == ( decode_end + 8 ) ) + break; + decode = decode_end; // backup and do last couple + input = end_input_m8; + } + return decode_end + 8; + } + #endif + + // try to do blocks of 4 when you can + #if stbir__coder_min_num != 3 // doesn't divide cleanly by four + decode += 4; + STBIR_SIMD_NO_UNROLL_LOOP_START + while( decode <= decode_end ) + { + STBIR_SIMD_NO_UNROLL(decode); + decode[0-4] = ((float)(input[stbir__decode_order0])) * stbir__max_uint16_as_float_inverted; + decode[1-4] = ((float)(input[stbir__decode_order1])) * stbir__max_uint16_as_float_inverted; + decode[2-4] = ((float)(input[stbir__decode_order2])) * stbir__max_uint16_as_float_inverted; + decode[3-4] = ((float)(input[stbir__decode_order3])) * stbir__max_uint16_as_float_inverted; + decode += 4; + input += 4; + } + decode -= 4; + #endif + + // do the remnants + #if stbir__coder_min_num < 4 + STBIR_NO_UNROLL_LOOP_START + while( decode < decode_end ) + { + STBIR_NO_UNROLL(decode); + decode[0] = ((float)(input[stbir__decode_order0])) * stbir__max_uint16_as_float_inverted; + #if stbir__coder_min_num >= 2 + decode[1] = ((float)(input[stbir__decode_order1])) * stbir__max_uint16_as_float_inverted; + #endif + #if stbir__coder_min_num >= 3 + decode[2] = ((float)(input[stbir__decode_order2])) * stbir__max_uint16_as_float_inverted; + #endif + decode += stbir__coder_min_num; + input += stbir__coder_min_num; + } + #endif + return decode_end; +} + + +static void STBIR__CODER_NAME(stbir__encode_uint16_linear_scaled)( void * outputp, int width_times_channels, float const * encode ) +{ + unsigned short STBIR_SIMD_STREAMOUT_PTR( * ) output = (unsigned short*) outputp; + unsigned short * end_output = ( (unsigned short*) output ) + width_times_channels; + + #ifdef STBIR_SIMD + { + if ( width_times_channels >= stbir__simdfX_float_count*2 ) + { + float const * end_encode_m8 = encode + width_times_channels - stbir__simdfX_float_count*2; + end_output -= stbir__simdfX_float_count*2; + STBIR_SIMD_NO_UNROLL_LOOP_START_INF_FOR + for(;;) + { + stbir__simdfX e0, e1; + stbir__simdiX i; + STBIR_SIMD_NO_UNROLL(encode); + stbir__simdfX_madd_mem( e0, STBIR_simd_point5X, STBIR_max_uint16_as_floatX, encode ); + stbir__simdfX_madd_mem( e1, STBIR_simd_point5X, STBIR_max_uint16_as_floatX, encode+stbir__simdfX_float_count ); + stbir__encode_simdfX_unflip( e0 ); + stbir__encode_simdfX_unflip( e1 ); + stbir__simdfX_pack_to_words( i, e0, e1 ); + stbir__simdiX_store( output, i ); + encode += stbir__simdfX_float_count*2; + output += stbir__simdfX_float_count*2; + if ( output <= end_output ) + continue; + if ( output == ( end_output + stbir__simdfX_float_count*2 ) ) + break; + output = end_output; // backup and do last couple + encode = end_encode_m8; + } + return; + } + } + + // try to do blocks of 4 when you can + #if stbir__coder_min_num != 3 // doesn't divide cleanly by four + output += 4; + STBIR_NO_UNROLL_LOOP_START + while( output <= end_output ) + { + stbir__simdf e; + stbir__simdi i; + STBIR_NO_UNROLL(encode); + stbir__simdf_load( e, encode ); + stbir__simdf_madd( e, STBIR__CONSTF(STBIR_simd_point5), STBIR__CONSTF(STBIR_max_uint16_as_float), e ); + stbir__encode_simdf4_unflip( e ); + stbir__simdf_pack_to_8words( i, e, e ); // only use first 4 + stbir__simdi_store2( output-4, i ); + output += 4; + encode += 4; + } + output -= 4; + #endif + + // do the remnants + #if stbir__coder_min_num < 4 + STBIR_NO_UNROLL_LOOP_START + while( output < end_output ) + { + stbir__simdf e; + STBIR_NO_UNROLL(encode); + stbir__simdf_madd1_mem( e, STBIR__CONSTF(STBIR_simd_point5), STBIR__CONSTF(STBIR_max_uint16_as_float), encode+stbir__encode_order0 ); output[0] = stbir__simdf_convert_float_to_short( e ); + #if stbir__coder_min_num >= 2 + stbir__simdf_madd1_mem( e, STBIR__CONSTF(STBIR_simd_point5), STBIR__CONSTF(STBIR_max_uint16_as_float), encode+stbir__encode_order1 ); output[1] = stbir__simdf_convert_float_to_short( e ); + #endif + #if stbir__coder_min_num >= 3 + stbir__simdf_madd1_mem( e, STBIR__CONSTF(STBIR_simd_point5), STBIR__CONSTF(STBIR_max_uint16_as_float), encode+stbir__encode_order2 ); output[2] = stbir__simdf_convert_float_to_short( e ); + #endif + output += stbir__coder_min_num; + encode += stbir__coder_min_num; + } + #endif + + #else + + // try to do blocks of 4 when you can + #if stbir__coder_min_num != 3 // doesn't divide cleanly by four + output += 4; + STBIR_SIMD_NO_UNROLL_LOOP_START + while( output <= end_output ) + { + float f; + STBIR_SIMD_NO_UNROLL(encode); + f = encode[stbir__encode_order0] * stbir__max_uint16_as_float + 0.5f; STBIR_CLAMP(f, 0, 65535); output[0-4] = (unsigned short)f; + f = encode[stbir__encode_order1] * stbir__max_uint16_as_float + 0.5f; STBIR_CLAMP(f, 0, 65535); output[1-4] = (unsigned short)f; + f = encode[stbir__encode_order2] * stbir__max_uint16_as_float + 0.5f; STBIR_CLAMP(f, 0, 65535); output[2-4] = (unsigned short)f; + f = encode[stbir__encode_order3] * stbir__max_uint16_as_float + 0.5f; STBIR_CLAMP(f, 0, 65535); output[3-4] = (unsigned short)f; + output += 4; + encode += 4; + } + output -= 4; + #endif + + // do the remnants + #if stbir__coder_min_num < 4 + STBIR_NO_UNROLL_LOOP_START + while( output < end_output ) + { + float f; + STBIR_NO_UNROLL(encode); + f = encode[stbir__encode_order0] * stbir__max_uint16_as_float + 0.5f; STBIR_CLAMP(f, 0, 65535); output[0] = (unsigned short)f; + #if stbir__coder_min_num >= 2 + f = encode[stbir__encode_order1] * stbir__max_uint16_as_float + 0.5f; STBIR_CLAMP(f, 0, 65535); output[1] = (unsigned short)f; + #endif + #if stbir__coder_min_num >= 3 + f = encode[stbir__encode_order2] * stbir__max_uint16_as_float + 0.5f; STBIR_CLAMP(f, 0, 65535); output[2] = (unsigned short)f; + #endif + output += stbir__coder_min_num; + encode += stbir__coder_min_num; + } + #endif + #endif +} + +static float * STBIR__CODER_NAME(stbir__decode_uint16_linear)( float * decodep, int width_times_channels, void const * inputp ) +{ + float STBIR_STREAMOUT_PTR( * ) decode = decodep; + float * decode_end = (float*) decode + width_times_channels; + unsigned short const * input = (unsigned short const *)inputp; + + #ifdef STBIR_SIMD + unsigned short const * end_input_m8 = input + width_times_channels - 8; + if ( width_times_channels >= 8 ) + { + decode_end -= 8; + STBIR_NO_UNROLL_LOOP_START_INF_FOR + for(;;) + { + #ifdef STBIR_SIMD8 + stbir__simdi i; stbir__simdi8 o; + stbir__simdf8 of; + STBIR_NO_UNROLL(decode); + stbir__simdi_load( i, input ); + stbir__simdi8_expand_u16_to_u32( o, i ); + stbir__simdi8_convert_i32_to_float( of, o ); + stbir__decode_simdf8_flip( of ); + stbir__simdf8_store( decode + 0, of ); + #else + stbir__simdi i, o0, o1; + stbir__simdf of0, of1; + STBIR_NO_UNROLL(decode); + stbir__simdi_load( i, input ); + stbir__simdi_expand_u16_to_u32( o0, o1, i ); + stbir__simdi_convert_i32_to_float( of0, o0 ); + stbir__simdi_convert_i32_to_float( of1, o1 ); + stbir__decode_simdf4_flip( of0 ); + stbir__decode_simdf4_flip( of1 ); + stbir__simdf_store( decode + 0, of0 ); + stbir__simdf_store( decode + 4, of1 ); + #endif + decode += 8; + input += 8; + if ( decode <= decode_end ) + continue; + if ( decode == ( decode_end + 8 ) ) + break; + decode = decode_end; // backup and do last couple + input = end_input_m8; + } + return decode_end + 8; + } + #endif + + // try to do blocks of 4 when you can + #if stbir__coder_min_num != 3 // doesn't divide cleanly by four + decode += 4; + STBIR_SIMD_NO_UNROLL_LOOP_START + while( decode <= decode_end ) + { + STBIR_SIMD_NO_UNROLL(decode); + decode[0-4] = ((float)(input[stbir__decode_order0])); + decode[1-4] = ((float)(input[stbir__decode_order1])); + decode[2-4] = ((float)(input[stbir__decode_order2])); + decode[3-4] = ((float)(input[stbir__decode_order3])); + decode += 4; + input += 4; + } + decode -= 4; + #endif + + // do the remnants + #if stbir__coder_min_num < 4 + STBIR_NO_UNROLL_LOOP_START + while( decode < decode_end ) + { + STBIR_NO_UNROLL(decode); + decode[0] = ((float)(input[stbir__decode_order0])); + #if stbir__coder_min_num >= 2 + decode[1] = ((float)(input[stbir__decode_order1])); + #endif + #if stbir__coder_min_num >= 3 + decode[2] = ((float)(input[stbir__decode_order2])); + #endif + decode += stbir__coder_min_num; + input += stbir__coder_min_num; + } + #endif + return decode_end; +} + +static void STBIR__CODER_NAME(stbir__encode_uint16_linear)( void * outputp, int width_times_channels, float const * encode ) +{ + unsigned short STBIR_SIMD_STREAMOUT_PTR( * ) output = (unsigned short*) outputp; + unsigned short * end_output = ( (unsigned short*) output ) + width_times_channels; + + #ifdef STBIR_SIMD + { + if ( width_times_channels >= stbir__simdfX_float_count*2 ) + { + float const * end_encode_m8 = encode + width_times_channels - stbir__simdfX_float_count*2; + end_output -= stbir__simdfX_float_count*2; + STBIR_SIMD_NO_UNROLL_LOOP_START_INF_FOR + for(;;) + { + stbir__simdfX e0, e1; + stbir__simdiX i; + STBIR_SIMD_NO_UNROLL(encode); + stbir__simdfX_add_mem( e0, STBIR_simd_point5X, encode ); + stbir__simdfX_add_mem( e1, STBIR_simd_point5X, encode+stbir__simdfX_float_count ); + stbir__encode_simdfX_unflip( e0 ); + stbir__encode_simdfX_unflip( e1 ); + stbir__simdfX_pack_to_words( i, e0, e1 ); + stbir__simdiX_store( output, i ); + encode += stbir__simdfX_float_count*2; + output += stbir__simdfX_float_count*2; + if ( output <= end_output ) + continue; + if ( output == ( end_output + stbir__simdfX_float_count*2 ) ) + break; + output = end_output; // backup and do last couple + encode = end_encode_m8; + } + return; + } + } + + // try to do blocks of 4 when you can + #if stbir__coder_min_num != 3 // doesn't divide cleanly by four + output += 4; + STBIR_NO_UNROLL_LOOP_START + while( output <= end_output ) + { + stbir__simdf e; + stbir__simdi i; + STBIR_NO_UNROLL(encode); + stbir__simdf_load( e, encode ); + stbir__simdf_add( e, STBIR__CONSTF(STBIR_simd_point5), e ); + stbir__encode_simdf4_unflip( e ); + stbir__simdf_pack_to_8words( i, e, e ); // only use first 4 + stbir__simdi_store2( output-4, i ); + output += 4; + encode += 4; + } + output -= 4; + #endif + + #else + + // try to do blocks of 4 when you can + #if stbir__coder_min_num != 3 // doesn't divide cleanly by four + output += 4; + STBIR_SIMD_NO_UNROLL_LOOP_START + while( output <= end_output ) + { + float f; + STBIR_SIMD_NO_UNROLL(encode); + f = encode[stbir__encode_order0] + 0.5f; STBIR_CLAMP(f, 0, 65535); output[0-4] = (unsigned short)f; + f = encode[stbir__encode_order1] + 0.5f; STBIR_CLAMP(f, 0, 65535); output[1-4] = (unsigned short)f; + f = encode[stbir__encode_order2] + 0.5f; STBIR_CLAMP(f, 0, 65535); output[2-4] = (unsigned short)f; + f = encode[stbir__encode_order3] + 0.5f; STBIR_CLAMP(f, 0, 65535); output[3-4] = (unsigned short)f; + output += 4; + encode += 4; + } + output -= 4; + #endif + + #endif + + // do the remnants + #if stbir__coder_min_num < 4 + STBIR_NO_UNROLL_LOOP_START + while( output < end_output ) + { + float f; + STBIR_NO_UNROLL(encode); + f = encode[stbir__encode_order0] + 0.5f; STBIR_CLAMP(f, 0, 65535); output[0] = (unsigned short)f; + #if stbir__coder_min_num >= 2 + f = encode[stbir__encode_order1] + 0.5f; STBIR_CLAMP(f, 0, 65535); output[1] = (unsigned short)f; + #endif + #if stbir__coder_min_num >= 3 + f = encode[stbir__encode_order2] + 0.5f; STBIR_CLAMP(f, 0, 65535); output[2] = (unsigned short)f; + #endif + output += stbir__coder_min_num; + encode += stbir__coder_min_num; + } + #endif +} + +static float * STBIR__CODER_NAME(stbir__decode_half_float_linear)( float * decodep, int width_times_channels, void const * inputp ) +{ + float STBIR_STREAMOUT_PTR( * ) decode = decodep; + float * decode_end = (float*) decode + width_times_channels; + stbir__FP16 const * input = (stbir__FP16 const *)inputp; + + #ifdef STBIR_SIMD + if ( width_times_channels >= 8 ) + { + stbir__FP16 const * end_input_m8 = input + width_times_channels - 8; + decode_end -= 8; + STBIR_NO_UNROLL_LOOP_START_INF_FOR + for(;;) + { + STBIR_NO_UNROLL(decode); + + stbir__half_to_float_SIMD( decode, input ); + #ifdef stbir__decode_swizzle + #ifdef STBIR_SIMD8 + { + stbir__simdf8 of; + stbir__simdf8_load( of, decode ); + stbir__decode_simdf8_flip( of ); + stbir__simdf8_store( decode, of ); + } + #else + { + stbir__simdf of0,of1; + stbir__simdf_load( of0, decode ); + stbir__simdf_load( of1, decode+4 ); + stbir__decode_simdf4_flip( of0 ); + stbir__decode_simdf4_flip( of1 ); + stbir__simdf_store( decode, of0 ); + stbir__simdf_store( decode+4, of1 ); + } + #endif + #endif + decode += 8; + input += 8; + if ( decode <= decode_end ) + continue; + if ( decode == ( decode_end + 8 ) ) + break; + decode = decode_end; // backup and do last couple + input = end_input_m8; + } + return decode_end + 8; + } + #endif + + // try to do blocks of 4 when you can + #if stbir__coder_min_num != 3 // doesn't divide cleanly by four + decode += 4; + STBIR_SIMD_NO_UNROLL_LOOP_START + while( decode <= decode_end ) + { + STBIR_SIMD_NO_UNROLL(decode); + decode[0-4] = stbir__half_to_float(input[stbir__decode_order0]); + decode[1-4] = stbir__half_to_float(input[stbir__decode_order1]); + decode[2-4] = stbir__half_to_float(input[stbir__decode_order2]); + decode[3-4] = stbir__half_to_float(input[stbir__decode_order3]); + decode += 4; + input += 4; + } + decode -= 4; + #endif + + // do the remnants + #if stbir__coder_min_num < 4 + STBIR_NO_UNROLL_LOOP_START + while( decode < decode_end ) + { + STBIR_NO_UNROLL(decode); + decode[0] = stbir__half_to_float(input[stbir__decode_order0]); + #if stbir__coder_min_num >= 2 + decode[1] = stbir__half_to_float(input[stbir__decode_order1]); + #endif + #if stbir__coder_min_num >= 3 + decode[2] = stbir__half_to_float(input[stbir__decode_order2]); + #endif + decode += stbir__coder_min_num; + input += stbir__coder_min_num; + } + #endif + return decode_end; +} + +static void STBIR__CODER_NAME( stbir__encode_half_float_linear )( void * outputp, int width_times_channels, float const * encode ) +{ + stbir__FP16 STBIR_SIMD_STREAMOUT_PTR( * ) output = (stbir__FP16*) outputp; + stbir__FP16 * end_output = ( (stbir__FP16*) output ) + width_times_channels; + + #ifdef STBIR_SIMD + if ( width_times_channels >= 8 ) + { + float const * end_encode_m8 = encode + width_times_channels - 8; + end_output -= 8; + STBIR_SIMD_NO_UNROLL_LOOP_START_INF_FOR + for(;;) + { + STBIR_SIMD_NO_UNROLL(encode); + #ifdef stbir__decode_swizzle + #ifdef STBIR_SIMD8 + { + stbir__simdf8 of; + stbir__simdf8_load( of, encode ); + stbir__encode_simdf8_unflip( of ); + stbir__float_to_half_SIMD( output, (float*)&of ); + } + #else + { + stbir__simdf of[2]; + stbir__simdf_load( of[0], encode ); + stbir__simdf_load( of[1], encode+4 ); + stbir__encode_simdf4_unflip( of[0] ); + stbir__encode_simdf4_unflip( of[1] ); + stbir__float_to_half_SIMD( output, (float*)of ); + } + #endif + #else + stbir__float_to_half_SIMD( output, encode ); + #endif + encode += 8; + output += 8; + if ( output <= end_output ) + continue; + if ( output == ( end_output + 8 ) ) + break; + output = end_output; // backup and do last couple + encode = end_encode_m8; + } + return; + } + #endif + + // try to do blocks of 4 when you can + #if stbir__coder_min_num != 3 // doesn't divide cleanly by four + output += 4; + STBIR_SIMD_NO_UNROLL_LOOP_START + while( output <= end_output ) + { + STBIR_SIMD_NO_UNROLL(output); + output[0-4] = stbir__float_to_half(encode[stbir__encode_order0]); + output[1-4] = stbir__float_to_half(encode[stbir__encode_order1]); + output[2-4] = stbir__float_to_half(encode[stbir__encode_order2]); + output[3-4] = stbir__float_to_half(encode[stbir__encode_order3]); + output += 4; + encode += 4; + } + output -= 4; + #endif + + // do the remnants + #if stbir__coder_min_num < 4 + STBIR_NO_UNROLL_LOOP_START + while( output < end_output ) + { + STBIR_NO_UNROLL(output); + output[0] = stbir__float_to_half(encode[stbir__encode_order0]); + #if stbir__coder_min_num >= 2 + output[1] = stbir__float_to_half(encode[stbir__encode_order1]); + #endif + #if stbir__coder_min_num >= 3 + output[2] = stbir__float_to_half(encode[stbir__encode_order2]); + #endif + output += stbir__coder_min_num; + encode += stbir__coder_min_num; + } + #endif +} + +static float * STBIR__CODER_NAME(stbir__decode_float_linear)( float * decodep, int width_times_channels, void const * inputp ) +{ + #ifdef stbir__decode_swizzle + float STBIR_STREAMOUT_PTR( * ) decode = decodep; + float * decode_end = (float*) decode + width_times_channels; + float const * input = (float const *)inputp; + + #ifdef STBIR_SIMD + if ( width_times_channels >= 16 ) + { + float const * end_input_m16 = input + width_times_channels - 16; + decode_end -= 16; + STBIR_NO_UNROLL_LOOP_START_INF_FOR + for(;;) + { + STBIR_NO_UNROLL(decode); + #ifdef stbir__decode_swizzle + #ifdef STBIR_SIMD8 + { + stbir__simdf8 of0,of1; + stbir__simdf8_load( of0, input ); + stbir__simdf8_load( of1, input+8 ); + stbir__decode_simdf8_flip( of0 ); + stbir__decode_simdf8_flip( of1 ); + stbir__simdf8_store( decode, of0 ); + stbir__simdf8_store( decode+8, of1 ); + } + #else + { + stbir__simdf of0,of1,of2,of3; + stbir__simdf_load( of0, input ); + stbir__simdf_load( of1, input+4 ); + stbir__simdf_load( of2, input+8 ); + stbir__simdf_load( of3, input+12 ); + stbir__decode_simdf4_flip( of0 ); + stbir__decode_simdf4_flip( of1 ); + stbir__decode_simdf4_flip( of2 ); + stbir__decode_simdf4_flip( of3 ); + stbir__simdf_store( decode, of0 ); + stbir__simdf_store( decode+4, of1 ); + stbir__simdf_store( decode+8, of2 ); + stbir__simdf_store( decode+12, of3 ); + } + #endif + #endif + decode += 16; + input += 16; + if ( decode <= decode_end ) + continue; + if ( decode == ( decode_end + 16 ) ) + break; + decode = decode_end; // backup and do last couple + input = end_input_m16; + } + return decode_end + 16; + } + #endif + + // try to do blocks of 4 when you can + #if stbir__coder_min_num != 3 // doesn't divide cleanly by four + decode += 4; + STBIR_SIMD_NO_UNROLL_LOOP_START + while( decode <= decode_end ) + { + STBIR_SIMD_NO_UNROLL(decode); + decode[0-4] = input[stbir__decode_order0]; + decode[1-4] = input[stbir__decode_order1]; + decode[2-4] = input[stbir__decode_order2]; + decode[3-4] = input[stbir__decode_order3]; + decode += 4; + input += 4; + } + decode -= 4; + #endif + + // do the remnants + #if stbir__coder_min_num < 4 + STBIR_NO_UNROLL_LOOP_START + while( decode < decode_end ) + { + STBIR_NO_UNROLL(decode); + decode[0] = input[stbir__decode_order0]; + #if stbir__coder_min_num >= 2 + decode[1] = input[stbir__decode_order1]; + #endif + #if stbir__coder_min_num >= 3 + decode[2] = input[stbir__decode_order2]; + #endif + decode += stbir__coder_min_num; + input += stbir__coder_min_num; + } + #endif + return decode_end; + + #else + + if ( (void*)decodep != inputp ) + STBIR_MEMCPY( decodep, inputp, width_times_channels * sizeof( float ) ); + + return decodep + width_times_channels; + + #endif +} + +static void STBIR__CODER_NAME( stbir__encode_float_linear )( void * outputp, int width_times_channels, float const * encode ) +{ + #if !defined( STBIR_FLOAT_HIGH_CLAMP ) && !defined(STBIR_FLOAT_LOW_CLAMP) && !defined(stbir__decode_swizzle) + + if ( (void*)outputp != (void*) encode ) + STBIR_MEMCPY( outputp, encode, width_times_channels * sizeof( float ) ); + + #else + + float STBIR_SIMD_STREAMOUT_PTR( * ) output = (float*) outputp; + float * end_output = ( (float*) output ) + width_times_channels; + + #ifdef STBIR_FLOAT_HIGH_CLAMP + #define stbir_scalar_hi_clamp( v ) if ( v > STBIR_FLOAT_HIGH_CLAMP ) v = STBIR_FLOAT_HIGH_CLAMP; + #else + #define stbir_scalar_hi_clamp( v ) + #endif + #ifdef STBIR_FLOAT_LOW_CLAMP + #define stbir_scalar_lo_clamp( v ) if ( v < STBIR_FLOAT_LOW_CLAMP ) v = STBIR_FLOAT_LOW_CLAMP; + #else + #define stbir_scalar_lo_clamp( v ) + #endif + + #ifdef STBIR_SIMD + + #ifdef STBIR_FLOAT_HIGH_CLAMP + const stbir__simdfX high_clamp = stbir__simdf_frepX(STBIR_FLOAT_HIGH_CLAMP); + #endif + #ifdef STBIR_FLOAT_LOW_CLAMP + const stbir__simdfX low_clamp = stbir__simdf_frepX(STBIR_FLOAT_LOW_CLAMP); + #endif + + if ( width_times_channels >= ( stbir__simdfX_float_count * 2 ) ) + { + float const * end_encode_m8 = encode + width_times_channels - ( stbir__simdfX_float_count * 2 ); + end_output -= ( stbir__simdfX_float_count * 2 ); + STBIR_SIMD_NO_UNROLL_LOOP_START_INF_FOR + for(;;) + { + stbir__simdfX e0, e1; + STBIR_SIMD_NO_UNROLL(encode); + stbir__simdfX_load( e0, encode ); + stbir__simdfX_load( e1, encode+stbir__simdfX_float_count ); +#ifdef STBIR_FLOAT_HIGH_CLAMP + stbir__simdfX_min( e0, e0, high_clamp ); + stbir__simdfX_min( e1, e1, high_clamp ); +#endif +#ifdef STBIR_FLOAT_LOW_CLAMP + stbir__simdfX_max( e0, e0, low_clamp ); + stbir__simdfX_max( e1, e1, low_clamp ); +#endif + stbir__encode_simdfX_unflip( e0 ); + stbir__encode_simdfX_unflip( e1 ); + stbir__simdfX_store( output, e0 ); + stbir__simdfX_store( output+stbir__simdfX_float_count, e1 ); + encode += stbir__simdfX_float_count * 2; + output += stbir__simdfX_float_count * 2; + if ( output <= end_output ) + continue; + if ( output == ( end_output + ( stbir__simdfX_float_count * 2 ) ) ) + break; + output = end_output; // backup and do last couple + encode = end_encode_m8; + } + return; + } + + // try to do blocks of 4 when you can + #if stbir__coder_min_num != 3 // doesn't divide cleanly by four + output += 4; + STBIR_NO_UNROLL_LOOP_START + while( output <= end_output ) + { + stbir__simdf e0; + STBIR_NO_UNROLL(encode); + stbir__simdf_load( e0, encode ); +#ifdef STBIR_FLOAT_HIGH_CLAMP + stbir__simdf_min( e0, e0, high_clamp ); +#endif +#ifdef STBIR_FLOAT_LOW_CLAMP + stbir__simdf_max( e0, e0, low_clamp ); +#endif + stbir__encode_simdf4_unflip( e0 ); + stbir__simdf_store( output-4, e0 ); + output += 4; + encode += 4; + } + output -= 4; + #endif + + #else + + // try to do blocks of 4 when you can + #if stbir__coder_min_num != 3 // doesn't divide cleanly by four + output += 4; + STBIR_SIMD_NO_UNROLL_LOOP_START + while( output <= end_output ) + { + float e; + STBIR_SIMD_NO_UNROLL(encode); + e = encode[ stbir__encode_order0 ]; stbir_scalar_hi_clamp( e ); stbir_scalar_lo_clamp( e ); output[0-4] = e; + e = encode[ stbir__encode_order1 ]; stbir_scalar_hi_clamp( e ); stbir_scalar_lo_clamp( e ); output[1-4] = e; + e = encode[ stbir__encode_order2 ]; stbir_scalar_hi_clamp( e ); stbir_scalar_lo_clamp( e ); output[2-4] = e; + e = encode[ stbir__encode_order3 ]; stbir_scalar_hi_clamp( e ); stbir_scalar_lo_clamp( e ); output[3-4] = e; + output += 4; + encode += 4; + } + output -= 4; + + #endif + + #endif + + // do the remnants + #if stbir__coder_min_num < 4 + STBIR_NO_UNROLL_LOOP_START + while( output < end_output ) + { + float e; + STBIR_NO_UNROLL(encode); + e = encode[ stbir__encode_order0 ]; stbir_scalar_hi_clamp( e ); stbir_scalar_lo_clamp( e ); output[0] = e; + #if stbir__coder_min_num >= 2 + e = encode[ stbir__encode_order1 ]; stbir_scalar_hi_clamp( e ); stbir_scalar_lo_clamp( e ); output[1] = e; + #endif + #if stbir__coder_min_num >= 3 + e = encode[ stbir__encode_order2 ]; stbir_scalar_hi_clamp( e ); stbir_scalar_lo_clamp( e ); output[2] = e; + #endif + output += stbir__coder_min_num; + encode += stbir__coder_min_num; + } + #endif + + #endif +} + +#undef stbir__decode_suffix +#undef stbir__decode_simdf8_flip +#undef stbir__decode_simdf4_flip +#undef stbir__decode_order0 +#undef stbir__decode_order1 +#undef stbir__decode_order2 +#undef stbir__decode_order3 +#undef stbir__encode_order0 +#undef stbir__encode_order1 +#undef stbir__encode_order2 +#undef stbir__encode_order3 +#undef stbir__encode_simdf8_unflip +#undef stbir__encode_simdf4_unflip +#undef stbir__encode_simdfX_unflip +#undef STBIR__CODER_NAME +#undef stbir__coder_min_num +#undef stbir__decode_swizzle +#undef stbir_scalar_hi_clamp +#undef stbir_scalar_lo_clamp +#undef STB_IMAGE_RESIZE_DO_CODERS + +#elif defined( STB_IMAGE_RESIZE_DO_VERTICALS) + +#ifdef STB_IMAGE_RESIZE_VERTICAL_CONTINUE +#define STBIR_chans( start, end ) STBIR_strs_join14(start,STBIR__vertical_channels,end,_cont) +#else +#define STBIR_chans( start, end ) STBIR_strs_join1(start,STBIR__vertical_channels,end) +#endif + +#if STBIR__vertical_channels >= 1 +#define stbIF0( code ) code +#else +#define stbIF0( code ) +#endif +#if STBIR__vertical_channels >= 2 +#define stbIF1( code ) code +#else +#define stbIF1( code ) +#endif +#if STBIR__vertical_channels >= 3 +#define stbIF2( code ) code +#else +#define stbIF2( code ) +#endif +#if STBIR__vertical_channels >= 4 +#define stbIF3( code ) code +#else +#define stbIF3( code ) +#endif +#if STBIR__vertical_channels >= 5 +#define stbIF4( code ) code +#else +#define stbIF4( code ) +#endif +#if STBIR__vertical_channels >= 6 +#define stbIF5( code ) code +#else +#define stbIF5( code ) +#endif +#if STBIR__vertical_channels >= 7 +#define stbIF6( code ) code +#else +#define stbIF6( code ) +#endif +#if STBIR__vertical_channels >= 8 +#define stbIF7( code ) code +#else +#define stbIF7( code ) +#endif + +static void STBIR_chans( stbir__vertical_scatter_with_,_coeffs)( float ** outputs, float const * vertical_coefficients, float const * input, float const * input_end ) +{ + stbIF0( float STBIR_SIMD_STREAMOUT_PTR( * ) output0 = outputs[0]; float c0s = vertical_coefficients[0]; ) + stbIF1( float STBIR_SIMD_STREAMOUT_PTR( * ) output1 = outputs[1]; float c1s = vertical_coefficients[1]; ) + stbIF2( float STBIR_SIMD_STREAMOUT_PTR( * ) output2 = outputs[2]; float c2s = vertical_coefficients[2]; ) + stbIF3( float STBIR_SIMD_STREAMOUT_PTR( * ) output3 = outputs[3]; float c3s = vertical_coefficients[3]; ) + stbIF4( float STBIR_SIMD_STREAMOUT_PTR( * ) output4 = outputs[4]; float c4s = vertical_coefficients[4]; ) + stbIF5( float STBIR_SIMD_STREAMOUT_PTR( * ) output5 = outputs[5]; float c5s = vertical_coefficients[5]; ) + stbIF6( float STBIR_SIMD_STREAMOUT_PTR( * ) output6 = outputs[6]; float c6s = vertical_coefficients[6]; ) + stbIF7( float STBIR_SIMD_STREAMOUT_PTR( * ) output7 = outputs[7]; float c7s = vertical_coefficients[7]; ) + + #ifdef STBIR_SIMD + { + stbIF0(stbir__simdfX c0 = stbir__simdf_frepX( c0s ); ) + stbIF1(stbir__simdfX c1 = stbir__simdf_frepX( c1s ); ) + stbIF2(stbir__simdfX c2 = stbir__simdf_frepX( c2s ); ) + stbIF3(stbir__simdfX c3 = stbir__simdf_frepX( c3s ); ) + stbIF4(stbir__simdfX c4 = stbir__simdf_frepX( c4s ); ) + stbIF5(stbir__simdfX c5 = stbir__simdf_frepX( c5s ); ) + stbIF6(stbir__simdfX c6 = stbir__simdf_frepX( c6s ); ) + stbIF7(stbir__simdfX c7 = stbir__simdf_frepX( c7s ); ) + STBIR_SIMD_NO_UNROLL_LOOP_START + while ( ( (char*)input_end - (char*) input ) >= (16*stbir__simdfX_float_count) ) + { + stbir__simdfX o0, o1, o2, o3, r0, r1, r2, r3; + STBIR_SIMD_NO_UNROLL(output0); + + stbir__simdfX_load( r0, input ); stbir__simdfX_load( r1, input+stbir__simdfX_float_count ); stbir__simdfX_load( r2, input+(2*stbir__simdfX_float_count) ); stbir__simdfX_load( r3, input+(3*stbir__simdfX_float_count) ); + + #ifdef STB_IMAGE_RESIZE_VERTICAL_CONTINUE + stbIF0( stbir__simdfX_load( o0, output0 ); stbir__simdfX_load( o1, output0+stbir__simdfX_float_count ); stbir__simdfX_load( o2, output0+(2*stbir__simdfX_float_count) ); stbir__simdfX_load( o3, output0+(3*stbir__simdfX_float_count) ); + stbir__simdfX_madd( o0, o0, r0, c0 ); stbir__simdfX_madd( o1, o1, r1, c0 ); stbir__simdfX_madd( o2, o2, r2, c0 ); stbir__simdfX_madd( o3, o3, r3, c0 ); + stbir__simdfX_store( output0, o0 ); stbir__simdfX_store( output0+stbir__simdfX_float_count, o1 ); stbir__simdfX_store( output0+(2*stbir__simdfX_float_count), o2 ); stbir__simdfX_store( output0+(3*stbir__simdfX_float_count), o3 ); ) + stbIF1( stbir__simdfX_load( o0, output1 ); stbir__simdfX_load( o1, output1+stbir__simdfX_float_count ); stbir__simdfX_load( o2, output1+(2*stbir__simdfX_float_count) ); stbir__simdfX_load( o3, output1+(3*stbir__simdfX_float_count) ); + stbir__simdfX_madd( o0, o0, r0, c1 ); stbir__simdfX_madd( o1, o1, r1, c1 ); stbir__simdfX_madd( o2, o2, r2, c1 ); stbir__simdfX_madd( o3, o3, r3, c1 ); + stbir__simdfX_store( output1, o0 ); stbir__simdfX_store( output1+stbir__simdfX_float_count, o1 ); stbir__simdfX_store( output1+(2*stbir__simdfX_float_count), o2 ); stbir__simdfX_store( output1+(3*stbir__simdfX_float_count), o3 ); ) + stbIF2( stbir__simdfX_load( o0, output2 ); stbir__simdfX_load( o1, output2+stbir__simdfX_float_count ); stbir__simdfX_load( o2, output2+(2*stbir__simdfX_float_count) ); stbir__simdfX_load( o3, output2+(3*stbir__simdfX_float_count) ); + stbir__simdfX_madd( o0, o0, r0, c2 ); stbir__simdfX_madd( o1, o1, r1, c2 ); stbir__simdfX_madd( o2, o2, r2, c2 ); stbir__simdfX_madd( o3, o3, r3, c2 ); + stbir__simdfX_store( output2, o0 ); stbir__simdfX_store( output2+stbir__simdfX_float_count, o1 ); stbir__simdfX_store( output2+(2*stbir__simdfX_float_count), o2 ); stbir__simdfX_store( output2+(3*stbir__simdfX_float_count), o3 ); ) + stbIF3( stbir__simdfX_load( o0, output3 ); stbir__simdfX_load( o1, output3+stbir__simdfX_float_count ); stbir__simdfX_load( o2, output3+(2*stbir__simdfX_float_count) ); stbir__simdfX_load( o3, output3+(3*stbir__simdfX_float_count) ); + stbir__simdfX_madd( o0, o0, r0, c3 ); stbir__simdfX_madd( o1, o1, r1, c3 ); stbir__simdfX_madd( o2, o2, r2, c3 ); stbir__simdfX_madd( o3, o3, r3, c3 ); + stbir__simdfX_store( output3, o0 ); stbir__simdfX_store( output3+stbir__simdfX_float_count, o1 ); stbir__simdfX_store( output3+(2*stbir__simdfX_float_count), o2 ); stbir__simdfX_store( output3+(3*stbir__simdfX_float_count), o3 ); ) + stbIF4( stbir__simdfX_load( o0, output4 ); stbir__simdfX_load( o1, output4+stbir__simdfX_float_count ); stbir__simdfX_load( o2, output4+(2*stbir__simdfX_float_count) ); stbir__simdfX_load( o3, output4+(3*stbir__simdfX_float_count) ); + stbir__simdfX_madd( o0, o0, r0, c4 ); stbir__simdfX_madd( o1, o1, r1, c4 ); stbir__simdfX_madd( o2, o2, r2, c4 ); stbir__simdfX_madd( o3, o3, r3, c4 ); + stbir__simdfX_store( output4, o0 ); stbir__simdfX_store( output4+stbir__simdfX_float_count, o1 ); stbir__simdfX_store( output4+(2*stbir__simdfX_float_count), o2 ); stbir__simdfX_store( output4+(3*stbir__simdfX_float_count), o3 ); ) + stbIF5( stbir__simdfX_load( o0, output5 ); stbir__simdfX_load( o1, output5+stbir__simdfX_float_count ); stbir__simdfX_load( o2, output5+(2*stbir__simdfX_float_count)); stbir__simdfX_load( o3, output5+(3*stbir__simdfX_float_count) ); + stbir__simdfX_madd( o0, o0, r0, c5 ); stbir__simdfX_madd( o1, o1, r1, c5 ); stbir__simdfX_madd( o2, o2, r2, c5 ); stbir__simdfX_madd( o3, o3, r3, c5 ); + stbir__simdfX_store( output5, o0 ); stbir__simdfX_store( output5+stbir__simdfX_float_count, o1 ); stbir__simdfX_store( output5+(2*stbir__simdfX_float_count), o2 ); stbir__simdfX_store( output5+(3*stbir__simdfX_float_count), o3 ); ) + stbIF6( stbir__simdfX_load( o0, output6 ); stbir__simdfX_load( o1, output6+stbir__simdfX_float_count ); stbir__simdfX_load( o2, output6+(2*stbir__simdfX_float_count) ); stbir__simdfX_load( o3, output6+(3*stbir__simdfX_float_count) ); + stbir__simdfX_madd( o0, o0, r0, c6 ); stbir__simdfX_madd( o1, o1, r1, c6 ); stbir__simdfX_madd( o2, o2, r2, c6 ); stbir__simdfX_madd( o3, o3, r3, c6 ); + stbir__simdfX_store( output6, o0 ); stbir__simdfX_store( output6+stbir__simdfX_float_count, o1 ); stbir__simdfX_store( output6+(2*stbir__simdfX_float_count), o2 ); stbir__simdfX_store( output6+(3*stbir__simdfX_float_count), o3 ); ) + stbIF7( stbir__simdfX_load( o0, output7 ); stbir__simdfX_load( o1, output7+stbir__simdfX_float_count ); stbir__simdfX_load( o2, output7+(2*stbir__simdfX_float_count) ); stbir__simdfX_load( o3, output7+(3*stbir__simdfX_float_count) ); + stbir__simdfX_madd( o0, o0, r0, c7 ); stbir__simdfX_madd( o1, o1, r1, c7 ); stbir__simdfX_madd( o2, o2, r2, c7 ); stbir__simdfX_madd( o3, o3, r3, c7 ); + stbir__simdfX_store( output7, o0 ); stbir__simdfX_store( output7+stbir__simdfX_float_count, o1 ); stbir__simdfX_store( output7+(2*stbir__simdfX_float_count), o2 ); stbir__simdfX_store( output7+(3*stbir__simdfX_float_count), o3 ); ) + #else + stbIF0( stbir__simdfX_mult( o0, r0, c0 ); stbir__simdfX_mult( o1, r1, c0 ); stbir__simdfX_mult( o2, r2, c0 ); stbir__simdfX_mult( o3, r3, c0 ); + stbir__simdfX_store( output0, o0 ); stbir__simdfX_store( output0+stbir__simdfX_float_count, o1 ); stbir__simdfX_store( output0+(2*stbir__simdfX_float_count), o2 ); stbir__simdfX_store( output0+(3*stbir__simdfX_float_count), o3 ); ) + stbIF1( stbir__simdfX_mult( o0, r0, c1 ); stbir__simdfX_mult( o1, r1, c1 ); stbir__simdfX_mult( o2, r2, c1 ); stbir__simdfX_mult( o3, r3, c1 ); + stbir__simdfX_store( output1, o0 ); stbir__simdfX_store( output1+stbir__simdfX_float_count, o1 ); stbir__simdfX_store( output1+(2*stbir__simdfX_float_count), o2 ); stbir__simdfX_store( output1+(3*stbir__simdfX_float_count), o3 ); ) + stbIF2( stbir__simdfX_mult( o0, r0, c2 ); stbir__simdfX_mult( o1, r1, c2 ); stbir__simdfX_mult( o2, r2, c2 ); stbir__simdfX_mult( o3, r3, c2 ); + stbir__simdfX_store( output2, o0 ); stbir__simdfX_store( output2+stbir__simdfX_float_count, o1 ); stbir__simdfX_store( output2+(2*stbir__simdfX_float_count), o2 ); stbir__simdfX_store( output2+(3*stbir__simdfX_float_count), o3 ); ) + stbIF3( stbir__simdfX_mult( o0, r0, c3 ); stbir__simdfX_mult( o1, r1, c3 ); stbir__simdfX_mult( o2, r2, c3 ); stbir__simdfX_mult( o3, r3, c3 ); + stbir__simdfX_store( output3, o0 ); stbir__simdfX_store( output3+stbir__simdfX_float_count, o1 ); stbir__simdfX_store( output3+(2*stbir__simdfX_float_count), o2 ); stbir__simdfX_store( output3+(3*stbir__simdfX_float_count), o3 ); ) + stbIF4( stbir__simdfX_mult( o0, r0, c4 ); stbir__simdfX_mult( o1, r1, c4 ); stbir__simdfX_mult( o2, r2, c4 ); stbir__simdfX_mult( o3, r3, c4 ); + stbir__simdfX_store( output4, o0 ); stbir__simdfX_store( output4+stbir__simdfX_float_count, o1 ); stbir__simdfX_store( output4+(2*stbir__simdfX_float_count), o2 ); stbir__simdfX_store( output4+(3*stbir__simdfX_float_count), o3 ); ) + stbIF5( stbir__simdfX_mult( o0, r0, c5 ); stbir__simdfX_mult( o1, r1, c5 ); stbir__simdfX_mult( o2, r2, c5 ); stbir__simdfX_mult( o3, r3, c5 ); + stbir__simdfX_store( output5, o0 ); stbir__simdfX_store( output5+stbir__simdfX_float_count, o1 ); stbir__simdfX_store( output5+(2*stbir__simdfX_float_count), o2 ); stbir__simdfX_store( output5+(3*stbir__simdfX_float_count), o3 ); ) + stbIF6( stbir__simdfX_mult( o0, r0, c6 ); stbir__simdfX_mult( o1, r1, c6 ); stbir__simdfX_mult( o2, r2, c6 ); stbir__simdfX_mult( o3, r3, c6 ); + stbir__simdfX_store( output6, o0 ); stbir__simdfX_store( output6+stbir__simdfX_float_count, o1 ); stbir__simdfX_store( output6+(2*stbir__simdfX_float_count), o2 ); stbir__simdfX_store( output6+(3*stbir__simdfX_float_count), o3 ); ) + stbIF7( stbir__simdfX_mult( o0, r0, c7 ); stbir__simdfX_mult( o1, r1, c7 ); stbir__simdfX_mult( o2, r2, c7 ); stbir__simdfX_mult( o3, r3, c7 ); + stbir__simdfX_store( output7, o0 ); stbir__simdfX_store( output7+stbir__simdfX_float_count, o1 ); stbir__simdfX_store( output7+(2*stbir__simdfX_float_count), o2 ); stbir__simdfX_store( output7+(3*stbir__simdfX_float_count), o3 ); ) + #endif + + input += (4*stbir__simdfX_float_count); + stbIF0( output0 += (4*stbir__simdfX_float_count); ) stbIF1( output1 += (4*stbir__simdfX_float_count); ) stbIF2( output2 += (4*stbir__simdfX_float_count); ) stbIF3( output3 += (4*stbir__simdfX_float_count); ) stbIF4( output4 += (4*stbir__simdfX_float_count); ) stbIF5( output5 += (4*stbir__simdfX_float_count); ) stbIF6( output6 += (4*stbir__simdfX_float_count); ) stbIF7( output7 += (4*stbir__simdfX_float_count); ) + } + STBIR_SIMD_NO_UNROLL_LOOP_START + while ( ( (char*)input_end - (char*) input ) >= 16 ) + { + stbir__simdf o0, r0; + STBIR_SIMD_NO_UNROLL(output0); + + stbir__simdf_load( r0, input ); + + #ifdef STB_IMAGE_RESIZE_VERTICAL_CONTINUE + stbIF0( stbir__simdf_load( o0, output0 ); stbir__simdf_madd( o0, o0, r0, stbir__if_simdf8_cast_to_simdf4( c0 ) ); stbir__simdf_store( output0, o0 ); ) + stbIF1( stbir__simdf_load( o0, output1 ); stbir__simdf_madd( o0, o0, r0, stbir__if_simdf8_cast_to_simdf4( c1 ) ); stbir__simdf_store( output1, o0 ); ) + stbIF2( stbir__simdf_load( o0, output2 ); stbir__simdf_madd( o0, o0, r0, stbir__if_simdf8_cast_to_simdf4( c2 ) ); stbir__simdf_store( output2, o0 ); ) + stbIF3( stbir__simdf_load( o0, output3 ); stbir__simdf_madd( o0, o0, r0, stbir__if_simdf8_cast_to_simdf4( c3 ) ); stbir__simdf_store( output3, o0 ); ) + stbIF4( stbir__simdf_load( o0, output4 ); stbir__simdf_madd( o0, o0, r0, stbir__if_simdf8_cast_to_simdf4( c4 ) ); stbir__simdf_store( output4, o0 ); ) + stbIF5( stbir__simdf_load( o0, output5 ); stbir__simdf_madd( o0, o0, r0, stbir__if_simdf8_cast_to_simdf4( c5 ) ); stbir__simdf_store( output5, o0 ); ) + stbIF6( stbir__simdf_load( o0, output6 ); stbir__simdf_madd( o0, o0, r0, stbir__if_simdf8_cast_to_simdf4( c6 ) ); stbir__simdf_store( output6, o0 ); ) + stbIF7( stbir__simdf_load( o0, output7 ); stbir__simdf_madd( o0, o0, r0, stbir__if_simdf8_cast_to_simdf4( c7 ) ); stbir__simdf_store( output7, o0 ); ) + #else + stbIF0( stbir__simdf_mult( o0, r0, stbir__if_simdf8_cast_to_simdf4( c0 ) ); stbir__simdf_store( output0, o0 ); ) + stbIF1( stbir__simdf_mult( o0, r0, stbir__if_simdf8_cast_to_simdf4( c1 ) ); stbir__simdf_store( output1, o0 ); ) + stbIF2( stbir__simdf_mult( o0, r0, stbir__if_simdf8_cast_to_simdf4( c2 ) ); stbir__simdf_store( output2, o0 ); ) + stbIF3( stbir__simdf_mult( o0, r0, stbir__if_simdf8_cast_to_simdf4( c3 ) ); stbir__simdf_store( output3, o0 ); ) + stbIF4( stbir__simdf_mult( o0, r0, stbir__if_simdf8_cast_to_simdf4( c4 ) ); stbir__simdf_store( output4, o0 ); ) + stbIF5( stbir__simdf_mult( o0, r0, stbir__if_simdf8_cast_to_simdf4( c5 ) ); stbir__simdf_store( output5, o0 ); ) + stbIF6( stbir__simdf_mult( o0, r0, stbir__if_simdf8_cast_to_simdf4( c6 ) ); stbir__simdf_store( output6, o0 ); ) + stbIF7( stbir__simdf_mult( o0, r0, stbir__if_simdf8_cast_to_simdf4( c7 ) ); stbir__simdf_store( output7, o0 ); ) + #endif + + input += 4; + stbIF0( output0 += 4; ) stbIF1( output1 += 4; ) stbIF2( output2 += 4; ) stbIF3( output3 += 4; ) stbIF4( output4 += 4; ) stbIF5( output5 += 4; ) stbIF6( output6 += 4; ) stbIF7( output7 += 4; ) + } + } + #else + STBIR_NO_UNROLL_LOOP_START + while ( ( (char*)input_end - (char*) input ) >= 16 ) + { + float r0, r1, r2, r3; + STBIR_NO_UNROLL(input); + + r0 = input[0], r1 = input[1], r2 = input[2], r3 = input[3]; + + #ifdef STB_IMAGE_RESIZE_VERTICAL_CONTINUE + stbIF0( output0[0] += ( r0 * c0s ); output0[1] += ( r1 * c0s ); output0[2] += ( r2 * c0s ); output0[3] += ( r3 * c0s ); ) + stbIF1( output1[0] += ( r0 * c1s ); output1[1] += ( r1 * c1s ); output1[2] += ( r2 * c1s ); output1[3] += ( r3 * c1s ); ) + stbIF2( output2[0] += ( r0 * c2s ); output2[1] += ( r1 * c2s ); output2[2] += ( r2 * c2s ); output2[3] += ( r3 * c2s ); ) + stbIF3( output3[0] += ( r0 * c3s ); output3[1] += ( r1 * c3s ); output3[2] += ( r2 * c3s ); output3[3] += ( r3 * c3s ); ) + stbIF4( output4[0] += ( r0 * c4s ); output4[1] += ( r1 * c4s ); output4[2] += ( r2 * c4s ); output4[3] += ( r3 * c4s ); ) + stbIF5( output5[0] += ( r0 * c5s ); output5[1] += ( r1 * c5s ); output5[2] += ( r2 * c5s ); output5[3] += ( r3 * c5s ); ) + stbIF6( output6[0] += ( r0 * c6s ); output6[1] += ( r1 * c6s ); output6[2] += ( r2 * c6s ); output6[3] += ( r3 * c6s ); ) + stbIF7( output7[0] += ( r0 * c7s ); output7[1] += ( r1 * c7s ); output7[2] += ( r2 * c7s ); output7[3] += ( r3 * c7s ); ) + #else + stbIF0( output0[0] = ( r0 * c0s ); output0[1] = ( r1 * c0s ); output0[2] = ( r2 * c0s ); output0[3] = ( r3 * c0s ); ) + stbIF1( output1[0] = ( r0 * c1s ); output1[1] = ( r1 * c1s ); output1[2] = ( r2 * c1s ); output1[3] = ( r3 * c1s ); ) + stbIF2( output2[0] = ( r0 * c2s ); output2[1] = ( r1 * c2s ); output2[2] = ( r2 * c2s ); output2[3] = ( r3 * c2s ); ) + stbIF3( output3[0] = ( r0 * c3s ); output3[1] = ( r1 * c3s ); output3[2] = ( r2 * c3s ); output3[3] = ( r3 * c3s ); ) + stbIF4( output4[0] = ( r0 * c4s ); output4[1] = ( r1 * c4s ); output4[2] = ( r2 * c4s ); output4[3] = ( r3 * c4s ); ) + stbIF5( output5[0] = ( r0 * c5s ); output5[1] = ( r1 * c5s ); output5[2] = ( r2 * c5s ); output5[3] = ( r3 * c5s ); ) + stbIF6( output6[0] = ( r0 * c6s ); output6[1] = ( r1 * c6s ); output6[2] = ( r2 * c6s ); output6[3] = ( r3 * c6s ); ) + stbIF7( output7[0] = ( r0 * c7s ); output7[1] = ( r1 * c7s ); output7[2] = ( r2 * c7s ); output7[3] = ( r3 * c7s ); ) + #endif + + input += 4; + stbIF0( output0 += 4; ) stbIF1( output1 += 4; ) stbIF2( output2 += 4; ) stbIF3( output3 += 4; ) stbIF4( output4 += 4; ) stbIF5( output5 += 4; ) stbIF6( output6 += 4; ) stbIF7( output7 += 4; ) + } + #endif + STBIR_NO_UNROLL_LOOP_START + while ( input < input_end ) + { + float r = input[0]; + STBIR_NO_UNROLL(output0); + + #ifdef STB_IMAGE_RESIZE_VERTICAL_CONTINUE + stbIF0( output0[0] += ( r * c0s ); ) + stbIF1( output1[0] += ( r * c1s ); ) + stbIF2( output2[0] += ( r * c2s ); ) + stbIF3( output3[0] += ( r * c3s ); ) + stbIF4( output4[0] += ( r * c4s ); ) + stbIF5( output5[0] += ( r * c5s ); ) + stbIF6( output6[0] += ( r * c6s ); ) + stbIF7( output7[0] += ( r * c7s ); ) + #else + stbIF0( output0[0] = ( r * c0s ); ) + stbIF1( output1[0] = ( r * c1s ); ) + stbIF2( output2[0] = ( r * c2s ); ) + stbIF3( output3[0] = ( r * c3s ); ) + stbIF4( output4[0] = ( r * c4s ); ) + stbIF5( output5[0] = ( r * c5s ); ) + stbIF6( output6[0] = ( r * c6s ); ) + stbIF7( output7[0] = ( r * c7s ); ) + #endif + + ++input; + stbIF0( ++output0; ) stbIF1( ++output1; ) stbIF2( ++output2; ) stbIF3( ++output3; ) stbIF4( ++output4; ) stbIF5( ++output5; ) stbIF6( ++output6; ) stbIF7( ++output7; ) + } +} + +static void STBIR_chans( stbir__vertical_gather_with_,_coeffs)( float * outputp, float const * vertical_coefficients, float const ** inputs, float const * input0_end ) +{ + float STBIR_SIMD_STREAMOUT_PTR( * ) output = outputp; + + stbIF0( float const * input0 = inputs[0]; float c0s = vertical_coefficients[0]; ) + stbIF1( float const * input1 = inputs[1]; float c1s = vertical_coefficients[1]; ) + stbIF2( float const * input2 = inputs[2]; float c2s = vertical_coefficients[2]; ) + stbIF3( float const * input3 = inputs[3]; float c3s = vertical_coefficients[3]; ) + stbIF4( float const * input4 = inputs[4]; float c4s = vertical_coefficients[4]; ) + stbIF5( float const * input5 = inputs[5]; float c5s = vertical_coefficients[5]; ) + stbIF6( float const * input6 = inputs[6]; float c6s = vertical_coefficients[6]; ) + stbIF7( float const * input7 = inputs[7]; float c7s = vertical_coefficients[7]; ) + +#if ( STBIR__vertical_channels == 1 ) && !defined(STB_IMAGE_RESIZE_VERTICAL_CONTINUE) + // check single channel one weight + if ( ( c0s >= (1.0f-0.000001f) ) && ( c0s <= (1.0f+0.000001f) ) ) + { + STBIR_MEMCPY( output, input0, (char*)input0_end - (char*)input0 ); + return; + } +#endif + + #ifdef STBIR_SIMD + { + stbIF0(stbir__simdfX c0 = stbir__simdf_frepX( c0s ); ) + stbIF1(stbir__simdfX c1 = stbir__simdf_frepX( c1s ); ) + stbIF2(stbir__simdfX c2 = stbir__simdf_frepX( c2s ); ) + stbIF3(stbir__simdfX c3 = stbir__simdf_frepX( c3s ); ) + stbIF4(stbir__simdfX c4 = stbir__simdf_frepX( c4s ); ) + stbIF5(stbir__simdfX c5 = stbir__simdf_frepX( c5s ); ) + stbIF6(stbir__simdfX c6 = stbir__simdf_frepX( c6s ); ) + stbIF7(stbir__simdfX c7 = stbir__simdf_frepX( c7s ); ) + + STBIR_SIMD_NO_UNROLL_LOOP_START + while ( ( (char*)input0_end - (char*) input0 ) >= (16*stbir__simdfX_float_count) ) + { + stbir__simdfX o0, o1, o2, o3, r0, r1, r2, r3; + STBIR_SIMD_NO_UNROLL(output); + + // prefetch four loop iterations ahead (doesn't affect much for small resizes, but helps with big ones) + stbIF0( stbir__prefetch( input0 + (16*stbir__simdfX_float_count) ); ) + stbIF1( stbir__prefetch( input1 + (16*stbir__simdfX_float_count) ); ) + stbIF2( stbir__prefetch( input2 + (16*stbir__simdfX_float_count) ); ) + stbIF3( stbir__prefetch( input3 + (16*stbir__simdfX_float_count) ); ) + stbIF4( stbir__prefetch( input4 + (16*stbir__simdfX_float_count) ); ) + stbIF5( stbir__prefetch( input5 + (16*stbir__simdfX_float_count) ); ) + stbIF6( stbir__prefetch( input6 + (16*stbir__simdfX_float_count) ); ) + stbIF7( stbir__prefetch( input7 + (16*stbir__simdfX_float_count) ); ) + + #ifdef STB_IMAGE_RESIZE_VERTICAL_CONTINUE + stbIF0( stbir__simdfX_load( o0, output ); stbir__simdfX_load( o1, output+stbir__simdfX_float_count ); stbir__simdfX_load( o2, output+(2*stbir__simdfX_float_count) ); stbir__simdfX_load( o3, output+(3*stbir__simdfX_float_count) ); + stbir__simdfX_load( r0, input0 ); stbir__simdfX_load( r1, input0+stbir__simdfX_float_count ); stbir__simdfX_load( r2, input0+(2*stbir__simdfX_float_count) ); stbir__simdfX_load( r3, input0+(3*stbir__simdfX_float_count) ); + stbir__simdfX_madd( o0, o0, r0, c0 ); stbir__simdfX_madd( o1, o1, r1, c0 ); stbir__simdfX_madd( o2, o2, r2, c0 ); stbir__simdfX_madd( o3, o3, r3, c0 ); ) + #else + stbIF0( stbir__simdfX_load( r0, input0 ); stbir__simdfX_load( r1, input0+stbir__simdfX_float_count ); stbir__simdfX_load( r2, input0+(2*stbir__simdfX_float_count) ); stbir__simdfX_load( r3, input0+(3*stbir__simdfX_float_count) ); + stbir__simdfX_mult( o0, r0, c0 ); stbir__simdfX_mult( o1, r1, c0 ); stbir__simdfX_mult( o2, r2, c0 ); stbir__simdfX_mult( o3, r3, c0 ); ) + #endif + + stbIF1( stbir__simdfX_load( r0, input1 ); stbir__simdfX_load( r1, input1+stbir__simdfX_float_count ); stbir__simdfX_load( r2, input1+(2*stbir__simdfX_float_count) ); stbir__simdfX_load( r3, input1+(3*stbir__simdfX_float_count) ); + stbir__simdfX_madd( o0, o0, r0, c1 ); stbir__simdfX_madd( o1, o1, r1, c1 ); stbir__simdfX_madd( o2, o2, r2, c1 ); stbir__simdfX_madd( o3, o3, r3, c1 ); ) + stbIF2( stbir__simdfX_load( r0, input2 ); stbir__simdfX_load( r1, input2+stbir__simdfX_float_count ); stbir__simdfX_load( r2, input2+(2*stbir__simdfX_float_count) ); stbir__simdfX_load( r3, input2+(3*stbir__simdfX_float_count) ); + stbir__simdfX_madd( o0, o0, r0, c2 ); stbir__simdfX_madd( o1, o1, r1, c2 ); stbir__simdfX_madd( o2, o2, r2, c2 ); stbir__simdfX_madd( o3, o3, r3, c2 ); ) + stbIF3( stbir__simdfX_load( r0, input3 ); stbir__simdfX_load( r1, input3+stbir__simdfX_float_count ); stbir__simdfX_load( r2, input3+(2*stbir__simdfX_float_count) ); stbir__simdfX_load( r3, input3+(3*stbir__simdfX_float_count) ); + stbir__simdfX_madd( o0, o0, r0, c3 ); stbir__simdfX_madd( o1, o1, r1, c3 ); stbir__simdfX_madd( o2, o2, r2, c3 ); stbir__simdfX_madd( o3, o3, r3, c3 ); ) + stbIF4( stbir__simdfX_load( r0, input4 ); stbir__simdfX_load( r1, input4+stbir__simdfX_float_count ); stbir__simdfX_load( r2, input4+(2*stbir__simdfX_float_count) ); stbir__simdfX_load( r3, input4+(3*stbir__simdfX_float_count) ); + stbir__simdfX_madd( o0, o0, r0, c4 ); stbir__simdfX_madd( o1, o1, r1, c4 ); stbir__simdfX_madd( o2, o2, r2, c4 ); stbir__simdfX_madd( o3, o3, r3, c4 ); ) + stbIF5( stbir__simdfX_load( r0, input5 ); stbir__simdfX_load( r1, input5+stbir__simdfX_float_count ); stbir__simdfX_load( r2, input5+(2*stbir__simdfX_float_count) ); stbir__simdfX_load( r3, input5+(3*stbir__simdfX_float_count) ); + stbir__simdfX_madd( o0, o0, r0, c5 ); stbir__simdfX_madd( o1, o1, r1, c5 ); stbir__simdfX_madd( o2, o2, r2, c5 ); stbir__simdfX_madd( o3, o3, r3, c5 ); ) + stbIF6( stbir__simdfX_load( r0, input6 ); stbir__simdfX_load( r1, input6+stbir__simdfX_float_count ); stbir__simdfX_load( r2, input6+(2*stbir__simdfX_float_count) ); stbir__simdfX_load( r3, input6+(3*stbir__simdfX_float_count) ); + stbir__simdfX_madd( o0, o0, r0, c6 ); stbir__simdfX_madd( o1, o1, r1, c6 ); stbir__simdfX_madd( o2, o2, r2, c6 ); stbir__simdfX_madd( o3, o3, r3, c6 ); ) + stbIF7( stbir__simdfX_load( r0, input7 ); stbir__simdfX_load( r1, input7+stbir__simdfX_float_count ); stbir__simdfX_load( r2, input7+(2*stbir__simdfX_float_count) ); stbir__simdfX_load( r3, input7+(3*stbir__simdfX_float_count) ); + stbir__simdfX_madd( o0, o0, r0, c7 ); stbir__simdfX_madd( o1, o1, r1, c7 ); stbir__simdfX_madd( o2, o2, r2, c7 ); stbir__simdfX_madd( o3, o3, r3, c7 ); ) + + stbir__simdfX_store( output, o0 ); stbir__simdfX_store( output+stbir__simdfX_float_count, o1 ); stbir__simdfX_store( output+(2*stbir__simdfX_float_count), o2 ); stbir__simdfX_store( output+(3*stbir__simdfX_float_count), o3 ); + output += (4*stbir__simdfX_float_count); + stbIF0( input0 += (4*stbir__simdfX_float_count); ) stbIF1( input1 += (4*stbir__simdfX_float_count); ) stbIF2( input2 += (4*stbir__simdfX_float_count); ) stbIF3( input3 += (4*stbir__simdfX_float_count); ) stbIF4( input4 += (4*stbir__simdfX_float_count); ) stbIF5( input5 += (4*stbir__simdfX_float_count); ) stbIF6( input6 += (4*stbir__simdfX_float_count); ) stbIF7( input7 += (4*stbir__simdfX_float_count); ) + } + + STBIR_SIMD_NO_UNROLL_LOOP_START + while ( ( (char*)input0_end - (char*) input0 ) >= 16 ) + { + stbir__simdf o0, r0; + STBIR_SIMD_NO_UNROLL(output); + + #ifdef STB_IMAGE_RESIZE_VERTICAL_CONTINUE + stbIF0( stbir__simdf_load( o0, output ); stbir__simdf_load( r0, input0 ); stbir__simdf_madd( o0, o0, r0, stbir__if_simdf8_cast_to_simdf4( c0 ) ); ) + #else + stbIF0( stbir__simdf_load( r0, input0 ); stbir__simdf_mult( o0, r0, stbir__if_simdf8_cast_to_simdf4( c0 ) ); ) + #endif + stbIF1( stbir__simdf_load( r0, input1 ); stbir__simdf_madd( o0, o0, r0, stbir__if_simdf8_cast_to_simdf4( c1 ) ); ) + stbIF2( stbir__simdf_load( r0, input2 ); stbir__simdf_madd( o0, o0, r0, stbir__if_simdf8_cast_to_simdf4( c2 ) ); ) + stbIF3( stbir__simdf_load( r0, input3 ); stbir__simdf_madd( o0, o0, r0, stbir__if_simdf8_cast_to_simdf4( c3 ) ); ) + stbIF4( stbir__simdf_load( r0, input4 ); stbir__simdf_madd( o0, o0, r0, stbir__if_simdf8_cast_to_simdf4( c4 ) ); ) + stbIF5( stbir__simdf_load( r0, input5 ); stbir__simdf_madd( o0, o0, r0, stbir__if_simdf8_cast_to_simdf4( c5 ) ); ) + stbIF6( stbir__simdf_load( r0, input6 ); stbir__simdf_madd( o0, o0, r0, stbir__if_simdf8_cast_to_simdf4( c6 ) ); ) + stbIF7( stbir__simdf_load( r0, input7 ); stbir__simdf_madd( o0, o0, r0, stbir__if_simdf8_cast_to_simdf4( c7 ) ); ) + + stbir__simdf_store( output, o0 ); + output += 4; + stbIF0( input0 += 4; ) stbIF1( input1 += 4; ) stbIF2( input2 += 4; ) stbIF3( input3 += 4; ) stbIF4( input4 += 4; ) stbIF5( input5 += 4; ) stbIF6( input6 += 4; ) stbIF7( input7 += 4; ) + } + } + #else + STBIR_NO_UNROLL_LOOP_START + while ( ( (char*)input0_end - (char*) input0 ) >= 16 ) + { + float o0, o1, o2, o3; + STBIR_NO_UNROLL(output); + #ifdef STB_IMAGE_RESIZE_VERTICAL_CONTINUE + stbIF0( o0 = output[0] + input0[0] * c0s; o1 = output[1] + input0[1] * c0s; o2 = output[2] + input0[2] * c0s; o3 = output[3] + input0[3] * c0s; ) + #else + stbIF0( o0 = input0[0] * c0s; o1 = input0[1] * c0s; o2 = input0[2] * c0s; o3 = input0[3] * c0s; ) + #endif + stbIF1( o0 += input1[0] * c1s; o1 += input1[1] * c1s; o2 += input1[2] * c1s; o3 += input1[3] * c1s; ) + stbIF2( o0 += input2[0] * c2s; o1 += input2[1] * c2s; o2 += input2[2] * c2s; o3 += input2[3] * c2s; ) + stbIF3( o0 += input3[0] * c3s; o1 += input3[1] * c3s; o2 += input3[2] * c3s; o3 += input3[3] * c3s; ) + stbIF4( o0 += input4[0] * c4s; o1 += input4[1] * c4s; o2 += input4[2] * c4s; o3 += input4[3] * c4s; ) + stbIF5( o0 += input5[0] * c5s; o1 += input5[1] * c5s; o2 += input5[2] * c5s; o3 += input5[3] * c5s; ) + stbIF6( o0 += input6[0] * c6s; o1 += input6[1] * c6s; o2 += input6[2] * c6s; o3 += input6[3] * c6s; ) + stbIF7( o0 += input7[0] * c7s; o1 += input7[1] * c7s; o2 += input7[2] * c7s; o3 += input7[3] * c7s; ) + output[0] = o0; output[1] = o1; output[2] = o2; output[3] = o3; + output += 4; + stbIF0( input0 += 4; ) stbIF1( input1 += 4; ) stbIF2( input2 += 4; ) stbIF3( input3 += 4; ) stbIF4( input4 += 4; ) stbIF5( input5 += 4; ) stbIF6( input6 += 4; ) stbIF7( input7 += 4; ) + } + #endif + STBIR_NO_UNROLL_LOOP_START + while ( input0 < input0_end ) + { + float o0; + STBIR_NO_UNROLL(output); + #ifdef STB_IMAGE_RESIZE_VERTICAL_CONTINUE + stbIF0( o0 = output[0] + input0[0] * c0s; ) + #else + stbIF0( o0 = input0[0] * c0s; ) + #endif + stbIF1( o0 += input1[0] * c1s; ) + stbIF2( o0 += input2[0] * c2s; ) + stbIF3( o0 += input3[0] * c3s; ) + stbIF4( o0 += input4[0] * c4s; ) + stbIF5( o0 += input5[0] * c5s; ) + stbIF6( o0 += input6[0] * c6s; ) + stbIF7( o0 += input7[0] * c7s; ) + output[0] = o0; + ++output; + stbIF0( ++input0; ) stbIF1( ++input1; ) stbIF2( ++input2; ) stbIF3( ++input3; ) stbIF4( ++input4; ) stbIF5( ++input5; ) stbIF6( ++input6; ) stbIF7( ++input7; ) + } +} + +#undef stbIF0 +#undef stbIF1 +#undef stbIF2 +#undef stbIF3 +#undef stbIF4 +#undef stbIF5 +#undef stbIF6 +#undef stbIF7 +#undef STB_IMAGE_RESIZE_DO_VERTICALS +#undef STBIR__vertical_channels +#undef STB_IMAGE_RESIZE_DO_HORIZONTALS +#undef STBIR_strs_join24 +#undef STBIR_strs_join14 +#undef STBIR_chans +#ifdef STB_IMAGE_RESIZE_VERTICAL_CONTINUE +#undef STB_IMAGE_RESIZE_VERTICAL_CONTINUE +#endif + +#else // !STB_IMAGE_RESIZE_DO_VERTICALS + +#define STBIR_chans( start, end ) STBIR_strs_join1(start,STBIR__horizontal_channels,end) + +#ifndef stbir__2_coeff_only +#define stbir__2_coeff_only() \ + stbir__1_coeff_only(); \ + stbir__1_coeff_remnant(1); +#endif + +#ifndef stbir__2_coeff_remnant +#define stbir__2_coeff_remnant( ofs ) \ + stbir__1_coeff_remnant(ofs); \ + stbir__1_coeff_remnant((ofs)+1); +#endif + +#ifndef stbir__3_coeff_only +#define stbir__3_coeff_only() \ + stbir__2_coeff_only(); \ + stbir__1_coeff_remnant(2); +#endif + +#ifndef stbir__3_coeff_remnant +#define stbir__3_coeff_remnant( ofs ) \ + stbir__2_coeff_remnant(ofs); \ + stbir__1_coeff_remnant((ofs)+2); +#endif + +#ifndef stbir__3_coeff_setup +#define stbir__3_coeff_setup() +#endif + +#ifndef stbir__4_coeff_start +#define stbir__4_coeff_start() \ + stbir__2_coeff_only(); \ + stbir__2_coeff_remnant(2); +#endif + +#ifndef stbir__4_coeff_continue_from_4 +#define stbir__4_coeff_continue_from_4( ofs ) \ + stbir__2_coeff_remnant(ofs); \ + stbir__2_coeff_remnant((ofs)+2); +#endif + +#ifndef stbir__store_output_tiny +#define stbir__store_output_tiny stbir__store_output +#endif + +static void STBIR_chans( stbir__horizontal_gather_,_channels_with_1_coeff)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width ) +{ + float const * output_end = output_buffer + output_sub_size * STBIR__horizontal_channels; + float STBIR_SIMD_STREAMOUT_PTR( * ) output = output_buffer; + STBIR_SIMD_NO_UNROLL_LOOP_START + do { + float const * decode = decode_buffer + horizontal_contributors->n0 * STBIR__horizontal_channels; + float const * hc = horizontal_coefficients; + stbir__1_coeff_only(); + stbir__store_output_tiny(); + } while ( output < output_end ); +} + +static void STBIR_chans( stbir__horizontal_gather_,_channels_with_2_coeffs)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width ) +{ + float const * output_end = output_buffer + output_sub_size * STBIR__horizontal_channels; + float STBIR_SIMD_STREAMOUT_PTR( * ) output = output_buffer; + STBIR_SIMD_NO_UNROLL_LOOP_START + do { + float const * decode = decode_buffer + horizontal_contributors->n0 * STBIR__horizontal_channels; + float const * hc = horizontal_coefficients; + stbir__2_coeff_only(); + stbir__store_output_tiny(); + } while ( output < output_end ); +} + +static void STBIR_chans( stbir__horizontal_gather_,_channels_with_3_coeffs)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width ) +{ + float const * output_end = output_buffer + output_sub_size * STBIR__horizontal_channels; + float STBIR_SIMD_STREAMOUT_PTR( * ) output = output_buffer; + STBIR_SIMD_NO_UNROLL_LOOP_START + do { + float const * decode = decode_buffer + horizontal_contributors->n0 * STBIR__horizontal_channels; + float const * hc = horizontal_coefficients; + stbir__3_coeff_only(); + stbir__store_output_tiny(); + } while ( output < output_end ); +} + +static void STBIR_chans( stbir__horizontal_gather_,_channels_with_4_coeffs)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width ) +{ + float const * output_end = output_buffer + output_sub_size * STBIR__horizontal_channels; + float STBIR_SIMD_STREAMOUT_PTR( * ) output = output_buffer; + STBIR_SIMD_NO_UNROLL_LOOP_START + do { + float const * decode = decode_buffer + horizontal_contributors->n0 * STBIR__horizontal_channels; + float const * hc = horizontal_coefficients; + stbir__4_coeff_start(); + stbir__store_output(); + } while ( output < output_end ); +} + +static void STBIR_chans( stbir__horizontal_gather_,_channels_with_5_coeffs)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width ) +{ + float const * output_end = output_buffer + output_sub_size * STBIR__horizontal_channels; + float STBIR_SIMD_STREAMOUT_PTR( * ) output = output_buffer; + STBIR_SIMD_NO_UNROLL_LOOP_START + do { + float const * decode = decode_buffer + horizontal_contributors->n0 * STBIR__horizontal_channels; + float const * hc = horizontal_coefficients; + stbir__4_coeff_start(); + stbir__1_coeff_remnant(4); + stbir__store_output(); + } while ( output < output_end ); +} + +static void STBIR_chans( stbir__horizontal_gather_,_channels_with_6_coeffs)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width ) +{ + float const * output_end = output_buffer + output_sub_size * STBIR__horizontal_channels; + float STBIR_SIMD_STREAMOUT_PTR( * ) output = output_buffer; + STBIR_SIMD_NO_UNROLL_LOOP_START + do { + float const * decode = decode_buffer + horizontal_contributors->n0 * STBIR__horizontal_channels; + float const * hc = horizontal_coefficients; + stbir__4_coeff_start(); + stbir__2_coeff_remnant(4); + stbir__store_output(); + } while ( output < output_end ); +} + +static void STBIR_chans( stbir__horizontal_gather_,_channels_with_7_coeffs)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width ) +{ + float const * output_end = output_buffer + output_sub_size * STBIR__horizontal_channels; + float STBIR_SIMD_STREAMOUT_PTR( * ) output = output_buffer; + stbir__3_coeff_setup(); + STBIR_SIMD_NO_UNROLL_LOOP_START + do { + float const * decode = decode_buffer + horizontal_contributors->n0 * STBIR__horizontal_channels; + float const * hc = horizontal_coefficients; + + stbir__4_coeff_start(); + stbir__3_coeff_remnant(4); + stbir__store_output(); + } while ( output < output_end ); +} + +static void STBIR_chans( stbir__horizontal_gather_,_channels_with_8_coeffs)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width ) +{ + float const * output_end = output_buffer + output_sub_size * STBIR__horizontal_channels; + float STBIR_SIMD_STREAMOUT_PTR( * ) output = output_buffer; + STBIR_SIMD_NO_UNROLL_LOOP_START + do { + float const * decode = decode_buffer + horizontal_contributors->n0 * STBIR__horizontal_channels; + float const * hc = horizontal_coefficients; + stbir__4_coeff_start(); + stbir__4_coeff_continue_from_4(4); + stbir__store_output(); + } while ( output < output_end ); +} + +static void STBIR_chans( stbir__horizontal_gather_,_channels_with_9_coeffs)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width ) +{ + float const * output_end = output_buffer + output_sub_size * STBIR__horizontal_channels; + float STBIR_SIMD_STREAMOUT_PTR( * ) output = output_buffer; + STBIR_SIMD_NO_UNROLL_LOOP_START + do { + float const * decode = decode_buffer + horizontal_contributors->n0 * STBIR__horizontal_channels; + float const * hc = horizontal_coefficients; + stbir__4_coeff_start(); + stbir__4_coeff_continue_from_4(4); + stbir__1_coeff_remnant(8); + stbir__store_output(); + } while ( output < output_end ); +} + +static void STBIR_chans( stbir__horizontal_gather_,_channels_with_10_coeffs)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width ) +{ + float const * output_end = output_buffer + output_sub_size * STBIR__horizontal_channels; + float STBIR_SIMD_STREAMOUT_PTR( * ) output = output_buffer; + STBIR_SIMD_NO_UNROLL_LOOP_START + do { + float const * decode = decode_buffer + horizontal_contributors->n0 * STBIR__horizontal_channels; + float const * hc = horizontal_coefficients; + stbir__4_coeff_start(); + stbir__4_coeff_continue_from_4(4); + stbir__2_coeff_remnant(8); + stbir__store_output(); + } while ( output < output_end ); +} + +static void STBIR_chans( stbir__horizontal_gather_,_channels_with_11_coeffs)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width ) +{ + float const * output_end = output_buffer + output_sub_size * STBIR__horizontal_channels; + float STBIR_SIMD_STREAMOUT_PTR( * ) output = output_buffer; + stbir__3_coeff_setup(); + STBIR_SIMD_NO_UNROLL_LOOP_START + do { + float const * decode = decode_buffer + horizontal_contributors->n0 * STBIR__horizontal_channels; + float const * hc = horizontal_coefficients; + stbir__4_coeff_start(); + stbir__4_coeff_continue_from_4(4); + stbir__3_coeff_remnant(8); + stbir__store_output(); + } while ( output < output_end ); +} + +static void STBIR_chans( stbir__horizontal_gather_,_channels_with_12_coeffs)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width ) +{ + float const * output_end = output_buffer + output_sub_size * STBIR__horizontal_channels; + float STBIR_SIMD_STREAMOUT_PTR( * ) output = output_buffer; + STBIR_SIMD_NO_UNROLL_LOOP_START + do { + float const * decode = decode_buffer + horizontal_contributors->n0 * STBIR__horizontal_channels; + float const * hc = horizontal_coefficients; + stbir__4_coeff_start(); + stbir__4_coeff_continue_from_4(4); + stbir__4_coeff_continue_from_4(8); + stbir__store_output(); + } while ( output < output_end ); +} + +static void STBIR_chans( stbir__horizontal_gather_,_channels_with_n_coeffs_mod0 )( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width ) +{ + float const * output_end = output_buffer + output_sub_size * STBIR__horizontal_channels; + float STBIR_SIMD_STREAMOUT_PTR( * ) output = output_buffer; + STBIR_SIMD_NO_UNROLL_LOOP_START + do { + float const * decode = decode_buffer + horizontal_contributors->n0 * STBIR__horizontal_channels; + int n = ( ( horizontal_contributors->n1 - horizontal_contributors->n0 + 1 ) - 4 + 3 ) >> 2; + float const * hc = horizontal_coefficients; + + stbir__4_coeff_start(); + STBIR_SIMD_NO_UNROLL_LOOP_START + do { + hc += 4; + decode += STBIR__horizontal_channels * 4; + stbir__4_coeff_continue_from_4( 0 ); + --n; + } while ( n > 0 ); + stbir__store_output(); + } while ( output < output_end ); +} + +static void STBIR_chans( stbir__horizontal_gather_,_channels_with_n_coeffs_mod1 )( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width ) +{ + float const * output_end = output_buffer + output_sub_size * STBIR__horizontal_channels; + float STBIR_SIMD_STREAMOUT_PTR( * ) output = output_buffer; + STBIR_SIMD_NO_UNROLL_LOOP_START + do { + float const * decode = decode_buffer + horizontal_contributors->n0 * STBIR__horizontal_channels; + int n = ( ( horizontal_contributors->n1 - horizontal_contributors->n0 + 1 ) - 5 + 3 ) >> 2; + float const * hc = horizontal_coefficients; + + stbir__4_coeff_start(); + STBIR_SIMD_NO_UNROLL_LOOP_START + do { + hc += 4; + decode += STBIR__horizontal_channels * 4; + stbir__4_coeff_continue_from_4( 0 ); + --n; + } while ( n > 0 ); + stbir__1_coeff_remnant( 4 ); + stbir__store_output(); + } while ( output < output_end ); +} + +static void STBIR_chans( stbir__horizontal_gather_,_channels_with_n_coeffs_mod2 )( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width ) +{ + float const * output_end = output_buffer + output_sub_size * STBIR__horizontal_channels; + float STBIR_SIMD_STREAMOUT_PTR( * ) output = output_buffer; + STBIR_SIMD_NO_UNROLL_LOOP_START + do { + float const * decode = decode_buffer + horizontal_contributors->n0 * STBIR__horizontal_channels; + int n = ( ( horizontal_contributors->n1 - horizontal_contributors->n0 + 1 ) - 6 + 3 ) >> 2; + float const * hc = horizontal_coefficients; + + stbir__4_coeff_start(); + STBIR_SIMD_NO_UNROLL_LOOP_START + do { + hc += 4; + decode += STBIR__horizontal_channels * 4; + stbir__4_coeff_continue_from_4( 0 ); + --n; + } while ( n > 0 ); + stbir__2_coeff_remnant( 4 ); + + stbir__store_output(); + } while ( output < output_end ); +} + +static void STBIR_chans( stbir__horizontal_gather_,_channels_with_n_coeffs_mod3 )( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width ) +{ + float const * output_end = output_buffer + output_sub_size * STBIR__horizontal_channels; + float STBIR_SIMD_STREAMOUT_PTR( * ) output = output_buffer; + stbir__3_coeff_setup(); + STBIR_SIMD_NO_UNROLL_LOOP_START + do { + float const * decode = decode_buffer + horizontal_contributors->n0 * STBIR__horizontal_channels; + int n = ( ( horizontal_contributors->n1 - horizontal_contributors->n0 + 1 ) - 7 + 3 ) >> 2; + float const * hc = horizontal_coefficients; + + stbir__4_coeff_start(); + STBIR_SIMD_NO_UNROLL_LOOP_START + do { + hc += 4; + decode += STBIR__horizontal_channels * 4; + stbir__4_coeff_continue_from_4( 0 ); + --n; + } while ( n > 0 ); + stbir__3_coeff_remnant( 4 ); + + stbir__store_output(); + } while ( output < output_end ); +} + +static stbir__horizontal_gather_channels_func * STBIR_chans(stbir__horizontal_gather_,_channels_with_n_coeffs_funcs)[4]= +{ + STBIR_chans(stbir__horizontal_gather_,_channels_with_n_coeffs_mod0), + STBIR_chans(stbir__horizontal_gather_,_channels_with_n_coeffs_mod1), + STBIR_chans(stbir__horizontal_gather_,_channels_with_n_coeffs_mod2), + STBIR_chans(stbir__horizontal_gather_,_channels_with_n_coeffs_mod3), +}; + +static stbir__horizontal_gather_channels_func * STBIR_chans(stbir__horizontal_gather_,_channels_funcs)[12]= +{ + STBIR_chans(stbir__horizontal_gather_,_channels_with_1_coeff), + STBIR_chans(stbir__horizontal_gather_,_channels_with_2_coeffs), + STBIR_chans(stbir__horizontal_gather_,_channels_with_3_coeffs), + STBIR_chans(stbir__horizontal_gather_,_channels_with_4_coeffs), + STBIR_chans(stbir__horizontal_gather_,_channels_with_5_coeffs), + STBIR_chans(stbir__horizontal_gather_,_channels_with_6_coeffs), + STBIR_chans(stbir__horizontal_gather_,_channels_with_7_coeffs), + STBIR_chans(stbir__horizontal_gather_,_channels_with_8_coeffs), + STBIR_chans(stbir__horizontal_gather_,_channels_with_9_coeffs), + STBIR_chans(stbir__horizontal_gather_,_channels_with_10_coeffs), + STBIR_chans(stbir__horizontal_gather_,_channels_with_11_coeffs), + STBIR_chans(stbir__horizontal_gather_,_channels_with_12_coeffs), +}; + +#undef STBIR__horizontal_channels +#undef STB_IMAGE_RESIZE_DO_HORIZONTALS +#undef stbir__1_coeff_only +#undef stbir__1_coeff_remnant +#undef stbir__2_coeff_only +#undef stbir__2_coeff_remnant +#undef stbir__3_coeff_only +#undef stbir__3_coeff_remnant +#undef stbir__3_coeff_setup +#undef stbir__4_coeff_start +#undef stbir__4_coeff_continue_from_4 +#undef stbir__store_output +#undef stbir__store_output_tiny +#undef STBIR_chans + +#endif // HORIZONALS + +#undef STBIR_strs_join2 +#undef STBIR_strs_join1 + +#endif // STB_IMAGE_RESIZE_DO_HORIZONTALS/VERTICALS/CODERS + +/* +------------------------------------------------------------------------------ +This software is available under 2 licenses -- choose whichever you prefer. +------------------------------------------------------------------------------ +ALTERNATIVE A - MIT License +Copyright (c) 2017 Sean Barrett +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is furnished to do +so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +------------------------------------------------------------------------------ +ALTERNATIVE B - Public Domain (www.unlicense.org) +This is free and unencumbered software released into the public domain. +Anyone is free to copy, modify, publish, use, compile, sell, or distribute this +software, either in source code form or as a compiled binary, for any purpose, +commercial or non-commercial, and by any means. +In jurisdictions that recognize copyright laws, the author or authors of this +software dedicate any and all copyright interest in the software to the public +domain. We make this dedication for the benefit of the public at large and to +the detriment of our heirs and successors. We intend this dedication to be an +overt act of relinquishment in perpetuity of all present and future rights to +this software under copyright law. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN +ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +------------------------------------------------------------------------------ +*/ diff --git a/tests/data/c/stb/stb_image_write.h b/tests/data/c/stb/stb_image_write.h new file mode 100644 index 000000000..e4b32ed1b --- /dev/null +++ b/tests/data/c/stb/stb_image_write.h @@ -0,0 +1,1724 @@ +/* stb_image_write - v1.16 - public domain - http://nothings.org/stb + writes out PNG/BMP/TGA/JPEG/HDR images to C stdio - Sean Barrett 2010-2015 + no warranty implied; use at your own risk + + Before #including, + + #define STB_IMAGE_WRITE_IMPLEMENTATION + + in the file that you want to have the implementation. + + Will probably not work correctly with strict-aliasing optimizations. + +ABOUT: + + This header file is a library for writing images to C stdio or a callback. + + The PNG output is not optimal; it is 20-50% larger than the file + written by a decent optimizing implementation; though providing a custom + zlib compress function (see STBIW_ZLIB_COMPRESS) can mitigate that. + This library is designed for source code compactness and simplicity, + not optimal image file size or run-time performance. + +BUILDING: + + You can #define STBIW_ASSERT(x) before the #include to avoid using assert.h. + You can #define STBIW_MALLOC(), STBIW_REALLOC(), and STBIW_FREE() to replace + malloc,realloc,free. + You can #define STBIW_MEMMOVE() to replace memmove() + You can #define STBIW_ZLIB_COMPRESS to use a custom zlib-style compress function + for PNG compression (instead of the builtin one), it must have the following signature: + unsigned char * my_compress(unsigned char *data, int data_len, int *out_len, int quality); + The returned data will be freed with STBIW_FREE() (free() by default), + so it must be heap allocated with STBIW_MALLOC() (malloc() by default), + +UNICODE: + + If compiling for Windows and you wish to use Unicode filenames, compile + with + #define STBIW_WINDOWS_UTF8 + and pass utf8-encoded filenames. Call stbiw_convert_wchar_to_utf8 to convert + Windows wchar_t filenames to utf8. + +USAGE: + + There are five functions, one for each image file format: + + int stbi_write_png(char const *filename, int w, int h, int comp, const void *data, int stride_in_bytes); + int stbi_write_bmp(char const *filename, int w, int h, int comp, const void *data); + int stbi_write_tga(char const *filename, int w, int h, int comp, const void *data); + int stbi_write_jpg(char const *filename, int w, int h, int comp, const void *data, int quality); + int stbi_write_hdr(char const *filename, int w, int h, int comp, const float *data); + + void stbi_flip_vertically_on_write(int flag); // flag is non-zero to flip data vertically + + There are also five equivalent functions that use an arbitrary write function. You are + expected to open/close your file-equivalent before and after calling these: + + int stbi_write_png_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data, int stride_in_bytes); + int stbi_write_bmp_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data); + int stbi_write_tga_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data); + int stbi_write_hdr_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const float *data); + int stbi_write_jpg_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int quality); + + where the callback is: + void stbi_write_func(void *context, void *data, int size); + + You can configure it with these global variables: + int stbi_write_tga_with_rle; // defaults to true; set to 0 to disable RLE + int stbi_write_png_compression_level; // defaults to 8; set to higher for more compression + int stbi_write_force_png_filter; // defaults to -1; set to 0..5 to force a filter mode + + + You can define STBI_WRITE_NO_STDIO to disable the file variant of these + functions, so the library will not use stdio.h at all. However, this will + also disable HDR writing, because it requires stdio for formatted output. + + Each function returns 0 on failure and non-0 on success. + + The functions create an image file defined by the parameters. The image + is a rectangle of pixels stored from left-to-right, top-to-bottom. + Each pixel contains 'comp' channels of data stored interleaved with 8-bits + per channel, in the following order: 1=Y, 2=YA, 3=RGB, 4=RGBA. (Y is + monochrome color.) The rectangle is 'w' pixels wide and 'h' pixels tall. + The *data pointer points to the first byte of the top-left-most pixel. + For PNG, "stride_in_bytes" is the distance in bytes from the first byte of + a row of pixels to the first byte of the next row of pixels. + + PNG creates output files with the same number of components as the input. + The BMP format expands Y to RGB in the file format and does not + output alpha. + + PNG supports writing rectangles of data even when the bytes storing rows of + data are not consecutive in memory (e.g. sub-rectangles of a larger image), + by supplying the stride between the beginning of adjacent rows. The other + formats do not. (Thus you cannot write a native-format BMP through the BMP + writer, both because it is in BGR order and because it may have padding + at the end of the line.) + + PNG allows you to set the deflate compression level by setting the global + variable 'stbi_write_png_compression_level' (it defaults to 8). + + HDR expects linear float data. Since the format is always 32-bit rgb(e) + data, alpha (if provided) is discarded, and for monochrome data it is + replicated across all three channels. + + TGA supports RLE or non-RLE compressed data. To use non-RLE-compressed + data, set the global variable 'stbi_write_tga_with_rle' to 0. + + JPEG does ignore alpha channels in input data; quality is between 1 and 100. + Higher quality looks better but results in a bigger image. + JPEG baseline (no JPEG progressive). + +CREDITS: + + + Sean Barrett - PNG/BMP/TGA + Baldur Karlsson - HDR + Jean-Sebastien Guay - TGA monochrome + Tim Kelsey - misc enhancements + Alan Hickman - TGA RLE + Emmanuel Julien - initial file IO callback implementation + Jon Olick - original jo_jpeg.cpp code + Daniel Gibson - integrate JPEG, allow external zlib + Aarni Koskela - allow choosing PNG filter + + bugfixes: + github:Chribba + Guillaume Chereau + github:jry2 + github:romigrou + Sergio Gonzalez + Jonas Karlsson + Filip Wasil + Thatcher Ulrich + github:poppolopoppo + Patrick Boettcher + github:xeekworx + Cap Petschulat + Simon Rodriguez + Ivan Tikhonov + github:ignotion + Adam Schackart + Andrew Kensler + +LICENSE + + See end of file for license information. + +*/ + +#ifndef INCLUDE_STB_IMAGE_WRITE_H +#define INCLUDE_STB_IMAGE_WRITE_H + +#include + +// if STB_IMAGE_WRITE_STATIC causes problems, try defining STBIWDEF to 'inline' or 'static inline' +#ifndef STBIWDEF +#ifdef STB_IMAGE_WRITE_STATIC +#define STBIWDEF static +#else +#ifdef __cplusplus +#define STBIWDEF extern "C" +#else +#define STBIWDEF extern +#endif +#endif +#endif + +#ifndef STB_IMAGE_WRITE_STATIC // C++ forbids static forward declarations +STBIWDEF int stbi_write_tga_with_rle; +STBIWDEF int stbi_write_png_compression_level; +STBIWDEF int stbi_write_force_png_filter; +#endif + +#ifndef STBI_WRITE_NO_STDIO +STBIWDEF int stbi_write_png(char const *filename, int w, int h, int comp, const void *data, int stride_in_bytes); +STBIWDEF int stbi_write_bmp(char const *filename, int w, int h, int comp, const void *data); +STBIWDEF int stbi_write_tga(char const *filename, int w, int h, int comp, const void *data); +STBIWDEF int stbi_write_hdr(char const *filename, int w, int h, int comp, const float *data); +STBIWDEF int stbi_write_jpg(char const *filename, int x, int y, int comp, const void *data, int quality); + +#ifdef STBIW_WINDOWS_UTF8 +STBIWDEF int stbiw_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input); +#endif +#endif + +typedef void stbi_write_func(void *context, void *data, int size); + +STBIWDEF int stbi_write_png_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data, int stride_in_bytes); +STBIWDEF int stbi_write_bmp_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data); +STBIWDEF int stbi_write_tga_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data); +STBIWDEF int stbi_write_hdr_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const float *data); +STBIWDEF int stbi_write_jpg_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int quality); + +STBIWDEF void stbi_flip_vertically_on_write(int flip_boolean); + +#endif//INCLUDE_STB_IMAGE_WRITE_H + +#ifdef STB_IMAGE_WRITE_IMPLEMENTATION + +#ifdef _WIN32 + #ifndef _CRT_SECURE_NO_WARNINGS + #define _CRT_SECURE_NO_WARNINGS + #endif + #ifndef _CRT_NONSTDC_NO_DEPRECATE + #define _CRT_NONSTDC_NO_DEPRECATE + #endif +#endif + +#ifndef STBI_WRITE_NO_STDIO +#include +#endif // STBI_WRITE_NO_STDIO + +#include +#include +#include +#include + +#if defined(STBIW_MALLOC) && defined(STBIW_FREE) && (defined(STBIW_REALLOC) || defined(STBIW_REALLOC_SIZED)) +// ok +#elif !defined(STBIW_MALLOC) && !defined(STBIW_FREE) && !defined(STBIW_REALLOC) && !defined(STBIW_REALLOC_SIZED) +// ok +#else +#error "Must define all or none of STBIW_MALLOC, STBIW_FREE, and STBIW_REALLOC (or STBIW_REALLOC_SIZED)." +#endif + +#ifndef STBIW_MALLOC +#define STBIW_MALLOC(sz) malloc(sz) +#define STBIW_REALLOC(p,newsz) realloc(p,newsz) +#define STBIW_FREE(p) free(p) +#endif + +#ifndef STBIW_REALLOC_SIZED +#define STBIW_REALLOC_SIZED(p,oldsz,newsz) STBIW_REALLOC(p,newsz) +#endif + + +#ifndef STBIW_MEMMOVE +#define STBIW_MEMMOVE(a,b,sz) memmove(a,b,sz) +#endif + + +#ifndef STBIW_ASSERT +#include +#define STBIW_ASSERT(x) assert(x) +#endif + +#define STBIW_UCHAR(x) (unsigned char) ((x) & 0xff) + +#ifdef STB_IMAGE_WRITE_STATIC +static int stbi_write_png_compression_level = 8; +static int stbi_write_tga_with_rle = 1; +static int stbi_write_force_png_filter = -1; +#else +int stbi_write_png_compression_level = 8; +int stbi_write_tga_with_rle = 1; +int stbi_write_force_png_filter = -1; +#endif + +static int stbi__flip_vertically_on_write = 0; + +STBIWDEF void stbi_flip_vertically_on_write(int flag) +{ + stbi__flip_vertically_on_write = flag; +} + +typedef struct +{ + stbi_write_func *func; + void *context; + unsigned char buffer[64]; + int buf_used; +} stbi__write_context; + +// initialize a callback-based context +static void stbi__start_write_callbacks(stbi__write_context *s, stbi_write_func *c, void *context) +{ + s->func = c; + s->context = context; +} + +#ifndef STBI_WRITE_NO_STDIO + +static void stbi__stdio_write(void *context, void *data, int size) +{ + fwrite(data,1,size,(FILE*) context); +} + +#if defined(_WIN32) && defined(STBIW_WINDOWS_UTF8) +#ifdef __cplusplus +#define STBIW_EXTERN extern "C" +#else +#define STBIW_EXTERN extern +#endif +STBIW_EXTERN __declspec(dllimport) int __stdcall MultiByteToWideChar(unsigned int cp, unsigned long flags, const char *str, int cbmb, wchar_t *widestr, int cchwide); +STBIW_EXTERN __declspec(dllimport) int __stdcall WideCharToMultiByte(unsigned int cp, unsigned long flags, const wchar_t *widestr, int cchwide, char *str, int cbmb, const char *defchar, int *used_default); + +STBIWDEF int stbiw_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input) +{ + return WideCharToMultiByte(65001 /* UTF8 */, 0, input, -1, buffer, (int) bufferlen, NULL, NULL); +} +#endif + +static FILE *stbiw__fopen(char const *filename, char const *mode) +{ + FILE *f; +#if defined(_WIN32) && defined(STBIW_WINDOWS_UTF8) + wchar_t wMode[64]; + wchar_t wFilename[1024]; + if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, filename, -1, wFilename, sizeof(wFilename)/sizeof(*wFilename))) + return 0; + + if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, mode, -1, wMode, sizeof(wMode)/sizeof(*wMode))) + return 0; + +#if defined(_MSC_VER) && _MSC_VER >= 1400 + if (0 != _wfopen_s(&f, wFilename, wMode)) + f = 0; +#else + f = _wfopen(wFilename, wMode); +#endif + +#elif defined(_MSC_VER) && _MSC_VER >= 1400 + if (0 != fopen_s(&f, filename, mode)) + f=0; +#else + f = fopen(filename, mode); +#endif + return f; +} + +static int stbi__start_write_file(stbi__write_context *s, const char *filename) +{ + FILE *f = stbiw__fopen(filename, "wb"); + stbi__start_write_callbacks(s, stbi__stdio_write, (void *) f); + return f != NULL; +} + +static void stbi__end_write_file(stbi__write_context *s) +{ + fclose((FILE *)s->context); +} + +#endif // !STBI_WRITE_NO_STDIO + +typedef unsigned int stbiw_uint32; +typedef int stb_image_write_test[sizeof(stbiw_uint32)==4 ? 1 : -1]; + +static void stbiw__writefv(stbi__write_context *s, const char *fmt, va_list v) +{ + while (*fmt) { + switch (*fmt++) { + case ' ': break; + case '1': { unsigned char x = STBIW_UCHAR(va_arg(v, int)); + s->func(s->context,&x,1); + break; } + case '2': { int x = va_arg(v,int); + unsigned char b[2]; + b[0] = STBIW_UCHAR(x); + b[1] = STBIW_UCHAR(x>>8); + s->func(s->context,b,2); + break; } + case '4': { stbiw_uint32 x = va_arg(v,int); + unsigned char b[4]; + b[0]=STBIW_UCHAR(x); + b[1]=STBIW_UCHAR(x>>8); + b[2]=STBIW_UCHAR(x>>16); + b[3]=STBIW_UCHAR(x>>24); + s->func(s->context,b,4); + break; } + default: + STBIW_ASSERT(0); + return; + } + } +} + +static void stbiw__writef(stbi__write_context *s, const char *fmt, ...) +{ + va_list v; + va_start(v, fmt); + stbiw__writefv(s, fmt, v); + va_end(v); +} + +static void stbiw__write_flush(stbi__write_context *s) +{ + if (s->buf_used) { + s->func(s->context, &s->buffer, s->buf_used); + s->buf_used = 0; + } +} + +static void stbiw__putc(stbi__write_context *s, unsigned char c) +{ + s->func(s->context, &c, 1); +} + +static void stbiw__write1(stbi__write_context *s, unsigned char a) +{ + if ((size_t)s->buf_used + 1 > sizeof(s->buffer)) + stbiw__write_flush(s); + s->buffer[s->buf_used++] = a; +} + +static void stbiw__write3(stbi__write_context *s, unsigned char a, unsigned char b, unsigned char c) +{ + int n; + if ((size_t)s->buf_used + 3 > sizeof(s->buffer)) + stbiw__write_flush(s); + n = s->buf_used; + s->buf_used = n+3; + s->buffer[n+0] = a; + s->buffer[n+1] = b; + s->buffer[n+2] = c; +} + +static void stbiw__write_pixel(stbi__write_context *s, int rgb_dir, int comp, int write_alpha, int expand_mono, unsigned char *d) +{ + unsigned char bg[3] = { 255, 0, 255}, px[3]; + int k; + + if (write_alpha < 0) + stbiw__write1(s, d[comp - 1]); + + switch (comp) { + case 2: // 2 pixels = mono + alpha, alpha is written separately, so same as 1-channel case + case 1: + if (expand_mono) + stbiw__write3(s, d[0], d[0], d[0]); // monochrome bmp + else + stbiw__write1(s, d[0]); // monochrome TGA + break; + case 4: + if (!write_alpha) { + // composite against pink background + for (k = 0; k < 3; ++k) + px[k] = bg[k] + ((d[k] - bg[k]) * d[3]) / 255; + stbiw__write3(s, px[1 - rgb_dir], px[1], px[1 + rgb_dir]); + break; + } + /* FALLTHROUGH */ + case 3: + stbiw__write3(s, d[1 - rgb_dir], d[1], d[1 + rgb_dir]); + break; + } + if (write_alpha > 0) + stbiw__write1(s, d[comp - 1]); +} + +static void stbiw__write_pixels(stbi__write_context *s, int rgb_dir, int vdir, int x, int y, int comp, void *data, int write_alpha, int scanline_pad, int expand_mono) +{ + stbiw_uint32 zero = 0; + int i,j, j_end; + + if (y <= 0) + return; + + if (stbi__flip_vertically_on_write) + vdir *= -1; + + if (vdir < 0) { + j_end = -1; j = y-1; + } else { + j_end = y; j = 0; + } + + for (; j != j_end; j += vdir) { + for (i=0; i < x; ++i) { + unsigned char *d = (unsigned char *) data + (j*x+i)*comp; + stbiw__write_pixel(s, rgb_dir, comp, write_alpha, expand_mono, d); + } + stbiw__write_flush(s); + s->func(s->context, &zero, scanline_pad); + } +} + +static int stbiw__outfile(stbi__write_context *s, int rgb_dir, int vdir, int x, int y, int comp, int expand_mono, void *data, int alpha, int pad, const char *fmt, ...) +{ + if (y < 0 || x < 0) { + return 0; + } else { + va_list v; + va_start(v, fmt); + stbiw__writefv(s, fmt, v); + va_end(v); + stbiw__write_pixels(s,rgb_dir,vdir,x,y,comp,data,alpha,pad, expand_mono); + return 1; + } +} + +static int stbi_write_bmp_core(stbi__write_context *s, int x, int y, int comp, const void *data) +{ + if (comp != 4) { + // write RGB bitmap + int pad = (-x*3) & 3; + return stbiw__outfile(s,-1,-1,x,y,comp,1,(void *) data,0,pad, + "11 4 22 4" "4 44 22 444444", + 'B', 'M', 14+40+(x*3+pad)*y, 0,0, 14+40, // file header + 40, x,y, 1,24, 0,0,0,0,0,0); // bitmap header + } else { + // RGBA bitmaps need a v4 header + // use BI_BITFIELDS mode with 32bpp and alpha mask + // (straight BI_RGB with alpha mask doesn't work in most readers) + return stbiw__outfile(s,-1,-1,x,y,comp,1,(void *)data,1,0, + "11 4 22 4" "4 44 22 444444 4444 4 444 444 444 444", + 'B', 'M', 14+108+x*y*4, 0, 0, 14+108, // file header + 108, x,y, 1,32, 3,0,0,0,0,0, 0xff0000,0xff00,0xff,0xff000000u, 0, 0,0,0, 0,0,0, 0,0,0, 0,0,0); // bitmap V4 header + } +} + +STBIWDEF int stbi_write_bmp_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data) +{ + stbi__write_context s = { 0 }; + stbi__start_write_callbacks(&s, func, context); + return stbi_write_bmp_core(&s, x, y, comp, data); +} + +#ifndef STBI_WRITE_NO_STDIO +STBIWDEF int stbi_write_bmp(char const *filename, int x, int y, int comp, const void *data) +{ + stbi__write_context s = { 0 }; + if (stbi__start_write_file(&s,filename)) { + int r = stbi_write_bmp_core(&s, x, y, comp, data); + stbi__end_write_file(&s); + return r; + } else + return 0; +} +#endif //!STBI_WRITE_NO_STDIO + +static int stbi_write_tga_core(stbi__write_context *s, int x, int y, int comp, void *data) +{ + int has_alpha = (comp == 2 || comp == 4); + int colorbytes = has_alpha ? comp-1 : comp; + int format = colorbytes < 2 ? 3 : 2; // 3 color channels (RGB/RGBA) = 2, 1 color channel (Y/YA) = 3 + + if (y < 0 || x < 0) + return 0; + + if (!stbi_write_tga_with_rle) { + return stbiw__outfile(s, -1, -1, x, y, comp, 0, (void *) data, has_alpha, 0, + "111 221 2222 11", 0, 0, format, 0, 0, 0, 0, 0, x, y, (colorbytes + has_alpha) * 8, has_alpha * 8); + } else { + int i,j,k; + int jend, jdir; + + stbiw__writef(s, "111 221 2222 11", 0,0,format+8, 0,0,0, 0,0,x,y, (colorbytes + has_alpha) * 8, has_alpha * 8); + + if (stbi__flip_vertically_on_write) { + j = 0; + jend = y; + jdir = 1; + } else { + j = y-1; + jend = -1; + jdir = -1; + } + for (; j != jend; j += jdir) { + unsigned char *row = (unsigned char *) data + j * x * comp; + int len; + + for (i = 0; i < x; i += len) { + unsigned char *begin = row + i * comp; + int diff = 1; + len = 1; + + if (i < x - 1) { + ++len; + diff = memcmp(begin, row + (i + 1) * comp, comp); + if (diff) { + const unsigned char *prev = begin; + for (k = i + 2; k < x && len < 128; ++k) { + if (memcmp(prev, row + k * comp, comp)) { + prev += comp; + ++len; + } else { + --len; + break; + } + } + } else { + for (k = i + 2; k < x && len < 128; ++k) { + if (!memcmp(begin, row + k * comp, comp)) { + ++len; + } else { + break; + } + } + } + } + + if (diff) { + unsigned char header = STBIW_UCHAR(len - 1); + stbiw__write1(s, header); + for (k = 0; k < len; ++k) { + stbiw__write_pixel(s, -1, comp, has_alpha, 0, begin + k * comp); + } + } else { + unsigned char header = STBIW_UCHAR(len - 129); + stbiw__write1(s, header); + stbiw__write_pixel(s, -1, comp, has_alpha, 0, begin); + } + } + } + stbiw__write_flush(s); + } + return 1; +} + +STBIWDEF int stbi_write_tga_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data) +{ + stbi__write_context s = { 0 }; + stbi__start_write_callbacks(&s, func, context); + return stbi_write_tga_core(&s, x, y, comp, (void *) data); +} + +#ifndef STBI_WRITE_NO_STDIO +STBIWDEF int stbi_write_tga(char const *filename, int x, int y, int comp, const void *data) +{ + stbi__write_context s = { 0 }; + if (stbi__start_write_file(&s,filename)) { + int r = stbi_write_tga_core(&s, x, y, comp, (void *) data); + stbi__end_write_file(&s); + return r; + } else + return 0; +} +#endif + +// ************************************************************************************************* +// Radiance RGBE HDR writer +// by Baldur Karlsson + +#define stbiw__max(a, b) ((a) > (b) ? (a) : (b)) + +#ifndef STBI_WRITE_NO_STDIO + +static void stbiw__linear_to_rgbe(unsigned char *rgbe, float *linear) +{ + int exponent; + float maxcomp = stbiw__max(linear[0], stbiw__max(linear[1], linear[2])); + + if (maxcomp < 1e-32f) { + rgbe[0] = rgbe[1] = rgbe[2] = rgbe[3] = 0; + } else { + float normalize = (float) frexp(maxcomp, &exponent) * 256.0f/maxcomp; + + rgbe[0] = (unsigned char)(linear[0] * normalize); + rgbe[1] = (unsigned char)(linear[1] * normalize); + rgbe[2] = (unsigned char)(linear[2] * normalize); + rgbe[3] = (unsigned char)(exponent + 128); + } +} + +static void stbiw__write_run_data(stbi__write_context *s, int length, unsigned char databyte) +{ + unsigned char lengthbyte = STBIW_UCHAR(length+128); + STBIW_ASSERT(length+128 <= 255); + s->func(s->context, &lengthbyte, 1); + s->func(s->context, &databyte, 1); +} + +static void stbiw__write_dump_data(stbi__write_context *s, int length, unsigned char *data) +{ + unsigned char lengthbyte = STBIW_UCHAR(length); + STBIW_ASSERT(length <= 128); // inconsistent with spec but consistent with official code + s->func(s->context, &lengthbyte, 1); + s->func(s->context, data, length); +} + +static void stbiw__write_hdr_scanline(stbi__write_context *s, int width, int ncomp, unsigned char *scratch, float *scanline) +{ + unsigned char scanlineheader[4] = { 2, 2, 0, 0 }; + unsigned char rgbe[4]; + float linear[3]; + int x; + + scanlineheader[2] = (width&0xff00)>>8; + scanlineheader[3] = (width&0x00ff); + + /* skip RLE for images too small or large */ + if (width < 8 || width >= 32768) { + for (x=0; x < width; x++) { + switch (ncomp) { + case 4: /* fallthrough */ + case 3: linear[2] = scanline[x*ncomp + 2]; + linear[1] = scanline[x*ncomp + 1]; + linear[0] = scanline[x*ncomp + 0]; + break; + default: + linear[0] = linear[1] = linear[2] = scanline[x*ncomp + 0]; + break; + } + stbiw__linear_to_rgbe(rgbe, linear); + s->func(s->context, rgbe, 4); + } + } else { + int c,r; + /* encode into scratch buffer */ + for (x=0; x < width; x++) { + switch(ncomp) { + case 4: /* fallthrough */ + case 3: linear[2] = scanline[x*ncomp + 2]; + linear[1] = scanline[x*ncomp + 1]; + linear[0] = scanline[x*ncomp + 0]; + break; + default: + linear[0] = linear[1] = linear[2] = scanline[x*ncomp + 0]; + break; + } + stbiw__linear_to_rgbe(rgbe, linear); + scratch[x + width*0] = rgbe[0]; + scratch[x + width*1] = rgbe[1]; + scratch[x + width*2] = rgbe[2]; + scratch[x + width*3] = rgbe[3]; + } + + s->func(s->context, scanlineheader, 4); + + /* RLE each component separately */ + for (c=0; c < 4; c++) { + unsigned char *comp = &scratch[width*c]; + + x = 0; + while (x < width) { + // find first run + r = x; + while (r+2 < width) { + if (comp[r] == comp[r+1] && comp[r] == comp[r+2]) + break; + ++r; + } + if (r+2 >= width) + r = width; + // dump up to first run + while (x < r) { + int len = r-x; + if (len > 128) len = 128; + stbiw__write_dump_data(s, len, &comp[x]); + x += len; + } + // if there's a run, output it + if (r+2 < width) { // same test as what we break out of in search loop, so only true if we break'd + // find next byte after run + while (r < width && comp[r] == comp[x]) + ++r; + // output run up to r + while (x < r) { + int len = r-x; + if (len > 127) len = 127; + stbiw__write_run_data(s, len, comp[x]); + x += len; + } + } + } + } + } +} + +static int stbi_write_hdr_core(stbi__write_context *s, int x, int y, int comp, float *data) +{ + if (y <= 0 || x <= 0 || data == NULL) + return 0; + else { + // Each component is stored separately. Allocate scratch space for full output scanline. + unsigned char *scratch = (unsigned char *) STBIW_MALLOC(x*4); + int i, len; + char buffer[128]; + char header[] = "#?RADIANCE\n# Written by stb_image_write.h\nFORMAT=32-bit_rle_rgbe\n"; + s->func(s->context, header, sizeof(header)-1); + +#ifdef __STDC_LIB_EXT1__ + len = sprintf_s(buffer, sizeof(buffer), "EXPOSURE= 1.0000000000000\n\n-Y %d +X %d\n", y, x); +#else + len = sprintf(buffer, "EXPOSURE= 1.0000000000000\n\n-Y %d +X %d\n", y, x); +#endif + s->func(s->context, buffer, len); + + for(i=0; i < y; i++) + stbiw__write_hdr_scanline(s, x, comp, scratch, data + comp*x*(stbi__flip_vertically_on_write ? y-1-i : i)); + STBIW_FREE(scratch); + return 1; + } +} + +STBIWDEF int stbi_write_hdr_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const float *data) +{ + stbi__write_context s = { 0 }; + stbi__start_write_callbacks(&s, func, context); + return stbi_write_hdr_core(&s, x, y, comp, (float *) data); +} + +STBIWDEF int stbi_write_hdr(char const *filename, int x, int y, int comp, const float *data) +{ + stbi__write_context s = { 0 }; + if (stbi__start_write_file(&s,filename)) { + int r = stbi_write_hdr_core(&s, x, y, comp, (float *) data); + stbi__end_write_file(&s); + return r; + } else + return 0; +} +#endif // STBI_WRITE_NO_STDIO + + +////////////////////////////////////////////////////////////////////////////// +// +// PNG writer +// + +#ifndef STBIW_ZLIB_COMPRESS +// stretchy buffer; stbiw__sbpush() == vector<>::push_back() -- stbiw__sbcount() == vector<>::size() +#define stbiw__sbraw(a) ((int *) (void *) (a) - 2) +#define stbiw__sbm(a) stbiw__sbraw(a)[0] +#define stbiw__sbn(a) stbiw__sbraw(a)[1] + +#define stbiw__sbneedgrow(a,n) ((a)==0 || stbiw__sbn(a)+n >= stbiw__sbm(a)) +#define stbiw__sbmaybegrow(a,n) (stbiw__sbneedgrow(a,(n)) ? stbiw__sbgrow(a,n) : 0) +#define stbiw__sbgrow(a,n) stbiw__sbgrowf((void **) &(a), (n), sizeof(*(a))) + +#define stbiw__sbpush(a, v) (stbiw__sbmaybegrow(a,1), (a)[stbiw__sbn(a)++] = (v)) +#define stbiw__sbcount(a) ((a) ? stbiw__sbn(a) : 0) +#define stbiw__sbfree(a) ((a) ? STBIW_FREE(stbiw__sbraw(a)),0 : 0) + +static void *stbiw__sbgrowf(void **arr, int increment, int itemsize) +{ + int m = *arr ? 2*stbiw__sbm(*arr)+increment : increment+1; + void *p = STBIW_REALLOC_SIZED(*arr ? stbiw__sbraw(*arr) : 0, *arr ? (stbiw__sbm(*arr)*itemsize + sizeof(int)*2) : 0, itemsize * m + sizeof(int)*2); + STBIW_ASSERT(p); + if (p) { + if (!*arr) ((int *) p)[1] = 0; + *arr = (void *) ((int *) p + 2); + stbiw__sbm(*arr) = m; + } + return *arr; +} + +static unsigned char *stbiw__zlib_flushf(unsigned char *data, unsigned int *bitbuffer, int *bitcount) +{ + while (*bitcount >= 8) { + stbiw__sbpush(data, STBIW_UCHAR(*bitbuffer)); + *bitbuffer >>= 8; + *bitcount -= 8; + } + return data; +} + +static int stbiw__zlib_bitrev(int code, int codebits) +{ + int res=0; + while (codebits--) { + res = (res << 1) | (code & 1); + code >>= 1; + } + return res; +} + +static unsigned int stbiw__zlib_countm(unsigned char *a, unsigned char *b, int limit) +{ + int i; + for (i=0; i < limit && i < 258; ++i) + if (a[i] != b[i]) break; + return i; +} + +static unsigned int stbiw__zhash(unsigned char *data) +{ + stbiw_uint32 hash = data[0] + (data[1] << 8) + (data[2] << 16); + hash ^= hash << 3; + hash += hash >> 5; + hash ^= hash << 4; + hash += hash >> 17; + hash ^= hash << 25; + hash += hash >> 6; + return hash; +} + +#define stbiw__zlib_flush() (out = stbiw__zlib_flushf(out, &bitbuf, &bitcount)) +#define stbiw__zlib_add(code,codebits) \ + (bitbuf |= (code) << bitcount, bitcount += (codebits), stbiw__zlib_flush()) +#define stbiw__zlib_huffa(b,c) stbiw__zlib_add(stbiw__zlib_bitrev(b,c),c) +// default huffman tables +#define stbiw__zlib_huff1(n) stbiw__zlib_huffa(0x30 + (n), 8) +#define stbiw__zlib_huff2(n) stbiw__zlib_huffa(0x190 + (n)-144, 9) +#define stbiw__zlib_huff3(n) stbiw__zlib_huffa(0 + (n)-256,7) +#define stbiw__zlib_huff4(n) stbiw__zlib_huffa(0xc0 + (n)-280,8) +#define stbiw__zlib_huff(n) ((n) <= 143 ? stbiw__zlib_huff1(n) : (n) <= 255 ? stbiw__zlib_huff2(n) : (n) <= 279 ? stbiw__zlib_huff3(n) : stbiw__zlib_huff4(n)) +#define stbiw__zlib_huffb(n) ((n) <= 143 ? stbiw__zlib_huff1(n) : stbiw__zlib_huff2(n)) + +#define stbiw__ZHASH 16384 + +#endif // STBIW_ZLIB_COMPRESS + +STBIWDEF unsigned char * stbi_zlib_compress(unsigned char *data, int data_len, int *out_len, int quality) +{ +#ifdef STBIW_ZLIB_COMPRESS + // user provided a zlib compress implementation, use that + return STBIW_ZLIB_COMPRESS(data, data_len, out_len, quality); +#else // use builtin + static unsigned short lengthc[] = { 3,4,5,6,7,8,9,10,11,13,15,17,19,23,27,31,35,43,51,59,67,83,99,115,131,163,195,227,258, 259 }; + static unsigned char lengtheb[]= { 0,0,0,0,0,0,0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0 }; + static unsigned short distc[] = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577, 32768 }; + static unsigned char disteb[] = { 0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13 }; + unsigned int bitbuf=0; + int i,j, bitcount=0; + unsigned char *out = NULL; + unsigned char ***hash_table = (unsigned char***) STBIW_MALLOC(stbiw__ZHASH * sizeof(unsigned char**)); + if (hash_table == NULL) + return NULL; + if (quality < 5) quality = 5; + + stbiw__sbpush(out, 0x78); // DEFLATE 32K window + stbiw__sbpush(out, 0x5e); // FLEVEL = 1 + stbiw__zlib_add(1,1); // BFINAL = 1 + stbiw__zlib_add(1,2); // BTYPE = 1 -- fixed huffman + + for (i=0; i < stbiw__ZHASH; ++i) + hash_table[i] = NULL; + + i=0; + while (i < data_len-3) { + // hash next 3 bytes of data to be compressed + int h = stbiw__zhash(data+i)&(stbiw__ZHASH-1), best=3; + unsigned char *bestloc = 0; + unsigned char **hlist = hash_table[h]; + int n = stbiw__sbcount(hlist); + for (j=0; j < n; ++j) { + if (hlist[j]-data > i-32768) { // if entry lies within window + int d = stbiw__zlib_countm(hlist[j], data+i, data_len-i); + if (d >= best) { best=d; bestloc=hlist[j]; } + } + } + // when hash table entry is too long, delete half the entries + if (hash_table[h] && stbiw__sbn(hash_table[h]) == 2*quality) { + STBIW_MEMMOVE(hash_table[h], hash_table[h]+quality, sizeof(hash_table[h][0])*quality); + stbiw__sbn(hash_table[h]) = quality; + } + stbiw__sbpush(hash_table[h],data+i); + + if (bestloc) { + // "lazy matching" - check match at *next* byte, and if it's better, do cur byte as literal + h = stbiw__zhash(data+i+1)&(stbiw__ZHASH-1); + hlist = hash_table[h]; + n = stbiw__sbcount(hlist); + for (j=0; j < n; ++j) { + if (hlist[j]-data > i-32767) { + int e = stbiw__zlib_countm(hlist[j], data+i+1, data_len-i-1); + if (e > best) { // if next match is better, bail on current match + bestloc = NULL; + break; + } + } + } + } + + if (bestloc) { + int d = (int) (data+i - bestloc); // distance back + STBIW_ASSERT(d <= 32767 && best <= 258); + for (j=0; best > lengthc[j+1]-1; ++j); + stbiw__zlib_huff(j+257); + if (lengtheb[j]) stbiw__zlib_add(best - lengthc[j], lengtheb[j]); + for (j=0; d > distc[j+1]-1; ++j); + stbiw__zlib_add(stbiw__zlib_bitrev(j,5),5); + if (disteb[j]) stbiw__zlib_add(d - distc[j], disteb[j]); + i += best; + } else { + stbiw__zlib_huffb(data[i]); + ++i; + } + } + // write out final bytes + for (;i < data_len; ++i) + stbiw__zlib_huffb(data[i]); + stbiw__zlib_huff(256); // end of block + // pad with 0 bits to byte boundary + while (bitcount) + stbiw__zlib_add(0,1); + + for (i=0; i < stbiw__ZHASH; ++i) + (void) stbiw__sbfree(hash_table[i]); + STBIW_FREE(hash_table); + + // store uncompressed instead if compression was worse + if (stbiw__sbn(out) > data_len + 2 + ((data_len+32766)/32767)*5) { + stbiw__sbn(out) = 2; // truncate to DEFLATE 32K window and FLEVEL = 1 + for (j = 0; j < data_len;) { + int blocklen = data_len - j; + if (blocklen > 32767) blocklen = 32767; + stbiw__sbpush(out, data_len - j == blocklen); // BFINAL = ?, BTYPE = 0 -- no compression + stbiw__sbpush(out, STBIW_UCHAR(blocklen)); // LEN + stbiw__sbpush(out, STBIW_UCHAR(blocklen >> 8)); + stbiw__sbpush(out, STBIW_UCHAR(~blocklen)); // NLEN + stbiw__sbpush(out, STBIW_UCHAR(~blocklen >> 8)); + memcpy(out+stbiw__sbn(out), data+j, blocklen); + stbiw__sbn(out) += blocklen; + j += blocklen; + } + } + + { + // compute adler32 on input + unsigned int s1=1, s2=0; + int blocklen = (int) (data_len % 5552); + j=0; + while (j < data_len) { + for (i=0; i < blocklen; ++i) { s1 += data[j+i]; s2 += s1; } + s1 %= 65521; s2 %= 65521; + j += blocklen; + blocklen = 5552; + } + stbiw__sbpush(out, STBIW_UCHAR(s2 >> 8)); + stbiw__sbpush(out, STBIW_UCHAR(s2)); + stbiw__sbpush(out, STBIW_UCHAR(s1 >> 8)); + stbiw__sbpush(out, STBIW_UCHAR(s1)); + } + *out_len = stbiw__sbn(out); + // make returned pointer freeable + STBIW_MEMMOVE(stbiw__sbraw(out), out, *out_len); + return (unsigned char *) stbiw__sbraw(out); +#endif // STBIW_ZLIB_COMPRESS +} + +static unsigned int stbiw__crc32(unsigned char *buffer, int len) +{ +#ifdef STBIW_CRC32 + return STBIW_CRC32(buffer, len); +#else + static unsigned int crc_table[256] = + { + 0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3, + 0x0eDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988, 0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91, + 0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE, 0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7, + 0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC, 0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5, + 0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172, 0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B, + 0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940, 0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59, + 0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116, 0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F, + 0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924, 0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D, + 0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A, 0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433, + 0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818, 0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01, + 0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E, 0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457, + 0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA, 0xFCB9887C, 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65, + 0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2, 0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB, + 0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0, 0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9, + 0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086, 0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F, + 0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, 0x59B33D17, 0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD, + 0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A, 0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683, + 0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8, 0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1, + 0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE, 0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7, + 0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC, 0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5, + 0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252, 0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B, + 0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60, 0xDF60EFC3, 0xA867DF55, 0x316E8EEF, 0x4669BE79, + 0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236, 0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F, + 0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04, 0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D, + 0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A, 0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713, + 0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38, 0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21, + 0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E, 0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777, + 0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C, 0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45, + 0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2, 0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB, + 0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9, + 0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF, + 0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94, 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D + }; + + unsigned int crc = ~0u; + int i; + for (i=0; i < len; ++i) + crc = (crc >> 8) ^ crc_table[buffer[i] ^ (crc & 0xff)]; + return ~crc; +#endif +} + +#define stbiw__wpng4(o,a,b,c,d) ((o)[0]=STBIW_UCHAR(a),(o)[1]=STBIW_UCHAR(b),(o)[2]=STBIW_UCHAR(c),(o)[3]=STBIW_UCHAR(d),(o)+=4) +#define stbiw__wp32(data,v) stbiw__wpng4(data, (v)>>24,(v)>>16,(v)>>8,(v)); +#define stbiw__wptag(data,s) stbiw__wpng4(data, s[0],s[1],s[2],s[3]) + +static void stbiw__wpcrc(unsigned char **data, int len) +{ + unsigned int crc = stbiw__crc32(*data - len - 4, len+4); + stbiw__wp32(*data, crc); +} + +static unsigned char stbiw__paeth(int a, int b, int c) +{ + int p = a + b - c, pa = abs(p-a), pb = abs(p-b), pc = abs(p-c); + if (pa <= pb && pa <= pc) return STBIW_UCHAR(a); + if (pb <= pc) return STBIW_UCHAR(b); + return STBIW_UCHAR(c); +} + +// @OPTIMIZE: provide an option that always forces left-predict or paeth predict +static void stbiw__encode_png_line(unsigned char *pixels, int stride_bytes, int width, int height, int y, int n, int filter_type, signed char *line_buffer) +{ + static int mapping[] = { 0,1,2,3,4 }; + static int firstmap[] = { 0,1,0,5,6 }; + int *mymap = (y != 0) ? mapping : firstmap; + int i; + int type = mymap[filter_type]; + unsigned char *z = pixels + stride_bytes * (stbi__flip_vertically_on_write ? height-1-y : y); + int signed_stride = stbi__flip_vertically_on_write ? -stride_bytes : stride_bytes; + + if (type==0) { + memcpy(line_buffer, z, width*n); + return; + } + + // first loop isn't optimized since it's just one pixel + for (i = 0; i < n; ++i) { + switch (type) { + case 1: line_buffer[i] = z[i]; break; + case 2: line_buffer[i] = z[i] - z[i-signed_stride]; break; + case 3: line_buffer[i] = z[i] - (z[i-signed_stride]>>1); break; + case 4: line_buffer[i] = (signed char) (z[i] - stbiw__paeth(0,z[i-signed_stride],0)); break; + case 5: line_buffer[i] = z[i]; break; + case 6: line_buffer[i] = z[i]; break; + } + } + switch (type) { + case 1: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - z[i-n]; break; + case 2: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - z[i-signed_stride]; break; + case 3: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - ((z[i-n] + z[i-signed_stride])>>1); break; + case 4: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - stbiw__paeth(z[i-n], z[i-signed_stride], z[i-signed_stride-n]); break; + case 5: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - (z[i-n]>>1); break; + case 6: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - stbiw__paeth(z[i-n], 0,0); break; + } +} + +STBIWDEF unsigned char *stbi_write_png_to_mem(const unsigned char *pixels, int stride_bytes, int x, int y, int n, int *out_len) +{ + int force_filter = stbi_write_force_png_filter; + int ctype[5] = { -1, 0, 4, 2, 6 }; + unsigned char sig[8] = { 137,80,78,71,13,10,26,10 }; + unsigned char *out,*o, *filt, *zlib; + signed char *line_buffer; + int j,zlen; + + if (stride_bytes == 0) + stride_bytes = x * n; + + if (force_filter >= 5) { + force_filter = -1; + } + + filt = (unsigned char *) STBIW_MALLOC((x*n+1) * y); if (!filt) return 0; + line_buffer = (signed char *) STBIW_MALLOC(x * n); if (!line_buffer) { STBIW_FREE(filt); return 0; } + for (j=0; j < y; ++j) { + int filter_type; + if (force_filter > -1) { + filter_type = force_filter; + stbiw__encode_png_line((unsigned char*)(pixels), stride_bytes, x, y, j, n, force_filter, line_buffer); + } else { // Estimate the best filter by running through all of them: + int best_filter = 0, best_filter_val = 0x7fffffff, est, i; + for (filter_type = 0; filter_type < 5; filter_type++) { + stbiw__encode_png_line((unsigned char*)(pixels), stride_bytes, x, y, j, n, filter_type, line_buffer); + + // Estimate the entropy of the line using this filter; the less, the better. + est = 0; + for (i = 0; i < x*n; ++i) { + est += abs((signed char) line_buffer[i]); + } + if (est < best_filter_val) { + best_filter_val = est; + best_filter = filter_type; + } + } + if (filter_type != best_filter) { // If the last iteration already got us the best filter, don't redo it + stbiw__encode_png_line((unsigned char*)(pixels), stride_bytes, x, y, j, n, best_filter, line_buffer); + filter_type = best_filter; + } + } + // when we get here, filter_type contains the filter type, and line_buffer contains the data + filt[j*(x*n+1)] = (unsigned char) filter_type; + STBIW_MEMMOVE(filt+j*(x*n+1)+1, line_buffer, x*n); + } + STBIW_FREE(line_buffer); + zlib = stbi_zlib_compress(filt, y*( x*n+1), &zlen, stbi_write_png_compression_level); + STBIW_FREE(filt); + if (!zlib) return 0; + + // each tag requires 12 bytes of overhead + out = (unsigned char *) STBIW_MALLOC(8 + 12+13 + 12+zlen + 12); + if (!out) return 0; + *out_len = 8 + 12+13 + 12+zlen + 12; + + o=out; + STBIW_MEMMOVE(o,sig,8); o+= 8; + stbiw__wp32(o, 13); // header length + stbiw__wptag(o, "IHDR"); + stbiw__wp32(o, x); + stbiw__wp32(o, y); + *o++ = 8; + *o++ = STBIW_UCHAR(ctype[n]); + *o++ = 0; + *o++ = 0; + *o++ = 0; + stbiw__wpcrc(&o,13); + + stbiw__wp32(o, zlen); + stbiw__wptag(o, "IDAT"); + STBIW_MEMMOVE(o, zlib, zlen); + o += zlen; + STBIW_FREE(zlib); + stbiw__wpcrc(&o, zlen); + + stbiw__wp32(o,0); + stbiw__wptag(o, "IEND"); + stbiw__wpcrc(&o,0); + + STBIW_ASSERT(o == out + *out_len); + + return out; +} + +#ifndef STBI_WRITE_NO_STDIO +STBIWDEF int stbi_write_png(char const *filename, int x, int y, int comp, const void *data, int stride_bytes) +{ + FILE *f; + int len; + unsigned char *png = stbi_write_png_to_mem((const unsigned char *) data, stride_bytes, x, y, comp, &len); + if (png == NULL) return 0; + + f = stbiw__fopen(filename, "wb"); + if (!f) { STBIW_FREE(png); return 0; } + fwrite(png, 1, len, f); + fclose(f); + STBIW_FREE(png); + return 1; +} +#endif + +STBIWDEF int stbi_write_png_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int stride_bytes) +{ + int len; + unsigned char *png = stbi_write_png_to_mem((const unsigned char *) data, stride_bytes, x, y, comp, &len); + if (png == NULL) return 0; + func(context, png, len); + STBIW_FREE(png); + return 1; +} + + +/* *************************************************************************** + * + * JPEG writer + * + * This is based on Jon Olick's jo_jpeg.cpp: + * public domain Simple, Minimalistic JPEG writer - http://www.jonolick.com/code.html + */ + +static const unsigned char stbiw__jpg_ZigZag[] = { 0,1,5,6,14,15,27,28,2,4,7,13,16,26,29,42,3,8,12,17,25,30,41,43,9,11,18, + 24,31,40,44,53,10,19,23,32,39,45,52,54,20,22,33,38,46,51,55,60,21,34,37,47,50,56,59,61,35,36,48,49,57,58,62,63 }; + +static void stbiw__jpg_writeBits(stbi__write_context *s, int *bitBufP, int *bitCntP, const unsigned short *bs) { + int bitBuf = *bitBufP, bitCnt = *bitCntP; + bitCnt += bs[1]; + bitBuf |= bs[0] << (24 - bitCnt); + while(bitCnt >= 8) { + unsigned char c = (bitBuf >> 16) & 255; + stbiw__putc(s, c); + if(c == 255) { + stbiw__putc(s, 0); + } + bitBuf <<= 8; + bitCnt -= 8; + } + *bitBufP = bitBuf; + *bitCntP = bitCnt; +} + +static void stbiw__jpg_DCT(float *d0p, float *d1p, float *d2p, float *d3p, float *d4p, float *d5p, float *d6p, float *d7p) { + float d0 = *d0p, d1 = *d1p, d2 = *d2p, d3 = *d3p, d4 = *d4p, d5 = *d5p, d6 = *d6p, d7 = *d7p; + float z1, z2, z3, z4, z5, z11, z13; + + float tmp0 = d0 + d7; + float tmp7 = d0 - d7; + float tmp1 = d1 + d6; + float tmp6 = d1 - d6; + float tmp2 = d2 + d5; + float tmp5 = d2 - d5; + float tmp3 = d3 + d4; + float tmp4 = d3 - d4; + + // Even part + float tmp10 = tmp0 + tmp3; // phase 2 + float tmp13 = tmp0 - tmp3; + float tmp11 = tmp1 + tmp2; + float tmp12 = tmp1 - tmp2; + + d0 = tmp10 + tmp11; // phase 3 + d4 = tmp10 - tmp11; + + z1 = (tmp12 + tmp13) * 0.707106781f; // c4 + d2 = tmp13 + z1; // phase 5 + d6 = tmp13 - z1; + + // Odd part + tmp10 = tmp4 + tmp5; // phase 2 + tmp11 = tmp5 + tmp6; + tmp12 = tmp6 + tmp7; + + // The rotator is modified from fig 4-8 to avoid extra negations. + z5 = (tmp10 - tmp12) * 0.382683433f; // c6 + z2 = tmp10 * 0.541196100f + z5; // c2-c6 + z4 = tmp12 * 1.306562965f + z5; // c2+c6 + z3 = tmp11 * 0.707106781f; // c4 + + z11 = tmp7 + z3; // phase 5 + z13 = tmp7 - z3; + + *d5p = z13 + z2; // phase 6 + *d3p = z13 - z2; + *d1p = z11 + z4; + *d7p = z11 - z4; + + *d0p = d0; *d2p = d2; *d4p = d4; *d6p = d6; +} + +static void stbiw__jpg_calcBits(int val, unsigned short bits[2]) { + int tmp1 = val < 0 ? -val : val; + val = val < 0 ? val-1 : val; + bits[1] = 1; + while(tmp1 >>= 1) { + ++bits[1]; + } + bits[0] = val & ((1<0)&&(DU[end0pos]==0); --end0pos) { + } + // end0pos = first element in reverse order !=0 + if(end0pos == 0) { + stbiw__jpg_writeBits(s, bitBuf, bitCnt, EOB); + return DU[0]; + } + for(i = 1; i <= end0pos; ++i) { + int startpos = i; + int nrzeroes; + unsigned short bits[2]; + for (; DU[i]==0 && i<=end0pos; ++i) { + } + nrzeroes = i-startpos; + if ( nrzeroes >= 16 ) { + int lng = nrzeroes>>4; + int nrmarker; + for (nrmarker=1; nrmarker <= lng; ++nrmarker) + stbiw__jpg_writeBits(s, bitBuf, bitCnt, M16zeroes); + nrzeroes &= 15; + } + stbiw__jpg_calcBits(DU[i], bits); + stbiw__jpg_writeBits(s, bitBuf, bitCnt, HTAC[(nrzeroes<<4)+bits[1]]); + stbiw__jpg_writeBits(s, bitBuf, bitCnt, bits); + } + if(end0pos != 63) { + stbiw__jpg_writeBits(s, bitBuf, bitCnt, EOB); + } + return DU[0]; +} + +static int stbi_write_jpg_core(stbi__write_context *s, int width, int height, int comp, const void* data, int quality) { + // Constants that don't pollute global namespace + static const unsigned char std_dc_luminance_nrcodes[] = {0,0,1,5,1,1,1,1,1,1,0,0,0,0,0,0,0}; + static const unsigned char std_dc_luminance_values[] = {0,1,2,3,4,5,6,7,8,9,10,11}; + static const unsigned char std_ac_luminance_nrcodes[] = {0,0,2,1,3,3,2,4,3,5,5,4,4,0,0,1,0x7d}; + static const unsigned char std_ac_luminance_values[] = { + 0x01,0x02,0x03,0x00,0x04,0x11,0x05,0x12,0x21,0x31,0x41,0x06,0x13,0x51,0x61,0x07,0x22,0x71,0x14,0x32,0x81,0x91,0xa1,0x08, + 0x23,0x42,0xb1,0xc1,0x15,0x52,0xd1,0xf0,0x24,0x33,0x62,0x72,0x82,0x09,0x0a,0x16,0x17,0x18,0x19,0x1a,0x25,0x26,0x27,0x28, + 0x29,0x2a,0x34,0x35,0x36,0x37,0x38,0x39,0x3a,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4a,0x53,0x54,0x55,0x56,0x57,0x58,0x59, + 0x5a,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6a,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7a,0x83,0x84,0x85,0x86,0x87,0x88,0x89, + 0x8a,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9a,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7,0xa8,0xa9,0xaa,0xb2,0xb3,0xb4,0xb5,0xb6, + 0xb7,0xb8,0xb9,0xba,0xc2,0xc3,0xc4,0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xd2,0xd3,0xd4,0xd5,0xd6,0xd7,0xd8,0xd9,0xda,0xe1,0xe2, + 0xe3,0xe4,0xe5,0xe6,0xe7,0xe8,0xe9,0xea,0xf1,0xf2,0xf3,0xf4,0xf5,0xf6,0xf7,0xf8,0xf9,0xfa + }; + static const unsigned char std_dc_chrominance_nrcodes[] = {0,0,3,1,1,1,1,1,1,1,1,1,0,0,0,0,0}; + static const unsigned char std_dc_chrominance_values[] = {0,1,2,3,4,5,6,7,8,9,10,11}; + static const unsigned char std_ac_chrominance_nrcodes[] = {0,0,2,1,2,4,4,3,4,7,5,4,4,0,1,2,0x77}; + static const unsigned char std_ac_chrominance_values[] = { + 0x00,0x01,0x02,0x03,0x11,0x04,0x05,0x21,0x31,0x06,0x12,0x41,0x51,0x07,0x61,0x71,0x13,0x22,0x32,0x81,0x08,0x14,0x42,0x91, + 0xa1,0xb1,0xc1,0x09,0x23,0x33,0x52,0xf0,0x15,0x62,0x72,0xd1,0x0a,0x16,0x24,0x34,0xe1,0x25,0xf1,0x17,0x18,0x19,0x1a,0x26, + 0x27,0x28,0x29,0x2a,0x35,0x36,0x37,0x38,0x39,0x3a,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4a,0x53,0x54,0x55,0x56,0x57,0x58, + 0x59,0x5a,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6a,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7a,0x82,0x83,0x84,0x85,0x86,0x87, + 0x88,0x89,0x8a,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9a,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7,0xa8,0xa9,0xaa,0xb2,0xb3,0xb4, + 0xb5,0xb6,0xb7,0xb8,0xb9,0xba,0xc2,0xc3,0xc4,0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xd2,0xd3,0xd4,0xd5,0xd6,0xd7,0xd8,0xd9,0xda, + 0xe2,0xe3,0xe4,0xe5,0xe6,0xe7,0xe8,0xe9,0xea,0xf2,0xf3,0xf4,0xf5,0xf6,0xf7,0xf8,0xf9,0xfa + }; + // Huffman tables + static const unsigned short YDC_HT[256][2] = { {0,2},{2,3},{3,3},{4,3},{5,3},{6,3},{14,4},{30,5},{62,6},{126,7},{254,8},{510,9}}; + static const unsigned short UVDC_HT[256][2] = { {0,2},{1,2},{2,2},{6,3},{14,4},{30,5},{62,6},{126,7},{254,8},{510,9},{1022,10},{2046,11}}; + static const unsigned short YAC_HT[256][2] = { + {10,4},{0,2},{1,2},{4,3},{11,4},{26,5},{120,7},{248,8},{1014,10},{65410,16},{65411,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {12,4},{27,5},{121,7},{502,9},{2038,11},{65412,16},{65413,16},{65414,16},{65415,16},{65416,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {28,5},{249,8},{1015,10},{4084,12},{65417,16},{65418,16},{65419,16},{65420,16},{65421,16},{65422,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {58,6},{503,9},{4085,12},{65423,16},{65424,16},{65425,16},{65426,16},{65427,16},{65428,16},{65429,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {59,6},{1016,10},{65430,16},{65431,16},{65432,16},{65433,16},{65434,16},{65435,16},{65436,16},{65437,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {122,7},{2039,11},{65438,16},{65439,16},{65440,16},{65441,16},{65442,16},{65443,16},{65444,16},{65445,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {123,7},{4086,12},{65446,16},{65447,16},{65448,16},{65449,16},{65450,16},{65451,16},{65452,16},{65453,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {250,8},{4087,12},{65454,16},{65455,16},{65456,16},{65457,16},{65458,16},{65459,16},{65460,16},{65461,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {504,9},{32704,15},{65462,16},{65463,16},{65464,16},{65465,16},{65466,16},{65467,16},{65468,16},{65469,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {505,9},{65470,16},{65471,16},{65472,16},{65473,16},{65474,16},{65475,16},{65476,16},{65477,16},{65478,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {506,9},{65479,16},{65480,16},{65481,16},{65482,16},{65483,16},{65484,16},{65485,16},{65486,16},{65487,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {1017,10},{65488,16},{65489,16},{65490,16},{65491,16},{65492,16},{65493,16},{65494,16},{65495,16},{65496,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {1018,10},{65497,16},{65498,16},{65499,16},{65500,16},{65501,16},{65502,16},{65503,16},{65504,16},{65505,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {2040,11},{65506,16},{65507,16},{65508,16},{65509,16},{65510,16},{65511,16},{65512,16},{65513,16},{65514,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {65515,16},{65516,16},{65517,16},{65518,16},{65519,16},{65520,16},{65521,16},{65522,16},{65523,16},{65524,16},{0,0},{0,0},{0,0},{0,0},{0,0}, + {2041,11},{65525,16},{65526,16},{65527,16},{65528,16},{65529,16},{65530,16},{65531,16},{65532,16},{65533,16},{65534,16},{0,0},{0,0},{0,0},{0,0},{0,0} + }; + static const unsigned short UVAC_HT[256][2] = { + {0,2},{1,2},{4,3},{10,4},{24,5},{25,5},{56,6},{120,7},{500,9},{1014,10},{4084,12},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {11,4},{57,6},{246,8},{501,9},{2038,11},{4085,12},{65416,16},{65417,16},{65418,16},{65419,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {26,5},{247,8},{1015,10},{4086,12},{32706,15},{65420,16},{65421,16},{65422,16},{65423,16},{65424,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {27,5},{248,8},{1016,10},{4087,12},{65425,16},{65426,16},{65427,16},{65428,16},{65429,16},{65430,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {58,6},{502,9},{65431,16},{65432,16},{65433,16},{65434,16},{65435,16},{65436,16},{65437,16},{65438,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {59,6},{1017,10},{65439,16},{65440,16},{65441,16},{65442,16},{65443,16},{65444,16},{65445,16},{65446,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {121,7},{2039,11},{65447,16},{65448,16},{65449,16},{65450,16},{65451,16},{65452,16},{65453,16},{65454,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {122,7},{2040,11},{65455,16},{65456,16},{65457,16},{65458,16},{65459,16},{65460,16},{65461,16},{65462,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {249,8},{65463,16},{65464,16},{65465,16},{65466,16},{65467,16},{65468,16},{65469,16},{65470,16},{65471,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {503,9},{65472,16},{65473,16},{65474,16},{65475,16},{65476,16},{65477,16},{65478,16},{65479,16},{65480,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {504,9},{65481,16},{65482,16},{65483,16},{65484,16},{65485,16},{65486,16},{65487,16},{65488,16},{65489,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {505,9},{65490,16},{65491,16},{65492,16},{65493,16},{65494,16},{65495,16},{65496,16},{65497,16},{65498,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {506,9},{65499,16},{65500,16},{65501,16},{65502,16},{65503,16},{65504,16},{65505,16},{65506,16},{65507,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {2041,11},{65508,16},{65509,16},{65510,16},{65511,16},{65512,16},{65513,16},{65514,16},{65515,16},{65516,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {16352,14},{65517,16},{65518,16},{65519,16},{65520,16},{65521,16},{65522,16},{65523,16},{65524,16},{65525,16},{0,0},{0,0},{0,0},{0,0},{0,0}, + {1018,10},{32707,15},{65526,16},{65527,16},{65528,16},{65529,16},{65530,16},{65531,16},{65532,16},{65533,16},{65534,16},{0,0},{0,0},{0,0},{0,0},{0,0} + }; + static const int YQT[] = {16,11,10,16,24,40,51,61,12,12,14,19,26,58,60,55,14,13,16,24,40,57,69,56,14,17,22,29,51,87,80,62,18,22, + 37,56,68,109,103,77,24,35,55,64,81,104,113,92,49,64,78,87,103,121,120,101,72,92,95,98,112,100,103,99}; + static const int UVQT[] = {17,18,24,47,99,99,99,99,18,21,26,66,99,99,99,99,24,26,56,99,99,99,99,99,47,66,99,99,99,99,99,99, + 99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99}; + static const float aasf[] = { 1.0f * 2.828427125f, 1.387039845f * 2.828427125f, 1.306562965f * 2.828427125f, 1.175875602f * 2.828427125f, + 1.0f * 2.828427125f, 0.785694958f * 2.828427125f, 0.541196100f * 2.828427125f, 0.275899379f * 2.828427125f }; + + int row, col, i, k, subsample; + float fdtbl_Y[64], fdtbl_UV[64]; + unsigned char YTable[64], UVTable[64]; + + if(!data || !width || !height || comp > 4 || comp < 1) { + return 0; + } + + quality = quality ? quality : 90; + subsample = quality <= 90 ? 1 : 0; + quality = quality < 1 ? 1 : quality > 100 ? 100 : quality; + quality = quality < 50 ? 5000 / quality : 200 - quality * 2; + + for(i = 0; i < 64; ++i) { + int uvti, yti = (YQT[i]*quality+50)/100; + YTable[stbiw__jpg_ZigZag[i]] = (unsigned char) (yti < 1 ? 1 : yti > 255 ? 255 : yti); + uvti = (UVQT[i]*quality+50)/100; + UVTable[stbiw__jpg_ZigZag[i]] = (unsigned char) (uvti < 1 ? 1 : uvti > 255 ? 255 : uvti); + } + + for(row = 0, k = 0; row < 8; ++row) { + for(col = 0; col < 8; ++col, ++k) { + fdtbl_Y[k] = 1 / (YTable [stbiw__jpg_ZigZag[k]] * aasf[row] * aasf[col]); + fdtbl_UV[k] = 1 / (UVTable[stbiw__jpg_ZigZag[k]] * aasf[row] * aasf[col]); + } + } + + // Write Headers + { + static const unsigned char head0[] = { 0xFF,0xD8,0xFF,0xE0,0,0x10,'J','F','I','F',0,1,1,0,0,1,0,1,0,0,0xFF,0xDB,0,0x84,0 }; + static const unsigned char head2[] = { 0xFF,0xDA,0,0xC,3,1,0,2,0x11,3,0x11,0,0x3F,0 }; + const unsigned char head1[] = { 0xFF,0xC0,0,0x11,8,(unsigned char)(height>>8),STBIW_UCHAR(height),(unsigned char)(width>>8),STBIW_UCHAR(width), + 3,1,(unsigned char)(subsample?0x22:0x11),0,2,0x11,1,3,0x11,1,0xFF,0xC4,0x01,0xA2,0 }; + s->func(s->context, (void*)head0, sizeof(head0)); + s->func(s->context, (void*)YTable, sizeof(YTable)); + stbiw__putc(s, 1); + s->func(s->context, UVTable, sizeof(UVTable)); + s->func(s->context, (void*)head1, sizeof(head1)); + s->func(s->context, (void*)(std_dc_luminance_nrcodes+1), sizeof(std_dc_luminance_nrcodes)-1); + s->func(s->context, (void*)std_dc_luminance_values, sizeof(std_dc_luminance_values)); + stbiw__putc(s, 0x10); // HTYACinfo + s->func(s->context, (void*)(std_ac_luminance_nrcodes+1), sizeof(std_ac_luminance_nrcodes)-1); + s->func(s->context, (void*)std_ac_luminance_values, sizeof(std_ac_luminance_values)); + stbiw__putc(s, 1); // HTUDCinfo + s->func(s->context, (void*)(std_dc_chrominance_nrcodes+1), sizeof(std_dc_chrominance_nrcodes)-1); + s->func(s->context, (void*)std_dc_chrominance_values, sizeof(std_dc_chrominance_values)); + stbiw__putc(s, 0x11); // HTUACinfo + s->func(s->context, (void*)(std_ac_chrominance_nrcodes+1), sizeof(std_ac_chrominance_nrcodes)-1); + s->func(s->context, (void*)std_ac_chrominance_values, sizeof(std_ac_chrominance_values)); + s->func(s->context, (void*)head2, sizeof(head2)); + } + + // Encode 8x8 macroblocks + { + static const unsigned short fillBits[] = {0x7F, 7}; + int DCY=0, DCU=0, DCV=0; + int bitBuf=0, bitCnt=0; + // comp == 2 is grey+alpha (alpha is ignored) + int ofsG = comp > 2 ? 1 : 0, ofsB = comp > 2 ? 2 : 0; + const unsigned char *dataR = (const unsigned char *)data; + const unsigned char *dataG = dataR + ofsG; + const unsigned char *dataB = dataR + ofsB; + int x, y, pos; + if(subsample) { + for(y = 0; y < height; y += 16) { + for(x = 0; x < width; x += 16) { + float Y[256], U[256], V[256]; + for(row = y, pos = 0; row < y+16; ++row) { + // row >= height => use last input row + int clamped_row = (row < height) ? row : height - 1; + int base_p = (stbi__flip_vertically_on_write ? (height-1-clamped_row) : clamped_row)*width*comp; + for(col = x; col < x+16; ++col, ++pos) { + // if col >= width => use pixel from last input column + int p = base_p + ((col < width) ? col : (width-1))*comp; + float r = dataR[p], g = dataG[p], b = dataB[p]; + Y[pos]= +0.29900f*r + 0.58700f*g + 0.11400f*b - 128; + U[pos]= -0.16874f*r - 0.33126f*g + 0.50000f*b; + V[pos]= +0.50000f*r - 0.41869f*g - 0.08131f*b; + } + } + DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y+0, 16, fdtbl_Y, DCY, YDC_HT, YAC_HT); + DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y+8, 16, fdtbl_Y, DCY, YDC_HT, YAC_HT); + DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y+128, 16, fdtbl_Y, DCY, YDC_HT, YAC_HT); + DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y+136, 16, fdtbl_Y, DCY, YDC_HT, YAC_HT); + + // subsample U,V + { + float subU[64], subV[64]; + int yy, xx; + for(yy = 0, pos = 0; yy < 8; ++yy) { + for(xx = 0; xx < 8; ++xx, ++pos) { + int j = yy*32+xx*2; + subU[pos] = (U[j+0] + U[j+1] + U[j+16] + U[j+17]) * 0.25f; + subV[pos] = (V[j+0] + V[j+1] + V[j+16] + V[j+17]) * 0.25f; + } + } + DCU = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, subU, 8, fdtbl_UV, DCU, UVDC_HT, UVAC_HT); + DCV = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, subV, 8, fdtbl_UV, DCV, UVDC_HT, UVAC_HT); + } + } + } + } else { + for(y = 0; y < height; y += 8) { + for(x = 0; x < width; x += 8) { + float Y[64], U[64], V[64]; + for(row = y, pos = 0; row < y+8; ++row) { + // row >= height => use last input row + int clamped_row = (row < height) ? row : height - 1; + int base_p = (stbi__flip_vertically_on_write ? (height-1-clamped_row) : clamped_row)*width*comp; + for(col = x; col < x+8; ++col, ++pos) { + // if col >= width => use pixel from last input column + int p = base_p + ((col < width) ? col : (width-1))*comp; + float r = dataR[p], g = dataG[p], b = dataB[p]; + Y[pos]= +0.29900f*r + 0.58700f*g + 0.11400f*b - 128; + U[pos]= -0.16874f*r - 0.33126f*g + 0.50000f*b; + V[pos]= +0.50000f*r - 0.41869f*g - 0.08131f*b; + } + } + + DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y, 8, fdtbl_Y, DCY, YDC_HT, YAC_HT); + DCU = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, U, 8, fdtbl_UV, DCU, UVDC_HT, UVAC_HT); + DCV = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, V, 8, fdtbl_UV, DCV, UVDC_HT, UVAC_HT); + } + } + } + + // Do the bit alignment of the EOI marker + stbiw__jpg_writeBits(s, &bitBuf, &bitCnt, fillBits); + } + + // EOI + stbiw__putc(s, 0xFF); + stbiw__putc(s, 0xD9); + + return 1; +} + +STBIWDEF int stbi_write_jpg_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int quality) +{ + stbi__write_context s = { 0 }; + stbi__start_write_callbacks(&s, func, context); + return stbi_write_jpg_core(&s, x, y, comp, (void *) data, quality); +} + + +#ifndef STBI_WRITE_NO_STDIO +STBIWDEF int stbi_write_jpg(char const *filename, int x, int y, int comp, const void *data, int quality) +{ + stbi__write_context s = { 0 }; + if (stbi__start_write_file(&s,filename)) { + int r = stbi_write_jpg_core(&s, x, y, comp, data, quality); + stbi__end_write_file(&s); + return r; + } else + return 0; +} +#endif + +#endif // STB_IMAGE_WRITE_IMPLEMENTATION + +/* Revision history + 1.16 (2021-07-11) + make Deflate code emit uncompressed blocks when it would otherwise expand + support writing BMPs with alpha channel + 1.15 (2020-07-13) unknown + 1.14 (2020-02-02) updated JPEG writer to downsample chroma channels + 1.13 + 1.12 + 1.11 (2019-08-11) + + 1.10 (2019-02-07) + support utf8 filenames in Windows; fix warnings and platform ifdefs + 1.09 (2018-02-11) + fix typo in zlib quality API, improve STB_I_W_STATIC in C++ + 1.08 (2018-01-29) + add stbi__flip_vertically_on_write, external zlib, zlib quality, choose PNG filter + 1.07 (2017-07-24) + doc fix + 1.06 (2017-07-23) + writing JPEG (using Jon Olick's code) + 1.05 ??? + 1.04 (2017-03-03) + monochrome BMP expansion + 1.03 ??? + 1.02 (2016-04-02) + avoid allocating large structures on the stack + 1.01 (2016-01-16) + STBIW_REALLOC_SIZED: support allocators with no realloc support + avoid race-condition in crc initialization + minor compile issues + 1.00 (2015-09-14) + installable file IO function + 0.99 (2015-09-13) + warning fixes; TGA rle support + 0.98 (2015-04-08) + added STBIW_MALLOC, STBIW_ASSERT etc + 0.97 (2015-01-18) + fixed HDR asserts, rewrote HDR rle logic + 0.96 (2015-01-17) + add HDR output + fix monochrome BMP + 0.95 (2014-08-17) + add monochrome TGA output + 0.94 (2014-05-31) + rename private functions to avoid conflicts with stb_image.h + 0.93 (2014-05-27) + warning fixes + 0.92 (2010-08-01) + casts to unsigned char to fix warnings + 0.91 (2010-07-17) + first public release + 0.90 first internal release +*/ + +/* +------------------------------------------------------------------------------ +This software is available under 2 licenses -- choose whichever you prefer. +------------------------------------------------------------------------------ +ALTERNATIVE A - MIT License +Copyright (c) 2017 Sean Barrett +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is furnished to do +so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +------------------------------------------------------------------------------ +ALTERNATIVE B - Public Domain (www.unlicense.org) +This is free and unencumbered software released into the public domain. +Anyone is free to copy, modify, publish, use, compile, sell, or distribute this +software, either in source code form or as a compiled binary, for any purpose, +commercial or non-commercial, and by any means. +In jurisdictions that recognize copyright laws, the author or authors of this +software dedicate any and all copyright interest in the software to the public +domain. We make this dedication for the benefit of the public at large and to +the detriment of our heirs and successors. We intend this dedication to be an +overt act of relinquishment in perpetuity of all present and future rights to +this software under copyright law. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN +ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +------------------------------------------------------------------------------ +*/ diff --git a/tests/data/c/stb/stb_include.h b/tests/data/c/stb/stb_include.h new file mode 100644 index 000000000..c5db20138 --- /dev/null +++ b/tests/data/c/stb/stb_include.h @@ -0,0 +1,295 @@ +// stb_include.h - v0.02 - parse and process #include directives - public domain +// +// To build this, in one source file that includes this file do +// #define STB_INCLUDE_IMPLEMENTATION +// +// This program parses a string and replaces lines of the form +// #include "foo" +// with the contents of a file named "foo". It also embeds the +// appropriate #line directives. Note that all include files must +// reside in the location specified in the path passed to the API; +// it does not check multiple directories. +// +// If the string contains a line of the form +// #inject +// then it will be replaced with the contents of the string 'inject' passed to the API. +// +// Options: +// +// Define STB_INCLUDE_LINE_GLSL to get GLSL-style #line directives +// which use numbers instead of filenames. +// +// Define STB_INCLUDE_LINE_NONE to disable output of #line directives. +// +// Standard libraries: +// +// stdio.h FILE, fopen, fclose, fseek, ftell +// stdlib.h malloc, realloc, free +// string.h strcpy, strncmp, memcpy +// +// Credits: +// +// Written by Sean Barrett. +// +// Fixes: +// Michal Klos + +#ifndef STB_INCLUDE_STB_INCLUDE_H +#define STB_INCLUDE_STB_INCLUDE_H + +// Do include-processing on the string 'str'. To free the return value, pass it to free() +char *stb_include_string(char *str, char *inject, char *path_to_includes, char *filename_for_line_directive, char error[256]); + +// Concatenate the strings 'strs' and do include-processing on the result. To free the return value, pass it to free() +char *stb_include_strings(char **strs, int count, char *inject, char *path_to_includes, char *filename_for_line_directive, char error[256]); + +// Load the file 'filename' and do include-processing on the string therein. note that +// 'filename' is opened directly; 'path_to_includes' is not used. To free the return value, pass it to free() +char *stb_include_file(char *filename, char *inject, char *path_to_includes, char error[256]); + +#endif + + +#ifdef STB_INCLUDE_IMPLEMENTATION + +#include +#include +#include + +static char *stb_include_load_file(char *filename, size_t *plen) +{ + char *text; + size_t len; + FILE *f = fopen(filename, "rb"); + if (f == 0) return 0; + fseek(f, 0, SEEK_END); + len = (size_t) ftell(f); + if (plen) *plen = len; + text = (char *) malloc(len+1); + if (text == 0) return 0; + fseek(f, 0, SEEK_SET); + fread(text, 1, len, f); + fclose(f); + text[len] = 0; + return text; +} + +typedef struct +{ + int offset; + int end; + char *filename; + int next_line_after; +} include_info; + +static include_info *stb_include_append_include(include_info *array, int len, int offset, int end, char *filename, int next_line) +{ + include_info *z = (include_info *) realloc(array, sizeof(*z) * (len+1)); + z[len].offset = offset; + z[len].end = end; + z[len].filename = filename; + z[len].next_line_after = next_line; + return z; +} + +static void stb_include_free_includes(include_info *array, int len) +{ + int i; + for (i=0; i < len; ++i) + free(array[i].filename); + free(array); +} + +static int stb_include_isspace(int ch) +{ + return (ch == ' ' || ch == '\t' || ch == '\r' || ch == '\n'); +} + +// find location of all #include and #inject +static int stb_include_find_includes(char *text, include_info **plist) +{ + int line_count = 1; + int inc_count = 0; + char *s = text, *start; + include_info *list = NULL; + while (*s) { + // parse is always at start of line when we reach here + start = s; + while (*s == ' ' || *s == '\t') + ++s; + if (*s == '#') { + ++s; + while (*s == ' ' || *s == '\t') + ++s; + if (0==strncmp(s, "include", 7) && stb_include_isspace(s[7])) { + s += 7; + while (*s == ' ' || *s == '\t') + ++s; + if (*s == '"') { + char *t = ++s; + while (*t != '"' && *t != '\n' && *t != '\r' && *t != 0) + ++t; + if (*t == '"') { + char *filename = (char *) malloc(t-s+1); + memcpy(filename, s, t-s); + filename[t-s] = 0; + s=t; + while (*s != '\r' && *s != '\n' && *s != 0) + ++s; + // s points to the newline, so s-start is everything except the newline + list = stb_include_append_include(list, inc_count++, start-text, s-text, filename, line_count+1); + } + } + } else if (0==strncmp(s, "inject", 6) && (stb_include_isspace(s[6]) || s[6]==0)) { + while (*s != '\r' && *s != '\n' && *s != 0) + ++s; + list = stb_include_append_include(list, inc_count++, start-text, s-text, NULL, line_count+1); + } + } + while (*s != '\r' && *s != '\n' && *s != 0) + ++s; + if (*s == '\r' || *s == '\n') { + s = s + (s[0] + s[1] == '\r' + '\n' ? 2 : 1); + } + ++line_count; + } + *plist = list; + return inc_count; +} + +// avoid dependency on sprintf() +static void stb_include_itoa(char str[9], int n) +{ + int i; + for (i=0; i < 8; ++i) + str[i] = ' '; + str[i] = 0; + + for (i=1; i < 8; ++i) { + str[7-i] = '0' + (n % 10); + n /= 10; + if (n == 0) + break; + } +} + +static char *stb_include_append(char *str, size_t *curlen, char *addstr, size_t addlen) +{ + str = (char *) realloc(str, *curlen + addlen); + memcpy(str + *curlen, addstr, addlen); + *curlen += addlen; + return str; +} + +char *stb_include_string(char *str, char *inject, char *path_to_includes, char *filename, char error[256]) +{ + char temp[4096]; + include_info *inc_list; + int i, num = stb_include_find_includes(str, &inc_list); + size_t source_len = strlen(str); + char *text=0; + size_t textlen=0, last=0; + for (i=0; i < num; ++i) { + text = stb_include_append(text, &textlen, str+last, inc_list[i].offset - last); + // write out line directive for the include + #ifndef STB_INCLUDE_LINE_NONE + #ifdef STB_INCLUDE_LINE_GLSL + if (textlen != 0) // GLSL #version must appear first, so don't put a #line at the top + #endif + { + strcpy(temp, "#line "); + stb_include_itoa(temp+6, 1); + strcat(temp, " "); + #ifdef STB_INCLUDE_LINE_GLSL + stb_include_itoa(temp+15, i+1); + #else + strcat(temp, "\""); + if (inc_list[i].filename == 0) + strcmp(temp, "INJECT"); + else + strcat(temp, inc_list[i].filename); + strcat(temp, "\""); + #endif + strcat(temp, "\n"); + text = stb_include_append(text, &textlen, temp, strlen(temp)); + } + #endif + if (inc_list[i].filename == 0) { + if (inject != 0) + text = stb_include_append(text, &textlen, inject, strlen(inject)); + } else { + char *inc; + strcpy(temp, path_to_includes); + strcat(temp, "/"); + strcat(temp, inc_list[i].filename); + inc = stb_include_file(temp, inject, path_to_includes, error); + if (inc == NULL) { + stb_include_free_includes(inc_list, num); + return NULL; + } + text = stb_include_append(text, &textlen, inc, strlen(inc)); + free(inc); + } + // write out line directive + #ifndef STB_INCLUDE_LINE_NONE + strcpy(temp, "\n#line "); + stb_include_itoa(temp+6, inc_list[i].next_line_after); + strcat(temp, " "); + #ifdef STB_INCLUDE_LINE_GLSL + stb_include_itoa(temp+15, 0); + #else + strcat(temp, filename != 0 ? filename : "source-file"); + #endif + text = stb_include_append(text, &textlen, temp, strlen(temp)); + // no newlines, because we kept the #include newlines, which will get appended next + #endif + last = inc_list[i].end; + } + text = stb_include_append(text, &textlen, str+last, source_len - last + 1); // append '\0' + stb_include_free_includes(inc_list, num); + return text; +} + +char *stb_include_strings(char **strs, int count, char *inject, char *path_to_includes, char *filename, char error[256]) +{ + char *text; + char *result; + int i; + size_t length=0; + for (i=0; i < count; ++i) + length += strlen(strs[i]); + text = (char *) malloc(length+1); + length = 0; + for (i=0; i < count; ++i) { + strcpy(text + length, strs[i]); + length += strlen(strs[i]); + } + result = stb_include_string(text, inject, path_to_includes, filename, error); + free(text); + return result; +} + +char *stb_include_file(char *filename, char *inject, char *path_to_includes, char error[256]) +{ + size_t len; + char *result; + char *text = stb_include_load_file(filename, &len); + if (text == NULL) { + strcpy(error, "Error: couldn't load '"); + strcat(error, filename); + strcat(error, "'"); + return 0; + } + result = stb_include_string(text, inject, path_to_includes, filename, error); + free(text); + return result; +} + +#if 0 // @TODO, GL_ARB_shader_language_include-style system that doesn't touch filesystem +char *stb_include_preloaded(char *str, char *inject, char *includes[][2], char error[256]) +{ + +} +#endif + +#endif // STB_INCLUDE_IMPLEMENTATION diff --git a/tests/data/c/stb/stb_leakcheck.h b/tests/data/c/stb/stb_leakcheck.h new file mode 100644 index 000000000..19ee6e7ea --- /dev/null +++ b/tests/data/c/stb/stb_leakcheck.h @@ -0,0 +1,194 @@ +// stb_leakcheck.h - v0.6 - quick & dirty malloc leak-checking - public domain +// LICENSE +// +// See end of file. + +#ifdef STB_LEAKCHECK_IMPLEMENTATION +#undef STB_LEAKCHECK_IMPLEMENTATION // don't implement more than once + +// if we've already included leakcheck before, undefine the macros +#ifdef malloc +#undef malloc +#undef free +#undef realloc +#endif + +#ifndef STB_LEAKCHECK_OUTPUT_PIPE +#define STB_LEAKCHECK_OUTPUT_PIPE stdout +#endif + +#include +#include +#include +#include +#include +typedef struct malloc_info stb_leakcheck_malloc_info; + +struct malloc_info +{ + const char *file; + int line; + size_t size; + stb_leakcheck_malloc_info *next,*prev; +}; + +static stb_leakcheck_malloc_info *mi_head; + +void *stb_leakcheck_malloc(size_t sz, const char *file, int line) +{ + stb_leakcheck_malloc_info *mi = (stb_leakcheck_malloc_info *) malloc(sz + sizeof(*mi)); + if (mi == NULL) return mi; + mi->file = file; + mi->line = line; + mi->next = mi_head; + if (mi_head) + mi->next->prev = mi; + mi->prev = NULL; + mi->size = (int) sz; + mi_head = mi; + return mi+1; +} + +void stb_leakcheck_free(void *ptr) +{ + if (ptr != NULL) { + stb_leakcheck_malloc_info *mi = (stb_leakcheck_malloc_info *) ptr - 1; + mi->size = ~mi->size; + #ifndef STB_LEAKCHECK_SHOWALL + if (mi->prev == NULL) { + assert(mi_head == mi); + mi_head = mi->next; + } else + mi->prev->next = mi->next; + if (mi->next) + mi->next->prev = mi->prev; + free(mi); + #endif + } +} + +void *stb_leakcheck_realloc(void *ptr, size_t sz, const char *file, int line) +{ + if (ptr == NULL) { + return stb_leakcheck_malloc(sz, file, line); + } else if (sz == 0) { + stb_leakcheck_free(ptr); + return NULL; + } else { + stb_leakcheck_malloc_info *mi = (stb_leakcheck_malloc_info *) ptr - 1; + if (sz <= mi->size) + return ptr; + else { + #ifdef STB_LEAKCHECK_REALLOC_PRESERVE_MALLOC_FILELINE + void *q = stb_leakcheck_malloc(sz, mi->file, mi->line); + #else + void *q = stb_leakcheck_malloc(sz, file, line); + #endif + if (q) { + memcpy(q, ptr, mi->size); + stb_leakcheck_free(ptr); + } + return q; + } + } +} + +static void stblkck_internal_print(const char *reason, stb_leakcheck_malloc_info *mi) +{ +#if defined(_MSC_VER) && _MSC_VER < 1900 // 1900=VS 2015 + // Compilers that use the old MS C runtime library don't have %zd + // and the older ones don't even have %lld either... however, the old compilers + // without "long long" don't support 64-bit targets either, so here's the + // compromise: + #if _MSC_VER < 1400 // before VS 2005 + fprintf(STB_LEAKCHECK_OUTPUT_PIPE, "%s: %s (%4d): %8d bytes at %p\n", reason, mi->file, mi->line, (int)mi->size, (void*)(mi+1)); + #else + fprintf(STB_LEAKCHECK_OUTPUT_PIPE, "%s: %s (%4d): %16lld bytes at %p\n", reason, mi->file, mi->line, (long long)mi->size, (void*)(mi+1)); + #endif +#else + // Assume we have %zd on other targets. + #ifdef __MINGW32__ + __mingw_fprintf(STB_LEAKCHECK_OUTPUT_PIPE, "%s: %s (%4d): %zd bytes at %p\n", reason, mi->file, mi->line, mi->size, (void*)(mi+1)); + #else + fprintf(STB_LEAKCHECK_OUTPUT_PIPE, "%s: %s (%4d): %zd bytes at %p\n", reason, mi->file, mi->line, mi->size, (void*)(mi+1)); + #endif +#endif +} + +void stb_leakcheck_dumpmem(void) +{ + stb_leakcheck_malloc_info *mi = mi_head; + while (mi) { + if ((ptrdiff_t) mi->size >= 0) + stblkck_internal_print("LEAKED", mi); + mi = mi->next; + } + #ifdef STB_LEAKCHECK_SHOWALL + mi = mi_head; + while (mi) { + if ((ptrdiff_t) mi->size < 0) + stblkck_internal_print("FREED ", mi); + mi = mi->next; + } + #endif +} +#endif // STB_LEAKCHECK_IMPLEMENTATION + +#if !defined(INCLUDE_STB_LEAKCHECK_H) || !defined(malloc) +#define INCLUDE_STB_LEAKCHECK_H + +#include // we want to define the macros *after* stdlib to avoid a slew of errors + +#define malloc(sz) stb_leakcheck_malloc(sz, __FILE__, __LINE__) +#define free(p) stb_leakcheck_free(p) +#define realloc(p,sz) stb_leakcheck_realloc(p,sz, __FILE__, __LINE__) + +extern void * stb_leakcheck_malloc(size_t sz, const char *file, int line); +extern void * stb_leakcheck_realloc(void *ptr, size_t sz, const char *file, int line); +extern void stb_leakcheck_free(void *ptr); +extern void stb_leakcheck_dumpmem(void); + +#endif // INCLUDE_STB_LEAKCHECK_H + + +/* +------------------------------------------------------------------------------ +This software is available under 2 licenses -- choose whichever you prefer. +------------------------------------------------------------------------------ +ALTERNATIVE A - MIT License +Copyright (c) 2017 Sean Barrett +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is furnished to do +so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +------------------------------------------------------------------------------ +ALTERNATIVE B - Public Domain (www.unlicense.org) +This is free and unencumbered software released into the public domain. +Anyone is free to copy, modify, publish, use, compile, sell, or distribute this +software, either in source code form or as a compiled binary, for any purpose, +commercial or non-commercial, and by any means. +In jurisdictions that recognize copyright laws, the author or authors of this +software dedicate any and all copyright interest in the software to the public +domain. We make this dedication for the benefit of the public at large and to +the detriment of our heirs and successors. We intend this dedication to be an +overt act of relinquishment in perpetuity of all present and future rights to +this software under copyright law. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN +ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +------------------------------------------------------------------------------ +*/ diff --git a/tests/data/c/stb/stb_perlin.h b/tests/data/c/stb/stb_perlin.h new file mode 100644 index 000000000..47cb9a437 --- /dev/null +++ b/tests/data/c/stb/stb_perlin.h @@ -0,0 +1,428 @@ +// stb_perlin.h - v0.5 - perlin noise +// public domain single-file C implementation by Sean Barrett +// +// LICENSE +// +// See end of file. +// +// +// to create the implementation, +// #define STB_PERLIN_IMPLEMENTATION +// in *one* C/CPP file that includes this file. +// +// +// Documentation: +// +// float stb_perlin_noise3( float x, +// float y, +// float z, +// int x_wrap=0, +// int y_wrap=0, +// int z_wrap=0) +// +// This function computes a random value at the coordinate (x,y,z). +// Adjacent random values are continuous but the noise fluctuates +// its randomness with period 1, i.e. takes on wholly unrelated values +// at integer points. Specifically, this implements Ken Perlin's +// revised noise function from 2002. +// +// The "wrap" parameters can be used to create wraparound noise that +// wraps at powers of two. The numbers MUST be powers of two. Specify +// 0 to mean "don't care". (The noise always wraps every 256 due +// details of the implementation, even if you ask for larger or no +// wrapping.) +// +// float stb_perlin_noise3_seed( float x, +// float y, +// float z, +// int x_wrap=0, +// int y_wrap=0, +// int z_wrap=0, +// int seed) +// +// As above, but 'seed' selects from multiple different variations of the +// noise function. The current implementation only uses the bottom 8 bits +// of 'seed', but possibly in the future more bits will be used. +// +// +// Fractal Noise: +// +// Three common fractal noise functions are included, which produce +// a wide variety of nice effects depending on the parameters +// provided. Note that each function will call stb_perlin_noise3 +// 'octaves' times, so this parameter will affect runtime. +// +// float stb_perlin_ridge_noise3(float x, float y, float z, +// float lacunarity, float gain, float offset, int octaves) +// +// float stb_perlin_fbm_noise3(float x, float y, float z, +// float lacunarity, float gain, int octaves) +// +// float stb_perlin_turbulence_noise3(float x, float y, float z, +// float lacunarity, float gain, int octaves) +// +// Typical values to start playing with: +// octaves = 6 -- number of "octaves" of noise3() to sum +// lacunarity = ~ 2.0 -- spacing between successive octaves (use exactly 2.0 for wrapping output) +// gain = 0.5 -- relative weighting applied to each successive octave +// offset = 1.0? -- used to invert the ridges, may need to be larger, not sure +// +// +// Contributors: +// Jack Mott - additional noise functions +// Jordan Peck - seeded noise +// + + +#ifdef __cplusplus +extern "C" { +#endif +extern float stb_perlin_noise3(float x, float y, float z, int x_wrap, int y_wrap, int z_wrap); +extern float stb_perlin_noise3_seed(float x, float y, float z, int x_wrap, int y_wrap, int z_wrap, int seed); +extern float stb_perlin_ridge_noise3(float x, float y, float z, float lacunarity, float gain, float offset, int octaves); +extern float stb_perlin_fbm_noise3(float x, float y, float z, float lacunarity, float gain, int octaves); +extern float stb_perlin_turbulence_noise3(float x, float y, float z, float lacunarity, float gain, int octaves); +extern float stb_perlin_noise3_wrap_nonpow2(float x, float y, float z, int x_wrap, int y_wrap, int z_wrap, unsigned char seed); +#ifdef __cplusplus +} +#endif + +#ifdef STB_PERLIN_IMPLEMENTATION + +#include // fabs() + +// not same permutation table as Perlin's reference to avoid copyright issues; +// Perlin's table can be found at http://mrl.nyu.edu/~perlin/noise/ +static unsigned char stb__perlin_randtab[512] = +{ + 23, 125, 161, 52, 103, 117, 70, 37, 247, 101, 203, 169, 124, 126, 44, 123, + 152, 238, 145, 45, 171, 114, 253, 10, 192, 136, 4, 157, 249, 30, 35, 72, + 175, 63, 77, 90, 181, 16, 96, 111, 133, 104, 75, 162, 93, 56, 66, 240, + 8, 50, 84, 229, 49, 210, 173, 239, 141, 1, 87, 18, 2, 198, 143, 57, + 225, 160, 58, 217, 168, 206, 245, 204, 199, 6, 73, 60, 20, 230, 211, 233, + 94, 200, 88, 9, 74, 155, 33, 15, 219, 130, 226, 202, 83, 236, 42, 172, + 165, 218, 55, 222, 46, 107, 98, 154, 109, 67, 196, 178, 127, 158, 13, 243, + 65, 79, 166, 248, 25, 224, 115, 80, 68, 51, 184, 128, 232, 208, 151, 122, + 26, 212, 105, 43, 179, 213, 235, 148, 146, 89, 14, 195, 28, 78, 112, 76, + 250, 47, 24, 251, 140, 108, 186, 190, 228, 170, 183, 139, 39, 188, 244, 246, + 132, 48, 119, 144, 180, 138, 134, 193, 82, 182, 120, 121, 86, 220, 209, 3, + 91, 241, 149, 85, 205, 150, 113, 216, 31, 100, 41, 164, 177, 214, 153, 231, + 38, 71, 185, 174, 97, 201, 29, 95, 7, 92, 54, 254, 191, 118, 34, 221, + 131, 11, 163, 99, 234, 81, 227, 147, 156, 176, 17, 142, 69, 12, 110, 62, + 27, 255, 0, 194, 59, 116, 242, 252, 19, 21, 187, 53, 207, 129, 64, 135, + 61, 40, 167, 237, 102, 223, 106, 159, 197, 189, 215, 137, 36, 32, 22, 5, + + // and a second copy so we don't need an extra mask or static initializer + 23, 125, 161, 52, 103, 117, 70, 37, 247, 101, 203, 169, 124, 126, 44, 123, + 152, 238, 145, 45, 171, 114, 253, 10, 192, 136, 4, 157, 249, 30, 35, 72, + 175, 63, 77, 90, 181, 16, 96, 111, 133, 104, 75, 162, 93, 56, 66, 240, + 8, 50, 84, 229, 49, 210, 173, 239, 141, 1, 87, 18, 2, 198, 143, 57, + 225, 160, 58, 217, 168, 206, 245, 204, 199, 6, 73, 60, 20, 230, 211, 233, + 94, 200, 88, 9, 74, 155, 33, 15, 219, 130, 226, 202, 83, 236, 42, 172, + 165, 218, 55, 222, 46, 107, 98, 154, 109, 67, 196, 178, 127, 158, 13, 243, + 65, 79, 166, 248, 25, 224, 115, 80, 68, 51, 184, 128, 232, 208, 151, 122, + 26, 212, 105, 43, 179, 213, 235, 148, 146, 89, 14, 195, 28, 78, 112, 76, + 250, 47, 24, 251, 140, 108, 186, 190, 228, 170, 183, 139, 39, 188, 244, 246, + 132, 48, 119, 144, 180, 138, 134, 193, 82, 182, 120, 121, 86, 220, 209, 3, + 91, 241, 149, 85, 205, 150, 113, 216, 31, 100, 41, 164, 177, 214, 153, 231, + 38, 71, 185, 174, 97, 201, 29, 95, 7, 92, 54, 254, 191, 118, 34, 221, + 131, 11, 163, 99, 234, 81, 227, 147, 156, 176, 17, 142, 69, 12, 110, 62, + 27, 255, 0, 194, 59, 116, 242, 252, 19, 21, 187, 53, 207, 129, 64, 135, + 61, 40, 167, 237, 102, 223, 106, 159, 197, 189, 215, 137, 36, 32, 22, 5, +}; + + +// perlin's gradient has 12 cases so some get used 1/16th of the time +// and some 2/16ths. We reduce bias by changing those fractions +// to 5/64ths and 6/64ths + +// this array is designed to match the previous implementation +// of gradient hash: indices[stb__perlin_randtab[i]&63] +static unsigned char stb__perlin_randtab_grad_idx[512] = +{ + 7, 9, 5, 0, 11, 1, 6, 9, 3, 9, 11, 1, 8, 10, 4, 7, + 8, 6, 1, 5, 3, 10, 9, 10, 0, 8, 4, 1, 5, 2, 7, 8, + 7, 11, 9, 10, 1, 0, 4, 7, 5, 0, 11, 6, 1, 4, 2, 8, + 8, 10, 4, 9, 9, 2, 5, 7, 9, 1, 7, 2, 2, 6, 11, 5, + 5, 4, 6, 9, 0, 1, 1, 0, 7, 6, 9, 8, 4, 10, 3, 1, + 2, 8, 8, 9, 10, 11, 5, 11, 11, 2, 6, 10, 3, 4, 2, 4, + 9, 10, 3, 2, 6, 3, 6, 10, 5, 3, 4, 10, 11, 2, 9, 11, + 1, 11, 10, 4, 9, 4, 11, 0, 4, 11, 4, 0, 0, 0, 7, 6, + 10, 4, 1, 3, 11, 5, 3, 4, 2, 9, 1, 3, 0, 1, 8, 0, + 6, 7, 8, 7, 0, 4, 6, 10, 8, 2, 3, 11, 11, 8, 0, 2, + 4, 8, 3, 0, 0, 10, 6, 1, 2, 2, 4, 5, 6, 0, 1, 3, + 11, 9, 5, 5, 9, 6, 9, 8, 3, 8, 1, 8, 9, 6, 9, 11, + 10, 7, 5, 6, 5, 9, 1, 3, 7, 0, 2, 10, 11, 2, 6, 1, + 3, 11, 7, 7, 2, 1, 7, 3, 0, 8, 1, 1, 5, 0, 6, 10, + 11, 11, 0, 2, 7, 0, 10, 8, 3, 5, 7, 1, 11, 1, 0, 7, + 9, 0, 11, 5, 10, 3, 2, 3, 5, 9, 7, 9, 8, 4, 6, 5, + + // and a second copy so we don't need an extra mask or static initializer + 7, 9, 5, 0, 11, 1, 6, 9, 3, 9, 11, 1, 8, 10, 4, 7, + 8, 6, 1, 5, 3, 10, 9, 10, 0, 8, 4, 1, 5, 2, 7, 8, + 7, 11, 9, 10, 1, 0, 4, 7, 5, 0, 11, 6, 1, 4, 2, 8, + 8, 10, 4, 9, 9, 2, 5, 7, 9, 1, 7, 2, 2, 6, 11, 5, + 5, 4, 6, 9, 0, 1, 1, 0, 7, 6, 9, 8, 4, 10, 3, 1, + 2, 8, 8, 9, 10, 11, 5, 11, 11, 2, 6, 10, 3, 4, 2, 4, + 9, 10, 3, 2, 6, 3, 6, 10, 5, 3, 4, 10, 11, 2, 9, 11, + 1, 11, 10, 4, 9, 4, 11, 0, 4, 11, 4, 0, 0, 0, 7, 6, + 10, 4, 1, 3, 11, 5, 3, 4, 2, 9, 1, 3, 0, 1, 8, 0, + 6, 7, 8, 7, 0, 4, 6, 10, 8, 2, 3, 11, 11, 8, 0, 2, + 4, 8, 3, 0, 0, 10, 6, 1, 2, 2, 4, 5, 6, 0, 1, 3, + 11, 9, 5, 5, 9, 6, 9, 8, 3, 8, 1, 8, 9, 6, 9, 11, + 10, 7, 5, 6, 5, 9, 1, 3, 7, 0, 2, 10, 11, 2, 6, 1, + 3, 11, 7, 7, 2, 1, 7, 3, 0, 8, 1, 1, 5, 0, 6, 10, + 11, 11, 0, 2, 7, 0, 10, 8, 3, 5, 7, 1, 11, 1, 0, 7, + 9, 0, 11, 5, 10, 3, 2, 3, 5, 9, 7, 9, 8, 4, 6, 5, +}; + +static float stb__perlin_lerp(float a, float b, float t) +{ + return a + (b-a) * t; +} + +static int stb__perlin_fastfloor(float a) +{ + int ai = (int) a; + return (a < ai) ? ai-1 : ai; +} + +// different grad function from Perlin's, but easy to modify to match reference +static float stb__perlin_grad(int grad_idx, float x, float y, float z) +{ + static float basis[12][4] = + { + { 1, 1, 0 }, + { -1, 1, 0 }, + { 1,-1, 0 }, + { -1,-1, 0 }, + { 1, 0, 1 }, + { -1, 0, 1 }, + { 1, 0,-1 }, + { -1, 0,-1 }, + { 0, 1, 1 }, + { 0,-1, 1 }, + { 0, 1,-1 }, + { 0,-1,-1 }, + }; + + float *grad = basis[grad_idx]; + return grad[0]*x + grad[1]*y + grad[2]*z; +} + +float stb_perlin_noise3_internal(float x, float y, float z, int x_wrap, int y_wrap, int z_wrap, unsigned char seed) +{ + float u,v,w; + float n000,n001,n010,n011,n100,n101,n110,n111; + float n00,n01,n10,n11; + float n0,n1; + + unsigned int x_mask = (x_wrap-1) & 255; + unsigned int y_mask = (y_wrap-1) & 255; + unsigned int z_mask = (z_wrap-1) & 255; + int px = stb__perlin_fastfloor(x); + int py = stb__perlin_fastfloor(y); + int pz = stb__perlin_fastfloor(z); + int x0 = px & x_mask, x1 = (px+1) & x_mask; + int y0 = py & y_mask, y1 = (py+1) & y_mask; + int z0 = pz & z_mask, z1 = (pz+1) & z_mask; + int r0,r1, r00,r01,r10,r11; + + #define stb__perlin_ease(a) (((a*6-15)*a + 10) * a * a * a) + + x -= px; u = stb__perlin_ease(x); + y -= py; v = stb__perlin_ease(y); + z -= pz; w = stb__perlin_ease(z); + + r0 = stb__perlin_randtab[x0+seed]; + r1 = stb__perlin_randtab[x1+seed]; + + r00 = stb__perlin_randtab[r0+y0]; + r01 = stb__perlin_randtab[r0+y1]; + r10 = stb__perlin_randtab[r1+y0]; + r11 = stb__perlin_randtab[r1+y1]; + + n000 = stb__perlin_grad(stb__perlin_randtab_grad_idx[r00+z0], x , y , z ); + n001 = stb__perlin_grad(stb__perlin_randtab_grad_idx[r00+z1], x , y , z-1 ); + n010 = stb__perlin_grad(stb__perlin_randtab_grad_idx[r01+z0], x , y-1, z ); + n011 = stb__perlin_grad(stb__perlin_randtab_grad_idx[r01+z1], x , y-1, z-1 ); + n100 = stb__perlin_grad(stb__perlin_randtab_grad_idx[r10+z0], x-1, y , z ); + n101 = stb__perlin_grad(stb__perlin_randtab_grad_idx[r10+z1], x-1, y , z-1 ); + n110 = stb__perlin_grad(stb__perlin_randtab_grad_idx[r11+z0], x-1, y-1, z ); + n111 = stb__perlin_grad(stb__perlin_randtab_grad_idx[r11+z1], x-1, y-1, z-1 ); + + n00 = stb__perlin_lerp(n000,n001,w); + n01 = stb__perlin_lerp(n010,n011,w); + n10 = stb__perlin_lerp(n100,n101,w); + n11 = stb__perlin_lerp(n110,n111,w); + + n0 = stb__perlin_lerp(n00,n01,v); + n1 = stb__perlin_lerp(n10,n11,v); + + return stb__perlin_lerp(n0,n1,u); +} + +float stb_perlin_noise3(float x, float y, float z, int x_wrap, int y_wrap, int z_wrap) +{ + return stb_perlin_noise3_internal(x,y,z,x_wrap,y_wrap,z_wrap,0); +} + +float stb_perlin_noise3_seed(float x, float y, float z, int x_wrap, int y_wrap, int z_wrap, int seed) +{ + return stb_perlin_noise3_internal(x,y,z,x_wrap,y_wrap,z_wrap, (unsigned char) seed); +} + +float stb_perlin_ridge_noise3(float x, float y, float z, float lacunarity, float gain, float offset, int octaves) +{ + int i; + float frequency = 1.0f; + float prev = 1.0f; + float amplitude = 0.5f; + float sum = 0.0f; + + for (i = 0; i < octaves; i++) { + float r = stb_perlin_noise3_internal(x*frequency,y*frequency,z*frequency,0,0,0,(unsigned char)i); + r = offset - (float) fabs(r); + r = r*r; + sum += r*amplitude*prev; + prev = r; + frequency *= lacunarity; + amplitude *= gain; + } + return sum; +} + +float stb_perlin_fbm_noise3(float x, float y, float z, float lacunarity, float gain, int octaves) +{ + int i; + float frequency = 1.0f; + float amplitude = 1.0f; + float sum = 0.0f; + + for (i = 0; i < octaves; i++) { + sum += stb_perlin_noise3_internal(x*frequency,y*frequency,z*frequency,0,0,0,(unsigned char)i)*amplitude; + frequency *= lacunarity; + amplitude *= gain; + } + return sum; +} + +float stb_perlin_turbulence_noise3(float x, float y, float z, float lacunarity, float gain, int octaves) +{ + int i; + float frequency = 1.0f; + float amplitude = 1.0f; + float sum = 0.0f; + + for (i = 0; i < octaves; i++) { + float r = stb_perlin_noise3_internal(x*frequency,y*frequency,z*frequency,0,0,0,(unsigned char)i)*amplitude; + sum += (float) fabs(r); + frequency *= lacunarity; + amplitude *= gain; + } + return sum; +} + +float stb_perlin_noise3_wrap_nonpow2(float x, float y, float z, int x_wrap, int y_wrap, int z_wrap, unsigned char seed) +{ + float u,v,w; + float n000,n001,n010,n011,n100,n101,n110,n111; + float n00,n01,n10,n11; + float n0,n1; + + int px = stb__perlin_fastfloor(x); + int py = stb__perlin_fastfloor(y); + int pz = stb__perlin_fastfloor(z); + int x_wrap2 = (x_wrap ? x_wrap : 256); + int y_wrap2 = (y_wrap ? y_wrap : 256); + int z_wrap2 = (z_wrap ? z_wrap : 256); + int x0 = px % x_wrap2, x1; + int y0 = py % y_wrap2, y1; + int z0 = pz % z_wrap2, z1; + int r0,r1, r00,r01,r10,r11; + + if (x0 < 0) x0 += x_wrap2; + if (y0 < 0) y0 += y_wrap2; + if (z0 < 0) z0 += z_wrap2; + x1 = (x0+1) % x_wrap2; + y1 = (y0+1) % y_wrap2; + z1 = (z0+1) % z_wrap2; + + #define stb__perlin_ease(a) (((a*6-15)*a + 10) * a * a * a) + + x -= px; u = stb__perlin_ease(x); + y -= py; v = stb__perlin_ease(y); + z -= pz; w = stb__perlin_ease(z); + + r0 = stb__perlin_randtab[x0]; + r0 = stb__perlin_randtab[r0+seed]; + r1 = stb__perlin_randtab[x1]; + r1 = stb__perlin_randtab[r1+seed]; + + r00 = stb__perlin_randtab[r0+y0]; + r01 = stb__perlin_randtab[r0+y1]; + r10 = stb__perlin_randtab[r1+y0]; + r11 = stb__perlin_randtab[r1+y1]; + + n000 = stb__perlin_grad(stb__perlin_randtab_grad_idx[r00+z0], x , y , z ); + n001 = stb__perlin_grad(stb__perlin_randtab_grad_idx[r00+z1], x , y , z-1 ); + n010 = stb__perlin_grad(stb__perlin_randtab_grad_idx[r01+z0], x , y-1, z ); + n011 = stb__perlin_grad(stb__perlin_randtab_grad_idx[r01+z1], x , y-1, z-1 ); + n100 = stb__perlin_grad(stb__perlin_randtab_grad_idx[r10+z0], x-1, y , z ); + n101 = stb__perlin_grad(stb__perlin_randtab_grad_idx[r10+z1], x-1, y , z-1 ); + n110 = stb__perlin_grad(stb__perlin_randtab_grad_idx[r11+z0], x-1, y-1, z ); + n111 = stb__perlin_grad(stb__perlin_randtab_grad_idx[r11+z1], x-1, y-1, z-1 ); + + n00 = stb__perlin_lerp(n000,n001,w); + n01 = stb__perlin_lerp(n010,n011,w); + n10 = stb__perlin_lerp(n100,n101,w); + n11 = stb__perlin_lerp(n110,n111,w); + + n0 = stb__perlin_lerp(n00,n01,v); + n1 = stb__perlin_lerp(n10,n11,v); + + return stb__perlin_lerp(n0,n1,u); +} +#endif // STB_PERLIN_IMPLEMENTATION + +/* +------------------------------------------------------------------------------ +This software is available under 2 licenses -- choose whichever you prefer. +------------------------------------------------------------------------------ +ALTERNATIVE A - MIT License +Copyright (c) 2017 Sean Barrett +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is furnished to do +so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +------------------------------------------------------------------------------ +ALTERNATIVE B - Public Domain (www.unlicense.org) +This is free and unencumbered software released into the public domain. +Anyone is free to copy, modify, publish, use, compile, sell, or distribute this +software, either in source code form or as a compiled binary, for any purpose, +commercial or non-commercial, and by any means. +In jurisdictions that recognize copyright laws, the author or authors of this +software dedicate any and all copyright interest in the software to the public +domain. We make this dedication for the benefit of the public at large and to +the detriment of our heirs and successors. We intend this dedication to be an +overt act of relinquishment in perpetuity of all present and future rights to +this software under copyright law. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN +ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +------------------------------------------------------------------------------ +*/ diff --git a/tests/data/c/stb/stb_rect_pack.h b/tests/data/c/stb/stb_rect_pack.h new file mode 100644 index 000000000..6a633ce66 --- /dev/null +++ b/tests/data/c/stb/stb_rect_pack.h @@ -0,0 +1,623 @@ +// stb_rect_pack.h - v1.01 - public domain - rectangle packing +// Sean Barrett 2014 +// +// Useful for e.g. packing rectangular textures into an atlas. +// Does not do rotation. +// +// Before #including, +// +// #define STB_RECT_PACK_IMPLEMENTATION +// +// in the file that you want to have the implementation. +// +// Not necessarily the awesomest packing method, but better than +// the totally naive one in stb_truetype (which is primarily what +// this is meant to replace). +// +// Has only had a few tests run, may have issues. +// +// More docs to come. +// +// No memory allocations; uses qsort() and assert() from stdlib. +// Can override those by defining STBRP_SORT and STBRP_ASSERT. +// +// This library currently uses the Skyline Bottom-Left algorithm. +// +// Please note: better rectangle packers are welcome! Please +// implement them to the same API, but with a different init +// function. +// +// Credits +// +// Library +// Sean Barrett +// Minor features +// Martins Mozeiko +// github:IntellectualKitty +// +// Bugfixes / warning fixes +// Jeremy Jaussaud +// Fabian Giesen +// +// Version history: +// +// 1.01 (2021-07-11) always use large rect mode, expose STBRP__MAXVAL in public section +// 1.00 (2019-02-25) avoid small space waste; gracefully fail too-wide rectangles +// 0.99 (2019-02-07) warning fixes +// 0.11 (2017-03-03) return packing success/fail result +// 0.10 (2016-10-25) remove cast-away-const to avoid warnings +// 0.09 (2016-08-27) fix compiler warnings +// 0.08 (2015-09-13) really fix bug with empty rects (w=0 or h=0) +// 0.07 (2015-09-13) fix bug with empty rects (w=0 or h=0) +// 0.06 (2015-04-15) added STBRP_SORT to allow replacing qsort +// 0.05: added STBRP_ASSERT to allow replacing assert +// 0.04: fixed minor bug in STBRP_LARGE_RECTS support +// 0.01: initial release +// +// LICENSE +// +// See end of file for license information. + +////////////////////////////////////////////////////////////////////////////// +// +// INCLUDE SECTION +// + +#ifndef STB_INCLUDE_STB_RECT_PACK_H +#define STB_INCLUDE_STB_RECT_PACK_H + +#define STB_RECT_PACK_VERSION 1 + +#ifdef STBRP_STATIC +#define STBRP_DEF static +#else +#define STBRP_DEF extern +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct stbrp_context stbrp_context; +typedef struct stbrp_node stbrp_node; +typedef struct stbrp_rect stbrp_rect; + +typedef int stbrp_coord; + +#define STBRP__MAXVAL 0x7fffffff +// Mostly for internal use, but this is the maximum supported coordinate value. + +STBRP_DEF int stbrp_pack_rects (stbrp_context *context, stbrp_rect *rects, int num_rects); +// Assign packed locations to rectangles. The rectangles are of type +// 'stbrp_rect' defined below, stored in the array 'rects', and there +// are 'num_rects' many of them. +// +// Rectangles which are successfully packed have the 'was_packed' flag +// set to a non-zero value and 'x' and 'y' store the minimum location +// on each axis (i.e. bottom-left in cartesian coordinates, top-left +// if you imagine y increasing downwards). Rectangles which do not fit +// have the 'was_packed' flag set to 0. +// +// You should not try to access the 'rects' array from another thread +// while this function is running, as the function temporarily reorders +// the array while it executes. +// +// To pack into another rectangle, you need to call stbrp_init_target +// again. To continue packing into the same rectangle, you can call +// this function again. Calling this multiple times with multiple rect +// arrays will probably produce worse packing results than calling it +// a single time with the full rectangle array, but the option is +// available. +// +// The function returns 1 if all of the rectangles were successfully +// packed and 0 otherwise. + +struct stbrp_rect +{ + // reserved for your use: + int id; + + // input: + stbrp_coord w, h; + + // output: + stbrp_coord x, y; + int was_packed; // non-zero if valid packing + +}; // 16 bytes, nominally + + +STBRP_DEF void stbrp_init_target (stbrp_context *context, int width, int height, stbrp_node *nodes, int num_nodes); +// Initialize a rectangle packer to: +// pack a rectangle that is 'width' by 'height' in dimensions +// using temporary storage provided by the array 'nodes', which is 'num_nodes' long +// +// You must call this function every time you start packing into a new target. +// +// There is no "shutdown" function. The 'nodes' memory must stay valid for +// the following stbrp_pack_rects() call (or calls), but can be freed after +// the call (or calls) finish. +// +// Note: to guarantee best results, either: +// 1. make sure 'num_nodes' >= 'width' +// or 2. call stbrp_allow_out_of_mem() defined below with 'allow_out_of_mem = 1' +// +// If you don't do either of the above things, widths will be quantized to multiples +// of small integers to guarantee the algorithm doesn't run out of temporary storage. +// +// If you do #2, then the non-quantized algorithm will be used, but the algorithm +// may run out of temporary storage and be unable to pack some rectangles. + +STBRP_DEF void stbrp_setup_allow_out_of_mem (stbrp_context *context, int allow_out_of_mem); +// Optionally call this function after init but before doing any packing to +// change the handling of the out-of-temp-memory scenario, described above. +// If you call init again, this will be reset to the default (false). + + +STBRP_DEF void stbrp_setup_heuristic (stbrp_context *context, int heuristic); +// Optionally select which packing heuristic the library should use. Different +// heuristics will produce better/worse results for different data sets. +// If you call init again, this will be reset to the default. + +enum +{ + STBRP_HEURISTIC_Skyline_default=0, + STBRP_HEURISTIC_Skyline_BL_sortHeight = STBRP_HEURISTIC_Skyline_default, + STBRP_HEURISTIC_Skyline_BF_sortHeight +}; + + +////////////////////////////////////////////////////////////////////////////// +// +// the details of the following structures don't matter to you, but they must +// be visible so you can handle the memory allocations for them + +struct stbrp_node +{ + stbrp_coord x,y; + stbrp_node *next; +}; + +struct stbrp_context +{ + int width; + int height; + int align; + int init_mode; + int heuristic; + int num_nodes; + stbrp_node *active_head; + stbrp_node *free_head; + stbrp_node extra[2]; // we allocate two extra nodes so optimal user-node-count is 'width' not 'width+2' +}; + +#ifdef __cplusplus +} +#endif + +#endif + +////////////////////////////////////////////////////////////////////////////// +// +// IMPLEMENTATION SECTION +// + +#ifdef STB_RECT_PACK_IMPLEMENTATION +#ifndef STBRP_SORT +#include +#define STBRP_SORT qsort +#endif + +#ifndef STBRP_ASSERT +#include +#define STBRP_ASSERT assert +#endif + +#ifdef _MSC_VER +#define STBRP__NOTUSED(v) (void)(v) +#define STBRP__CDECL __cdecl +#else +#define STBRP__NOTUSED(v) (void)sizeof(v) +#define STBRP__CDECL +#endif + +enum +{ + STBRP__INIT_skyline = 1 +}; + +STBRP_DEF void stbrp_setup_heuristic(stbrp_context *context, int heuristic) +{ + switch (context->init_mode) { + case STBRP__INIT_skyline: + STBRP_ASSERT(heuristic == STBRP_HEURISTIC_Skyline_BL_sortHeight || heuristic == STBRP_HEURISTIC_Skyline_BF_sortHeight); + context->heuristic = heuristic; + break; + default: + STBRP_ASSERT(0); + } +} + +STBRP_DEF void stbrp_setup_allow_out_of_mem(stbrp_context *context, int allow_out_of_mem) +{ + if (allow_out_of_mem) + // if it's ok to run out of memory, then don't bother aligning them; + // this gives better packing, but may fail due to OOM (even though + // the rectangles easily fit). @TODO a smarter approach would be to only + // quantize once we've hit OOM, then we could get rid of this parameter. + context->align = 1; + else { + // if it's not ok to run out of memory, then quantize the widths + // so that num_nodes is always enough nodes. + // + // I.e. num_nodes * align >= width + // align >= width / num_nodes + // align = ceil(width/num_nodes) + + context->align = (context->width + context->num_nodes-1) / context->num_nodes; + } +} + +STBRP_DEF void stbrp_init_target(stbrp_context *context, int width, int height, stbrp_node *nodes, int num_nodes) +{ + int i; + + for (i=0; i < num_nodes-1; ++i) + nodes[i].next = &nodes[i+1]; + nodes[i].next = NULL; + context->init_mode = STBRP__INIT_skyline; + context->heuristic = STBRP_HEURISTIC_Skyline_default; + context->free_head = &nodes[0]; + context->active_head = &context->extra[0]; + context->width = width; + context->height = height; + context->num_nodes = num_nodes; + stbrp_setup_allow_out_of_mem(context, 0); + + // node 0 is the full width, node 1 is the sentinel (lets us not store width explicitly) + context->extra[0].x = 0; + context->extra[0].y = 0; + context->extra[0].next = &context->extra[1]; + context->extra[1].x = (stbrp_coord) width; + context->extra[1].y = (1<<30); + context->extra[1].next = NULL; +} + +// find minimum y position if it starts at x1 +static int stbrp__skyline_find_min_y(stbrp_context *c, stbrp_node *first, int x0, int width, int *pwaste) +{ + stbrp_node *node = first; + int x1 = x0 + width; + int min_y, visited_width, waste_area; + + STBRP__NOTUSED(c); + + STBRP_ASSERT(first->x <= x0); + + #if 0 + // skip in case we're past the node + while (node->next->x <= x0) + ++node; + #else + STBRP_ASSERT(node->next->x > x0); // we ended up handling this in the caller for efficiency + #endif + + STBRP_ASSERT(node->x <= x0); + + min_y = 0; + waste_area = 0; + visited_width = 0; + while (node->x < x1) { + if (node->y > min_y) { + // raise min_y higher. + // we've accounted for all waste up to min_y, + // but we'll now add more waste for everything we've visted + waste_area += visited_width * (node->y - min_y); + min_y = node->y; + // the first time through, visited_width might be reduced + if (node->x < x0) + visited_width += node->next->x - x0; + else + visited_width += node->next->x - node->x; + } else { + // add waste area + int under_width = node->next->x - node->x; + if (under_width + visited_width > width) + under_width = width - visited_width; + waste_area += under_width * (min_y - node->y); + visited_width += under_width; + } + node = node->next; + } + + *pwaste = waste_area; + return min_y; +} + +typedef struct +{ + int x,y; + stbrp_node **prev_link; +} stbrp__findresult; + +static stbrp__findresult stbrp__skyline_find_best_pos(stbrp_context *c, int width, int height) +{ + int best_waste = (1<<30), best_x, best_y = (1 << 30); + stbrp__findresult fr; + stbrp_node **prev, *node, *tail, **best = NULL; + + // align to multiple of c->align + width = (width + c->align - 1); + width -= width % c->align; + STBRP_ASSERT(width % c->align == 0); + + // if it can't possibly fit, bail immediately + if (width > c->width || height > c->height) { + fr.prev_link = NULL; + fr.x = fr.y = 0; + return fr; + } + + node = c->active_head; + prev = &c->active_head; + while (node->x + width <= c->width) { + int y,waste; + y = stbrp__skyline_find_min_y(c, node, node->x, width, &waste); + if (c->heuristic == STBRP_HEURISTIC_Skyline_BL_sortHeight) { // actually just want to test BL + // bottom left + if (y < best_y) { + best_y = y; + best = prev; + } + } else { + // best-fit + if (y + height <= c->height) { + // can only use it if it first vertically + if (y < best_y || (y == best_y && waste < best_waste)) { + best_y = y; + best_waste = waste; + best = prev; + } + } + } + prev = &node->next; + node = node->next; + } + + best_x = (best == NULL) ? 0 : (*best)->x; + + // if doing best-fit (BF), we also have to try aligning right edge to each node position + // + // e.g, if fitting + // + // ____________________ + // |____________________| + // + // into + // + // | | + // | ____________| + // |____________| + // + // then right-aligned reduces waste, but bottom-left BL is always chooses left-aligned + // + // This makes BF take about 2x the time + + if (c->heuristic == STBRP_HEURISTIC_Skyline_BF_sortHeight) { + tail = c->active_head; + node = c->active_head; + prev = &c->active_head; + // find first node that's admissible + while (tail->x < width) + tail = tail->next; + while (tail) { + int xpos = tail->x - width; + int y,waste; + STBRP_ASSERT(xpos >= 0); + // find the left position that matches this + while (node->next->x <= xpos) { + prev = &node->next; + node = node->next; + } + STBRP_ASSERT(node->next->x > xpos && node->x <= xpos); + y = stbrp__skyline_find_min_y(c, node, xpos, width, &waste); + if (y + height <= c->height) { + if (y <= best_y) { + if (y < best_y || waste < best_waste || (waste==best_waste && xpos < best_x)) { + best_x = xpos; + STBRP_ASSERT(y <= best_y); + best_y = y; + best_waste = waste; + best = prev; + } + } + } + tail = tail->next; + } + } + + fr.prev_link = best; + fr.x = best_x; + fr.y = best_y; + return fr; +} + +static stbrp__findresult stbrp__skyline_pack_rectangle(stbrp_context *context, int width, int height) +{ + // find best position according to heuristic + stbrp__findresult res = stbrp__skyline_find_best_pos(context, width, height); + stbrp_node *node, *cur; + + // bail if: + // 1. it failed + // 2. the best node doesn't fit (we don't always check this) + // 3. we're out of memory + if (res.prev_link == NULL || res.y + height > context->height || context->free_head == NULL) { + res.prev_link = NULL; + return res; + } + + // on success, create new node + node = context->free_head; + node->x = (stbrp_coord) res.x; + node->y = (stbrp_coord) (res.y + height); + + context->free_head = node->next; + + // insert the new node into the right starting point, and + // let 'cur' point to the remaining nodes needing to be + // stiched back in + + cur = *res.prev_link; + if (cur->x < res.x) { + // preserve the existing one, so start testing with the next one + stbrp_node *next = cur->next; + cur->next = node; + cur = next; + } else { + *res.prev_link = node; + } + + // from here, traverse cur and free the nodes, until we get to one + // that shouldn't be freed + while (cur->next && cur->next->x <= res.x + width) { + stbrp_node *next = cur->next; + // move the current node to the free list + cur->next = context->free_head; + context->free_head = cur; + cur = next; + } + + // stitch the list back in + node->next = cur; + + if (cur->x < res.x + width) + cur->x = (stbrp_coord) (res.x + width); + +#ifdef _DEBUG + cur = context->active_head; + while (cur->x < context->width) { + STBRP_ASSERT(cur->x < cur->next->x); + cur = cur->next; + } + STBRP_ASSERT(cur->next == NULL); + + { + int count=0; + cur = context->active_head; + while (cur) { + cur = cur->next; + ++count; + } + cur = context->free_head; + while (cur) { + cur = cur->next; + ++count; + } + STBRP_ASSERT(count == context->num_nodes+2); + } +#endif + + return res; +} + +static int STBRP__CDECL rect_height_compare(const void *a, const void *b) +{ + const stbrp_rect *p = (const stbrp_rect *) a; + const stbrp_rect *q = (const stbrp_rect *) b; + if (p->h > q->h) + return -1; + if (p->h < q->h) + return 1; + return (p->w > q->w) ? -1 : (p->w < q->w); +} + +static int STBRP__CDECL rect_original_order(const void *a, const void *b) +{ + const stbrp_rect *p = (const stbrp_rect *) a; + const stbrp_rect *q = (const stbrp_rect *) b; + return (p->was_packed < q->was_packed) ? -1 : (p->was_packed > q->was_packed); +} + +STBRP_DEF int stbrp_pack_rects(stbrp_context *context, stbrp_rect *rects, int num_rects) +{ + int i, all_rects_packed = 1; + + // we use the 'was_packed' field internally to allow sorting/unsorting + for (i=0; i < num_rects; ++i) { + rects[i].was_packed = i; + } + + // sort according to heuristic + STBRP_SORT(rects, num_rects, sizeof(rects[0]), rect_height_compare); + + for (i=0; i < num_rects; ++i) { + if (rects[i].w == 0 || rects[i].h == 0) { + rects[i].x = rects[i].y = 0; // empty rect needs no space + } else { + stbrp__findresult fr = stbrp__skyline_pack_rectangle(context, rects[i].w, rects[i].h); + if (fr.prev_link) { + rects[i].x = (stbrp_coord) fr.x; + rects[i].y = (stbrp_coord) fr.y; + } else { + rects[i].x = rects[i].y = STBRP__MAXVAL; + } + } + } + + // unsort + STBRP_SORT(rects, num_rects, sizeof(rects[0]), rect_original_order); + + // set was_packed flags and all_rects_packed status + for (i=0; i < num_rects; ++i) { + rects[i].was_packed = !(rects[i].x == STBRP__MAXVAL && rects[i].y == STBRP__MAXVAL); + if (!rects[i].was_packed) + all_rects_packed = 0; + } + + // return the all_rects_packed status + return all_rects_packed; +} +#endif + +/* +------------------------------------------------------------------------------ +This software is available under 2 licenses -- choose whichever you prefer. +------------------------------------------------------------------------------ +ALTERNATIVE A - MIT License +Copyright (c) 2017 Sean Barrett +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is furnished to do +so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +------------------------------------------------------------------------------ +ALTERNATIVE B - Public Domain (www.unlicense.org) +This is free and unencumbered software released into the public domain. +Anyone is free to copy, modify, publish, use, compile, sell, or distribute this +software, either in source code form or as a compiled binary, for any purpose, +commercial or non-commercial, and by any means. +In jurisdictions that recognize copyright laws, the author or authors of this +software dedicate any and all copyright interest in the software to the public +domain. We make this dedication for the benefit of the public at large and to +the detriment of our heirs and successors. We intend this dedication to be an +overt act of relinquishment in perpetuity of all present and future rights to +this software under copyright law. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN +ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +------------------------------------------------------------------------------ +*/ diff --git a/tests/data/c/stb/stb_sprintf.h b/tests/data/c/stb/stb_sprintf.h new file mode 100644 index 000000000..ca432a6bc --- /dev/null +++ b/tests/data/c/stb/stb_sprintf.h @@ -0,0 +1,1906 @@ +// stb_sprintf - v1.10 - public domain snprintf() implementation +// originally by Jeff Roberts / RAD Game Tools, 2015/10/20 +// http://github.com/nothings/stb +// +// allowed types: sc uidBboXx p AaGgEef n +// lengths : hh h ll j z t I64 I32 I +// +// Contributors: +// Fabian "ryg" Giesen (reformatting) +// github:aganm (attribute format) +// +// Contributors (bugfixes): +// github:d26435 +// github:trex78 +// github:account-login +// Jari Komppa (SI suffixes) +// Rohit Nirmal +// Marcin Wojdyr +// Leonard Ritter +// Stefano Zanotti +// Adam Allison +// Arvid Gerstmann +// Markus Kolb +// +// LICENSE: +// +// See end of file for license information. + +#ifndef STB_SPRINTF_H_INCLUDE +#define STB_SPRINTF_H_INCLUDE + +/* +Single file sprintf replacement. + +Originally written by Jeff Roberts at RAD Game Tools - 2015/10/20. +Hereby placed in public domain. + +This is a full sprintf replacement that supports everything that +the C runtime sprintfs support, including float/double, 64-bit integers, +hex floats, field parameters (%*.*d stuff), length reads backs, etc. + +Why would you need this if sprintf already exists? Well, first off, +it's *much* faster (see below). It's also much smaller than the CRT +versions code-space-wise. We've also added some simple improvements +that are super handy (commas in thousands, callbacks at buffer full, +for example). Finally, the format strings for MSVC and GCC differ +for 64-bit integers (among other small things), so this lets you use +the same format strings in cross platform code. + +It uses the standard single file trick of being both the header file +and the source itself. If you just include it normally, you just get +the header file function definitions. To get the code, you include +it from a C or C++ file and define STB_SPRINTF_IMPLEMENTATION first. + +It only uses va_args macros from the C runtime to do it's work. It +does cast doubles to S64s and shifts and divides U64s, which does +drag in CRT code on most platforms. + +It compiles to roughly 8K with float support, and 4K without. +As a comparison, when using MSVC static libs, calling sprintf drags +in 16K. + +API: +==== +int stbsp_sprintf( char * buf, char const * fmt, ... ) +int stbsp_snprintf( char * buf, int count, char const * fmt, ... ) + Convert an arg list into a buffer. stbsp_snprintf always returns + a zero-terminated string (unlike regular snprintf). + +int stbsp_vsprintf( char * buf, char const * fmt, va_list va ) +int stbsp_vsnprintf( char * buf, int count, char const * fmt, va_list va ) + Convert a va_list arg list into a buffer. stbsp_vsnprintf always returns + a zero-terminated string (unlike regular snprintf). + +int stbsp_vsprintfcb( STBSP_SPRINTFCB * callback, void * user, char * buf, char const * fmt, va_list va ) + typedef char * STBSP_SPRINTFCB( char const * buf, void * user, int len ); + Convert into a buffer, calling back every STB_SPRINTF_MIN chars. + Your callback can then copy the chars out, print them or whatever. + This function is actually the workhorse for everything else. + The buffer you pass in must hold at least STB_SPRINTF_MIN characters. + // you return the next buffer to use or 0 to stop converting + +void stbsp_set_separators( char comma, char period ) + Set the comma and period characters to use. + +FLOATS/DOUBLES: +=============== +This code uses a internal float->ascii conversion method that uses +doubles with error correction (double-doubles, for ~105 bits of +precision). This conversion is round-trip perfect - that is, an atof +of the values output here will give you the bit-exact double back. + +One difference is that our insignificant digits will be different than +with MSVC or GCC (but they don't match each other either). We also +don't attempt to find the minimum length matching float (pre-MSVC15 +doesn't either). + +If you don't need float or doubles at all, define STB_SPRINTF_NOFLOAT +and you'll save 4K of code space. + +64-BIT INTS: +============ +This library also supports 64-bit integers and you can use MSVC style or +GCC style indicators (%I64d or %lld). It supports the C99 specifiers +for size_t and ptr_diff_t (%jd %zd) as well. + +EXTRAS: +======= +Like some GCCs, for integers and floats, you can use a ' (single quote) +specifier and commas will be inserted on the thousands: "%'d" on 12345 +would print 12,345. + +For integers and floats, you can use a "$" specifier and the number +will be converted to float and then divided to get kilo, mega, giga or +tera and then printed, so "%$d" 1000 is "1.0 k", "%$.2d" 2536000 is +"2.53 M", etc. For byte values, use two $:s, like "%$$d" to turn +2536000 to "2.42 Mi". If you prefer JEDEC suffixes to SI ones, use three +$:s: "%$$$d" -> "2.42 M". To remove the space between the number and the +suffix, add "_" specifier: "%_$d" -> "2.53M". + +In addition to octal and hexadecimal conversions, you can print +integers in binary: "%b" for 256 would print 100. + +PERFORMANCE vs MSVC 2008 32-/64-bit (GCC is even slower than MSVC): +=================================================================== +"%d" across all 32-bit ints (4.8x/4.0x faster than 32-/64-bit MSVC) +"%24d" across all 32-bit ints (4.5x/4.2x faster) +"%x" across all 32-bit ints (4.5x/3.8x faster) +"%08x" across all 32-bit ints (4.3x/3.8x faster) +"%f" across e-10 to e+10 floats (7.3x/6.0x faster) +"%e" across e-10 to e+10 floats (8.1x/6.0x faster) +"%g" across e-10 to e+10 floats (10.0x/7.1x faster) +"%f" for values near e-300 (7.9x/6.5x faster) +"%f" for values near e+300 (10.0x/9.1x faster) +"%e" for values near e-300 (10.1x/7.0x faster) +"%e" for values near e+300 (9.2x/6.0x faster) +"%.320f" for values near e-300 (12.6x/11.2x faster) +"%a" for random values (8.6x/4.3x faster) +"%I64d" for 64-bits with 32-bit values (4.8x/3.4x faster) +"%I64d" for 64-bits > 32-bit values (4.9x/5.5x faster) +"%s%s%s" for 64 char strings (7.1x/7.3x faster) +"...512 char string..." ( 35.0x/32.5x faster!) +*/ + +#if defined(__clang__) + #if defined(__has_feature) && defined(__has_attribute) + #if __has_feature(address_sanitizer) + #if __has_attribute(__no_sanitize__) + #define STBSP__ASAN __attribute__((__no_sanitize__("address"))) + #elif __has_attribute(__no_sanitize_address__) + #define STBSP__ASAN __attribute__((__no_sanitize_address__)) + #elif __has_attribute(__no_address_safety_analysis__) + #define STBSP__ASAN __attribute__((__no_address_safety_analysis__)) + #endif + #endif + #endif +#elif defined(__GNUC__) && (__GNUC__ >= 5 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)) + #if defined(__SANITIZE_ADDRESS__) && __SANITIZE_ADDRESS__ + #define STBSP__ASAN __attribute__((__no_sanitize_address__)) + #endif +#endif + +#ifndef STBSP__ASAN +#define STBSP__ASAN +#endif + +#ifdef STB_SPRINTF_STATIC +#define STBSP__PUBLICDEC static +#define STBSP__PUBLICDEF static STBSP__ASAN +#else +#ifdef __cplusplus +#define STBSP__PUBLICDEC extern "C" +#define STBSP__PUBLICDEF extern "C" STBSP__ASAN +#else +#define STBSP__PUBLICDEC extern +#define STBSP__PUBLICDEF STBSP__ASAN +#endif +#endif + +#if defined(__has_attribute) + #if __has_attribute(format) + #define STBSP__ATTRIBUTE_FORMAT(fmt,va) __attribute__((format(printf,fmt,va))) + #endif +#endif + +#ifndef STBSP__ATTRIBUTE_FORMAT +#define STBSP__ATTRIBUTE_FORMAT(fmt,va) +#endif + +#ifdef _MSC_VER +#define STBSP__NOTUSED(v) (void)(v) +#else +#define STBSP__NOTUSED(v) (void)sizeof(v) +#endif + +#include // for va_arg(), va_list() +#include // size_t, ptrdiff_t + +#ifndef STB_SPRINTF_MIN +#define STB_SPRINTF_MIN 512 // how many characters per callback +#endif +typedef char *STBSP_SPRINTFCB(const char *buf, void *user, int len); + +#ifndef STB_SPRINTF_DECORATE +#define STB_SPRINTF_DECORATE(name) stbsp_##name // define this before including if you want to change the names +#endif + +STBSP__PUBLICDEC int STB_SPRINTF_DECORATE(vsprintf)(char *buf, char const *fmt, va_list va); +STBSP__PUBLICDEC int STB_SPRINTF_DECORATE(vsnprintf)(char *buf, int count, char const *fmt, va_list va); +STBSP__PUBLICDEC int STB_SPRINTF_DECORATE(sprintf)(char *buf, char const *fmt, ...) STBSP__ATTRIBUTE_FORMAT(2,3); +STBSP__PUBLICDEC int STB_SPRINTF_DECORATE(snprintf)(char *buf, int count, char const *fmt, ...) STBSP__ATTRIBUTE_FORMAT(3,4); + +STBSP__PUBLICDEC int STB_SPRINTF_DECORATE(vsprintfcb)(STBSP_SPRINTFCB *callback, void *user, char *buf, char const *fmt, va_list va); +STBSP__PUBLICDEC void STB_SPRINTF_DECORATE(set_separators)(char comma, char period); + +#endif // STB_SPRINTF_H_INCLUDE + +#ifdef STB_SPRINTF_IMPLEMENTATION + +#define stbsp__uint32 unsigned int +#define stbsp__int32 signed int + +#ifdef _MSC_VER +#define stbsp__uint64 unsigned __int64 +#define stbsp__int64 signed __int64 +#else +#define stbsp__uint64 unsigned long long +#define stbsp__int64 signed long long +#endif +#define stbsp__uint16 unsigned short + +#ifndef stbsp__uintptr +#if defined(__ppc64__) || defined(__powerpc64__) || defined(__aarch64__) || defined(_M_X64) || defined(__x86_64__) || defined(__x86_64) || defined(__s390x__) +#define stbsp__uintptr stbsp__uint64 +#else +#define stbsp__uintptr stbsp__uint32 +#endif +#endif + +#ifndef STB_SPRINTF_MSVC_MODE // used for MSVC2013 and earlier (MSVC2015 matches GCC) +#if defined(_MSC_VER) && (_MSC_VER < 1900) +#define STB_SPRINTF_MSVC_MODE +#endif +#endif + +#ifdef STB_SPRINTF_NOUNALIGNED // define this before inclusion to force stbsp_sprintf to always use aligned accesses +#define STBSP__UNALIGNED(code) +#else +#define STBSP__UNALIGNED(code) code +#endif + +#ifndef STB_SPRINTF_NOFLOAT +// internal float utility functions +static stbsp__int32 stbsp__real_to_str(char const **start, stbsp__uint32 *len, char *out, stbsp__int32 *decimal_pos, double value, stbsp__uint32 frac_digits); +static stbsp__int32 stbsp__real_to_parts(stbsp__int64 *bits, stbsp__int32 *expo, double value); +#define STBSP__SPECIAL 0x7000 +#endif + +static char stbsp__period = '.'; +static char stbsp__comma = ','; +static struct +{ + short temp; // force next field to be 2-byte aligned + char pair[201]; +} stbsp__digitpair = +{ + 0, + "00010203040506070809101112131415161718192021222324" + "25262728293031323334353637383940414243444546474849" + "50515253545556575859606162636465666768697071727374" + "75767778798081828384858687888990919293949596979899" +}; + +STBSP__PUBLICDEF void STB_SPRINTF_DECORATE(set_separators)(char pcomma, char pperiod) +{ + stbsp__period = pperiod; + stbsp__comma = pcomma; +} + +#define STBSP__LEFTJUST 1 +#define STBSP__LEADINGPLUS 2 +#define STBSP__LEADINGSPACE 4 +#define STBSP__LEADING_0X 8 +#define STBSP__LEADINGZERO 16 +#define STBSP__INTMAX 32 +#define STBSP__TRIPLET_COMMA 64 +#define STBSP__NEGATIVE 128 +#define STBSP__METRIC_SUFFIX 256 +#define STBSP__HALFWIDTH 512 +#define STBSP__METRIC_NOSPACE 1024 +#define STBSP__METRIC_1024 2048 +#define STBSP__METRIC_JEDEC 4096 + +static void stbsp__lead_sign(stbsp__uint32 fl, char *sign) +{ + sign[0] = 0; + if (fl & STBSP__NEGATIVE) { + sign[0] = 1; + sign[1] = '-'; + } else if (fl & STBSP__LEADINGSPACE) { + sign[0] = 1; + sign[1] = ' '; + } else if (fl & STBSP__LEADINGPLUS) { + sign[0] = 1; + sign[1] = '+'; + } +} + +static STBSP__ASAN stbsp__uint32 stbsp__strlen_limited(char const *s, stbsp__uint32 limit) +{ + char const * sn = s; + + // get up to 4-byte alignment + for (;;) { + if (((stbsp__uintptr)sn & 3) == 0) + break; + + if (!limit || *sn == 0) + return (stbsp__uint32)(sn - s); + + ++sn; + --limit; + } + + // scan over 4 bytes at a time to find terminating 0 + // this will intentionally scan up to 3 bytes past the end of buffers, + // but becase it works 4B aligned, it will never cross page boundaries + // (hence the STBSP__ASAN markup; the over-read here is intentional + // and harmless) + while (limit >= 4) { + stbsp__uint32 v = *(stbsp__uint32 *)sn; + // bit hack to find if there's a 0 byte in there + if ((v - 0x01010101) & (~v) & 0x80808080UL) + break; + + sn += 4; + limit -= 4; + } + + // handle the last few characters to find actual size + while (limit && *sn) { + ++sn; + --limit; + } + + return (stbsp__uint32)(sn - s); +} + +STBSP__PUBLICDEF int STB_SPRINTF_DECORATE(vsprintfcb)(STBSP_SPRINTFCB *callback, void *user, char *buf, char const *fmt, va_list va) +{ + static char hex[] = "0123456789abcdefxp"; + static char hexu[] = "0123456789ABCDEFXP"; + char *bf; + char const *f; + int tlen = 0; + + bf = buf; + f = fmt; + for (;;) { + stbsp__int32 fw, pr, tz; + stbsp__uint32 fl; + + // macros for the callback buffer stuff + #define stbsp__chk_cb_bufL(bytes) \ + { \ + int len = (int)(bf - buf); \ + if ((len + (bytes)) >= STB_SPRINTF_MIN) { \ + tlen += len; \ + if (0 == (bf = buf = callback(buf, user, len))) \ + goto done; \ + } \ + } + #define stbsp__chk_cb_buf(bytes) \ + { \ + if (callback) { \ + stbsp__chk_cb_bufL(bytes); \ + } \ + } + #define stbsp__flush_cb() \ + { \ + stbsp__chk_cb_bufL(STB_SPRINTF_MIN - 1); \ + } // flush if there is even one byte in the buffer + #define stbsp__cb_buf_clamp(cl, v) \ + cl = v; \ + if (callback) { \ + int lg = STB_SPRINTF_MIN - (int)(bf - buf); \ + if (cl > lg) \ + cl = lg; \ + } + + // fast copy everything up to the next % (or end of string) + for (;;) { + while (((stbsp__uintptr)f) & 3) { + schk1: + if (f[0] == '%') + goto scandd; + schk2: + if (f[0] == 0) + goto endfmt; + stbsp__chk_cb_buf(1); + *bf++ = f[0]; + ++f; + } + for (;;) { + // Check if the next 4 bytes contain %(0x25) or end of string. + // Using the 'hasless' trick: + // https://graphics.stanford.edu/~seander/bithacks.html#HasLessInWord + stbsp__uint32 v, c; + v = *(stbsp__uint32 *)f; + c = (~v) & 0x80808080; + if (((v ^ 0x25252525) - 0x01010101) & c) + goto schk1; + if ((v - 0x01010101) & c) + goto schk2; + if (callback) + if ((STB_SPRINTF_MIN - (int)(bf - buf)) < 4) + goto schk1; + #ifdef STB_SPRINTF_NOUNALIGNED + if(((stbsp__uintptr)bf) & 3) { + bf[0] = f[0]; + bf[1] = f[1]; + bf[2] = f[2]; + bf[3] = f[3]; + } else + #endif + { + *(stbsp__uint32 *)bf = v; + } + bf += 4; + f += 4; + } + } + scandd: + + ++f; + + // ok, we have a percent, read the modifiers first + fw = 0; + pr = -1; + fl = 0; + tz = 0; + + // flags + for (;;) { + switch (f[0]) { + // if we have left justify + case '-': + fl |= STBSP__LEFTJUST; + ++f; + continue; + // if we have leading plus + case '+': + fl |= STBSP__LEADINGPLUS; + ++f; + continue; + // if we have leading space + case ' ': + fl |= STBSP__LEADINGSPACE; + ++f; + continue; + // if we have leading 0x + case '#': + fl |= STBSP__LEADING_0X; + ++f; + continue; + // if we have thousand commas + case '\'': + fl |= STBSP__TRIPLET_COMMA; + ++f; + continue; + // if we have kilo marker (none->kilo->kibi->jedec) + case '$': + if (fl & STBSP__METRIC_SUFFIX) { + if (fl & STBSP__METRIC_1024) { + fl |= STBSP__METRIC_JEDEC; + } else { + fl |= STBSP__METRIC_1024; + } + } else { + fl |= STBSP__METRIC_SUFFIX; + } + ++f; + continue; + // if we don't want space between metric suffix and number + case '_': + fl |= STBSP__METRIC_NOSPACE; + ++f; + continue; + // if we have leading zero + case '0': + fl |= STBSP__LEADINGZERO; + ++f; + goto flags_done; + default: goto flags_done; + } + } + flags_done: + + // get the field width + if (f[0] == '*') { + fw = va_arg(va, stbsp__uint32); + ++f; + } else { + while ((f[0] >= '0') && (f[0] <= '9')) { + fw = fw * 10 + f[0] - '0'; + f++; + } + } + // get the precision + if (f[0] == '.') { + ++f; + if (f[0] == '*') { + pr = va_arg(va, stbsp__uint32); + ++f; + } else { + pr = 0; + while ((f[0] >= '0') && (f[0] <= '9')) { + pr = pr * 10 + f[0] - '0'; + f++; + } + } + } + + // handle integer size overrides + switch (f[0]) { + // are we halfwidth? + case 'h': + fl |= STBSP__HALFWIDTH; + ++f; + if (f[0] == 'h') + ++f; // QUARTERWIDTH + break; + // are we 64-bit (unix style) + case 'l': + fl |= ((sizeof(long) == 8) ? STBSP__INTMAX : 0); + ++f; + if (f[0] == 'l') { + fl |= STBSP__INTMAX; + ++f; + } + break; + // are we 64-bit on intmax? (c99) + case 'j': + fl |= (sizeof(size_t) == 8) ? STBSP__INTMAX : 0; + ++f; + break; + // are we 64-bit on size_t or ptrdiff_t? (c99) + case 'z': + fl |= (sizeof(ptrdiff_t) == 8) ? STBSP__INTMAX : 0; + ++f; + break; + case 't': + fl |= (sizeof(ptrdiff_t) == 8) ? STBSP__INTMAX : 0; + ++f; + break; + // are we 64-bit (msft style) + case 'I': + if ((f[1] == '6') && (f[2] == '4')) { + fl |= STBSP__INTMAX; + f += 3; + } else if ((f[1] == '3') && (f[2] == '2')) { + f += 3; + } else { + fl |= ((sizeof(void *) == 8) ? STBSP__INTMAX : 0); + ++f; + } + break; + default: break; + } + + // handle each replacement + switch (f[0]) { + #define STBSP__NUMSZ 512 // big enough for e308 (with commas) or e-307 + char num[STBSP__NUMSZ]; + char lead[8]; + char tail[8]; + char *s; + char const *h; + stbsp__uint32 l, n, cs; + stbsp__uint64 n64; +#ifndef STB_SPRINTF_NOFLOAT + double fv; +#endif + stbsp__int32 dp; + char const *sn; + + case 's': + // get the string + s = va_arg(va, char *); + if (s == 0) + s = (char *)"null"; + // get the length, limited to desired precision + // always limit to ~0u chars since our counts are 32b + l = stbsp__strlen_limited(s, (pr >= 0) ? pr : ~0u); + lead[0] = 0; + tail[0] = 0; + pr = 0; + dp = 0; + cs = 0; + // copy the string in + goto scopy; + + case 'c': // char + // get the character + s = num + STBSP__NUMSZ - 1; + *s = (char)va_arg(va, int); + l = 1; + lead[0] = 0; + tail[0] = 0; + pr = 0; + dp = 0; + cs = 0; + goto scopy; + + case 'n': // weird write-bytes specifier + { + int *d = va_arg(va, int *); + *d = tlen + (int)(bf - buf); + } break; + +#ifdef STB_SPRINTF_NOFLOAT + case 'A': // float + case 'a': // hex float + case 'G': // float + case 'g': // float + case 'E': // float + case 'e': // float + case 'f': // float + va_arg(va, double); // eat it + s = (char *)"No float"; + l = 8; + lead[0] = 0; + tail[0] = 0; + pr = 0; + cs = 0; + STBSP__NOTUSED(dp); + goto scopy; +#else + case 'A': // hex float + case 'a': // hex float + h = (f[0] == 'A') ? hexu : hex; + fv = va_arg(va, double); + if (pr == -1) + pr = 6; // default is 6 + // read the double into a string + if (stbsp__real_to_parts((stbsp__int64 *)&n64, &dp, fv)) + fl |= STBSP__NEGATIVE; + + s = num + 64; + + stbsp__lead_sign(fl, lead); + + if (dp == -1023) + dp = (n64) ? -1022 : 0; + else + n64 |= (((stbsp__uint64)1) << 52); + n64 <<= (64 - 56); + if (pr < 15) + n64 += ((((stbsp__uint64)8) << 56) >> (pr * 4)); +// add leading chars + +#ifdef STB_SPRINTF_MSVC_MODE + *s++ = '0'; + *s++ = 'x'; +#else + lead[1 + lead[0]] = '0'; + lead[2 + lead[0]] = 'x'; + lead[0] += 2; +#endif + *s++ = h[(n64 >> 60) & 15]; + n64 <<= 4; + if (pr) + *s++ = stbsp__period; + sn = s; + + // print the bits + n = pr; + if (n > 13) + n = 13; + if (pr > (stbsp__int32)n) + tz = pr - n; + pr = 0; + while (n--) { + *s++ = h[(n64 >> 60) & 15]; + n64 <<= 4; + } + + // print the expo + tail[1] = h[17]; + if (dp < 0) { + tail[2] = '-'; + dp = -dp; + } else + tail[2] = '+'; + n = (dp >= 1000) ? 6 : ((dp >= 100) ? 5 : ((dp >= 10) ? 4 : 3)); + tail[0] = (char)n; + for (;;) { + tail[n] = '0' + dp % 10; + if (n <= 3) + break; + --n; + dp /= 10; + } + + dp = (int)(s - sn); + l = (int)(s - (num + 64)); + s = num + 64; + cs = 1 + (3 << 24); + goto scopy; + + case 'G': // float + case 'g': // float + h = (f[0] == 'G') ? hexu : hex; + fv = va_arg(va, double); + if (pr == -1) + pr = 6; + else if (pr == 0) + pr = 1; // default is 6 + // read the double into a string + if (stbsp__real_to_str(&sn, &l, num, &dp, fv, (pr - 1) | 0x80000000)) + fl |= STBSP__NEGATIVE; + + // clamp the precision and delete extra zeros after clamp + n = pr; + if (l > (stbsp__uint32)pr) + l = pr; + while ((l > 1) && (pr) && (sn[l - 1] == '0')) { + --pr; + --l; + } + + // should we use %e + if ((dp <= -4) || (dp > (stbsp__int32)n)) { + if (pr > (stbsp__int32)l) + pr = l - 1; + else if (pr) + --pr; // when using %e, there is one digit before the decimal + goto doexpfromg; + } + // this is the insane action to get the pr to match %g semantics for %f + if (dp > 0) { + pr = (dp < (stbsp__int32)l) ? l - dp : 0; + } else { + pr = -dp + ((pr > (stbsp__int32)l) ? (stbsp__int32) l : pr); + } + goto dofloatfromg; + + case 'E': // float + case 'e': // float + h = (f[0] == 'E') ? hexu : hex; + fv = va_arg(va, double); + if (pr == -1) + pr = 6; // default is 6 + // read the double into a string + if (stbsp__real_to_str(&sn, &l, num, &dp, fv, pr | 0x80000000)) + fl |= STBSP__NEGATIVE; + doexpfromg: + tail[0] = 0; + stbsp__lead_sign(fl, lead); + if (dp == STBSP__SPECIAL) { + s = (char *)sn; + cs = 0; + pr = 0; + goto scopy; + } + s = num + 64; + // handle leading chars + *s++ = sn[0]; + + if (pr) + *s++ = stbsp__period; + + // handle after decimal + if ((l - 1) > (stbsp__uint32)pr) + l = pr + 1; + for (n = 1; n < l; n++) + *s++ = sn[n]; + // trailing zeros + tz = pr - (l - 1); + pr = 0; + // dump expo + tail[1] = h[0xe]; + dp -= 1; + if (dp < 0) { + tail[2] = '-'; + dp = -dp; + } else + tail[2] = '+'; +#ifdef STB_SPRINTF_MSVC_MODE + n = 5; +#else + n = (dp >= 100) ? 5 : 4; +#endif + tail[0] = (char)n; + for (;;) { + tail[n] = '0' + dp % 10; + if (n <= 3) + break; + --n; + dp /= 10; + } + cs = 1 + (3 << 24); // how many tens + goto flt_lead; + + case 'f': // float + fv = va_arg(va, double); + doafloat: + // do kilos + if (fl & STBSP__METRIC_SUFFIX) { + double divisor; + divisor = 1000.0f; + if (fl & STBSP__METRIC_1024) + divisor = 1024.0; + while (fl < 0x4000000) { + if ((fv < divisor) && (fv > -divisor)) + break; + fv /= divisor; + fl += 0x1000000; + } + } + if (pr == -1) + pr = 6; // default is 6 + // read the double into a string + if (stbsp__real_to_str(&sn, &l, num, &dp, fv, pr)) + fl |= STBSP__NEGATIVE; + dofloatfromg: + tail[0] = 0; + stbsp__lead_sign(fl, lead); + if (dp == STBSP__SPECIAL) { + s = (char *)sn; + cs = 0; + pr = 0; + goto scopy; + } + s = num + 64; + + // handle the three decimal varieties + if (dp <= 0) { + stbsp__int32 i; + // handle 0.000*000xxxx + *s++ = '0'; + if (pr) + *s++ = stbsp__period; + n = -dp; + if ((stbsp__int32)n > pr) + n = pr; + i = n; + while (i) { + if ((((stbsp__uintptr)s) & 3) == 0) + break; + *s++ = '0'; + --i; + } + while (i >= 4) { + *(stbsp__uint32 *)s = 0x30303030; + s += 4; + i -= 4; + } + while (i) { + *s++ = '0'; + --i; + } + if ((stbsp__int32)(l + n) > pr) + l = pr - n; + i = l; + while (i) { + *s++ = *sn++; + --i; + } + tz = pr - (n + l); + cs = 1 + (3 << 24); // how many tens did we write (for commas below) + } else { + cs = (fl & STBSP__TRIPLET_COMMA) ? ((600 - (stbsp__uint32)dp) % 3) : 0; + if ((stbsp__uint32)dp >= l) { + // handle xxxx000*000.0 + n = 0; + for (;;) { + if ((fl & STBSP__TRIPLET_COMMA) && (++cs == 4)) { + cs = 0; + *s++ = stbsp__comma; + } else { + *s++ = sn[n]; + ++n; + if (n >= l) + break; + } + } + if (n < (stbsp__uint32)dp) { + n = dp - n; + if ((fl & STBSP__TRIPLET_COMMA) == 0) { + while (n) { + if ((((stbsp__uintptr)s) & 3) == 0) + break; + *s++ = '0'; + --n; + } + while (n >= 4) { + *(stbsp__uint32 *)s = 0x30303030; + s += 4; + n -= 4; + } + } + while (n) { + if ((fl & STBSP__TRIPLET_COMMA) && (++cs == 4)) { + cs = 0; + *s++ = stbsp__comma; + } else { + *s++ = '0'; + --n; + } + } + } + cs = (int)(s - (num + 64)) + (3 << 24); // cs is how many tens + if (pr) { + *s++ = stbsp__period; + tz = pr; + } + } else { + // handle xxxxx.xxxx000*000 + n = 0; + for (;;) { + if ((fl & STBSP__TRIPLET_COMMA) && (++cs == 4)) { + cs = 0; + *s++ = stbsp__comma; + } else { + *s++ = sn[n]; + ++n; + if (n >= (stbsp__uint32)dp) + break; + } + } + cs = (int)(s - (num + 64)) + (3 << 24); // cs is how many tens + if (pr) + *s++ = stbsp__period; + if ((l - dp) > (stbsp__uint32)pr) + l = pr + dp; + while (n < l) { + *s++ = sn[n]; + ++n; + } + tz = pr - (l - dp); + } + } + pr = 0; + + // handle k,m,g,t + if (fl & STBSP__METRIC_SUFFIX) { + char idx; + idx = 1; + if (fl & STBSP__METRIC_NOSPACE) + idx = 0; + tail[0] = idx; + tail[1] = ' '; + { + if (fl >> 24) { // SI kilo is 'k', JEDEC and SI kibits are 'K'. + if (fl & STBSP__METRIC_1024) + tail[idx + 1] = "_KMGT"[fl >> 24]; + else + tail[idx + 1] = "_kMGT"[fl >> 24]; + idx++; + // If printing kibits and not in jedec, add the 'i'. + if (fl & STBSP__METRIC_1024 && !(fl & STBSP__METRIC_JEDEC)) { + tail[idx + 1] = 'i'; + idx++; + } + tail[0] = idx; + } + } + }; + + flt_lead: + // get the length that we copied + l = (stbsp__uint32)(s - (num + 64)); + s = num + 64; + goto scopy; +#endif + + case 'B': // upper binary + case 'b': // lower binary + h = (f[0] == 'B') ? hexu : hex; + lead[0] = 0; + if (fl & STBSP__LEADING_0X) { + lead[0] = 2; + lead[1] = '0'; + lead[2] = h[0xb]; + } + l = (8 << 4) | (1 << 8); + goto radixnum; + + case 'o': // octal + h = hexu; + lead[0] = 0; + if (fl & STBSP__LEADING_0X) { + lead[0] = 1; + lead[1] = '0'; + } + l = (3 << 4) | (3 << 8); + goto radixnum; + + case 'p': // pointer + fl |= (sizeof(void *) == 8) ? STBSP__INTMAX : 0; + pr = sizeof(void *) * 2; + fl &= ~STBSP__LEADINGZERO; // 'p' only prints the pointer with zeros + // fall through - to X + + case 'X': // upper hex + case 'x': // lower hex + h = (f[0] == 'X') ? hexu : hex; + l = (4 << 4) | (4 << 8); + lead[0] = 0; + if (fl & STBSP__LEADING_0X) { + lead[0] = 2; + lead[1] = '0'; + lead[2] = h[16]; + } + radixnum: + // get the number + if (fl & STBSP__INTMAX) + n64 = va_arg(va, stbsp__uint64); + else + n64 = va_arg(va, stbsp__uint32); + + s = num + STBSP__NUMSZ; + dp = 0; + // clear tail, and clear leading if value is zero + tail[0] = 0; + if (n64 == 0) { + lead[0] = 0; + if (pr == 0) { + l = 0; + cs = 0; + goto scopy; + } + } + // convert to string + for (;;) { + *--s = h[n64 & ((1 << (l >> 8)) - 1)]; + n64 >>= (l >> 8); + if (!((n64) || ((stbsp__int32)((num + STBSP__NUMSZ) - s) < pr))) + break; + if (fl & STBSP__TRIPLET_COMMA) { + ++l; + if ((l & 15) == ((l >> 4) & 15)) { + l &= ~15; + *--s = stbsp__comma; + } + } + }; + // get the tens and the comma pos + cs = (stbsp__uint32)((num + STBSP__NUMSZ) - s) + ((((l >> 4) & 15)) << 24); + // get the length that we copied + l = (stbsp__uint32)((num + STBSP__NUMSZ) - s); + // copy it + goto scopy; + + case 'u': // unsigned + case 'i': + case 'd': // integer + // get the integer and abs it + if (fl & STBSP__INTMAX) { + stbsp__int64 i64 = va_arg(va, stbsp__int64); + n64 = (stbsp__uint64)i64; + if ((f[0] != 'u') && (i64 < 0)) { + n64 = (stbsp__uint64)-i64; + fl |= STBSP__NEGATIVE; + } + } else { + stbsp__int32 i = va_arg(va, stbsp__int32); + n64 = (stbsp__uint32)i; + if ((f[0] != 'u') && (i < 0)) { + n64 = (stbsp__uint32)-i; + fl |= STBSP__NEGATIVE; + } + } + +#ifndef STB_SPRINTF_NOFLOAT + if (fl & STBSP__METRIC_SUFFIX) { + if (n64 < 1024) + pr = 0; + else if (pr == -1) + pr = 1; + fv = (double)(stbsp__int64)n64; + goto doafloat; + } +#endif + + // convert to string + s = num + STBSP__NUMSZ; + l = 0; + + for (;;) { + // do in 32-bit chunks (avoid lots of 64-bit divides even with constant denominators) + char *o = s - 8; + if (n64 >= 100000000) { + n = (stbsp__uint32)(n64 % 100000000); + n64 /= 100000000; + } else { + n = (stbsp__uint32)n64; + n64 = 0; + } + if ((fl & STBSP__TRIPLET_COMMA) == 0) { + do { + s -= 2; + *(stbsp__uint16 *)s = *(stbsp__uint16 *)&stbsp__digitpair.pair[(n % 100) * 2]; + n /= 100; + } while (n); + } + while (n) { + if ((fl & STBSP__TRIPLET_COMMA) && (l++ == 3)) { + l = 0; + *--s = stbsp__comma; + --o; + } else { + *--s = (char)(n % 10) + '0'; + n /= 10; + } + } + if (n64 == 0) { + if ((s[0] == '0') && (s != (num + STBSP__NUMSZ))) + ++s; + break; + } + while (s != o) + if ((fl & STBSP__TRIPLET_COMMA) && (l++ == 3)) { + l = 0; + *--s = stbsp__comma; + --o; + } else { + *--s = '0'; + } + } + + tail[0] = 0; + stbsp__lead_sign(fl, lead); + + // get the length that we copied + l = (stbsp__uint32)((num + STBSP__NUMSZ) - s); + if (l == 0) { + *--s = '0'; + l = 1; + } + cs = l + (3 << 24); + if (pr < 0) + pr = 0; + + scopy: + // get fw=leading/trailing space, pr=leading zeros + if (pr < (stbsp__int32)l) + pr = l; + n = pr + lead[0] + tail[0] + tz; + if (fw < (stbsp__int32)n) + fw = n; + fw -= n; + pr -= l; + + // handle right justify and leading zeros + if ((fl & STBSP__LEFTJUST) == 0) { + if (fl & STBSP__LEADINGZERO) // if leading zeros, everything is in pr + { + pr = (fw > pr) ? fw : pr; + fw = 0; + } else { + fl &= ~STBSP__TRIPLET_COMMA; // if no leading zeros, then no commas + } + } + + // copy the spaces and/or zeros + if (fw + pr) { + stbsp__int32 i; + stbsp__uint32 c; + + // copy leading spaces (or when doing %8.4d stuff) + if ((fl & STBSP__LEFTJUST) == 0) + while (fw > 0) { + stbsp__cb_buf_clamp(i, fw); + fw -= i; + while (i) { + if ((((stbsp__uintptr)bf) & 3) == 0) + break; + *bf++ = ' '; + --i; + } + while (i >= 4) { + *(stbsp__uint32 *)bf = 0x20202020; + bf += 4; + i -= 4; + } + while (i) { + *bf++ = ' '; + --i; + } + stbsp__chk_cb_buf(1); + } + + // copy leader + sn = lead + 1; + while (lead[0]) { + stbsp__cb_buf_clamp(i, lead[0]); + lead[0] -= (char)i; + while (i) { + *bf++ = *sn++; + --i; + } + stbsp__chk_cb_buf(1); + } + + // copy leading zeros + c = cs >> 24; + cs &= 0xffffff; + cs = (fl & STBSP__TRIPLET_COMMA) ? ((stbsp__uint32)(c - ((pr + cs) % (c + 1)))) : 0; + while (pr > 0) { + stbsp__cb_buf_clamp(i, pr); + pr -= i; + if ((fl & STBSP__TRIPLET_COMMA) == 0) { + while (i) { + if ((((stbsp__uintptr)bf) & 3) == 0) + break; + *bf++ = '0'; + --i; + } + while (i >= 4) { + *(stbsp__uint32 *)bf = 0x30303030; + bf += 4; + i -= 4; + } + } + while (i) { + if ((fl & STBSP__TRIPLET_COMMA) && (cs++ == c)) { + cs = 0; + *bf++ = stbsp__comma; + } else + *bf++ = '0'; + --i; + } + stbsp__chk_cb_buf(1); + } + } + + // copy leader if there is still one + sn = lead + 1; + while (lead[0]) { + stbsp__int32 i; + stbsp__cb_buf_clamp(i, lead[0]); + lead[0] -= (char)i; + while (i) { + *bf++ = *sn++; + --i; + } + stbsp__chk_cb_buf(1); + } + + // copy the string + n = l; + while (n) { + stbsp__int32 i; + stbsp__cb_buf_clamp(i, n); + n -= i; + STBSP__UNALIGNED(while (i >= 4) { + *(stbsp__uint32 volatile *)bf = *(stbsp__uint32 volatile *)s; + bf += 4; + s += 4; + i -= 4; + }) + while (i) { + *bf++ = *s++; + --i; + } + stbsp__chk_cb_buf(1); + } + + // copy trailing zeros + while (tz) { + stbsp__int32 i; + stbsp__cb_buf_clamp(i, tz); + tz -= i; + while (i) { + if ((((stbsp__uintptr)bf) & 3) == 0) + break; + *bf++ = '0'; + --i; + } + while (i >= 4) { + *(stbsp__uint32 *)bf = 0x30303030; + bf += 4; + i -= 4; + } + while (i) { + *bf++ = '0'; + --i; + } + stbsp__chk_cb_buf(1); + } + + // copy tail if there is one + sn = tail + 1; + while (tail[0]) { + stbsp__int32 i; + stbsp__cb_buf_clamp(i, tail[0]); + tail[0] -= (char)i; + while (i) { + *bf++ = *sn++; + --i; + } + stbsp__chk_cb_buf(1); + } + + // handle the left justify + if (fl & STBSP__LEFTJUST) + if (fw > 0) { + while (fw) { + stbsp__int32 i; + stbsp__cb_buf_clamp(i, fw); + fw -= i; + while (i) { + if ((((stbsp__uintptr)bf) & 3) == 0) + break; + *bf++ = ' '; + --i; + } + while (i >= 4) { + *(stbsp__uint32 *)bf = 0x20202020; + bf += 4; + i -= 4; + } + while (i--) + *bf++ = ' '; + stbsp__chk_cb_buf(1); + } + } + break; + + default: // unknown, just copy code + s = num + STBSP__NUMSZ - 1; + *s = f[0]; + l = 1; + fw = fl = 0; + lead[0] = 0; + tail[0] = 0; + pr = 0; + dp = 0; + cs = 0; + goto scopy; + } + ++f; + } +endfmt: + + if (!callback) + *bf = 0; + else + stbsp__flush_cb(); + +done: + return tlen + (int)(bf - buf); +} + +// cleanup +#undef STBSP__LEFTJUST +#undef STBSP__LEADINGPLUS +#undef STBSP__LEADINGSPACE +#undef STBSP__LEADING_0X +#undef STBSP__LEADINGZERO +#undef STBSP__INTMAX +#undef STBSP__TRIPLET_COMMA +#undef STBSP__NEGATIVE +#undef STBSP__METRIC_SUFFIX +#undef STBSP__NUMSZ +#undef stbsp__chk_cb_bufL +#undef stbsp__chk_cb_buf +#undef stbsp__flush_cb +#undef stbsp__cb_buf_clamp + +// ============================================================================ +// wrapper functions + +STBSP__PUBLICDEF int STB_SPRINTF_DECORATE(sprintf)(char *buf, char const *fmt, ...) +{ + int result; + va_list va; + va_start(va, fmt); + result = STB_SPRINTF_DECORATE(vsprintfcb)(0, 0, buf, fmt, va); + va_end(va); + return result; +} + +typedef struct stbsp__context { + char *buf; + int count; + int length; + char tmp[STB_SPRINTF_MIN]; +} stbsp__context; + +static char *stbsp__clamp_callback(const char *buf, void *user, int len) +{ + stbsp__context *c = (stbsp__context *)user; + c->length += len; + + if (len > c->count) + len = c->count; + + if (len) { + if (buf != c->buf) { + const char *s, *se; + char *d; + d = c->buf; + s = buf; + se = buf + len; + do { + *d++ = *s++; + } while (s < se); + } + c->buf += len; + c->count -= len; + } + + if (c->count <= 0) + return c->tmp; + return (c->count >= STB_SPRINTF_MIN) ? c->buf : c->tmp; // go direct into buffer if you can +} + +static char * stbsp__count_clamp_callback( const char * buf, void * user, int len ) +{ + stbsp__context * c = (stbsp__context*)user; + (void) sizeof(buf); + + c->length += len; + return c->tmp; // go direct into buffer if you can +} + +STBSP__PUBLICDEF int STB_SPRINTF_DECORATE( vsnprintf )( char * buf, int count, char const * fmt, va_list va ) +{ + stbsp__context c; + + if ( (count == 0) && !buf ) + { + c.length = 0; + + STB_SPRINTF_DECORATE( vsprintfcb )( stbsp__count_clamp_callback, &c, c.tmp, fmt, va ); + } + else + { + int l; + + c.buf = buf; + c.count = count; + c.length = 0; + + STB_SPRINTF_DECORATE( vsprintfcb )( stbsp__clamp_callback, &c, stbsp__clamp_callback(0,&c,0), fmt, va ); + + // zero-terminate + l = (int)( c.buf - buf ); + if ( l >= count ) // should never be greater, only equal (or less) than count + l = count - 1; + buf[l] = 0; + } + + return c.length; +} + +STBSP__PUBLICDEF int STB_SPRINTF_DECORATE(snprintf)(char *buf, int count, char const *fmt, ...) +{ + int result; + va_list va; + va_start(va, fmt); + + result = STB_SPRINTF_DECORATE(vsnprintf)(buf, count, fmt, va); + va_end(va); + + return result; +} + +STBSP__PUBLICDEF int STB_SPRINTF_DECORATE(vsprintf)(char *buf, char const *fmt, va_list va) +{ + return STB_SPRINTF_DECORATE(vsprintfcb)(0, 0, buf, fmt, va); +} + +// ======================================================================= +// low level float utility functions + +#ifndef STB_SPRINTF_NOFLOAT + +// copies d to bits w/ strict aliasing (this compiles to nothing on /Ox) +#define STBSP__COPYFP(dest, src) \ + { \ + int cn; \ + for (cn = 0; cn < 8; cn++) \ + ((char *)&dest)[cn] = ((char *)&src)[cn]; \ + } + +// get float info +static stbsp__int32 stbsp__real_to_parts(stbsp__int64 *bits, stbsp__int32 *expo, double value) +{ + double d; + stbsp__int64 b = 0; + + // load value and round at the frac_digits + d = value; + + STBSP__COPYFP(b, d); + + *bits = b & ((((stbsp__uint64)1) << 52) - 1); + *expo = (stbsp__int32)(((b >> 52) & 2047) - 1023); + + return (stbsp__int32)((stbsp__uint64) b >> 63); +} + +static double const stbsp__bot[23] = { + 1e+000, 1e+001, 1e+002, 1e+003, 1e+004, 1e+005, 1e+006, 1e+007, 1e+008, 1e+009, 1e+010, 1e+011, + 1e+012, 1e+013, 1e+014, 1e+015, 1e+016, 1e+017, 1e+018, 1e+019, 1e+020, 1e+021, 1e+022 +}; +static double const stbsp__negbot[22] = { + 1e-001, 1e-002, 1e-003, 1e-004, 1e-005, 1e-006, 1e-007, 1e-008, 1e-009, 1e-010, 1e-011, + 1e-012, 1e-013, 1e-014, 1e-015, 1e-016, 1e-017, 1e-018, 1e-019, 1e-020, 1e-021, 1e-022 +}; +static double const stbsp__negboterr[22] = { + -5.551115123125783e-018, -2.0816681711721684e-019, -2.0816681711721686e-020, -4.7921736023859299e-021, -8.1803053914031305e-022, 4.5251888174113741e-023, + 4.5251888174113739e-024, -2.0922560830128471e-025, -6.2281591457779853e-026, -3.6432197315497743e-027, 6.0503030718060191e-028, 2.0113352370744385e-029, + -3.0373745563400371e-030, 1.1806906454401013e-032, -7.7705399876661076e-032, 2.0902213275965398e-033, -7.1542424054621921e-034, -7.1542424054621926e-035, + 2.4754073164739869e-036, 5.4846728545790429e-037, 9.2462547772103625e-038, -4.8596774326570872e-039 +}; +static double const stbsp__top[13] = { + 1e+023, 1e+046, 1e+069, 1e+092, 1e+115, 1e+138, 1e+161, 1e+184, 1e+207, 1e+230, 1e+253, 1e+276, 1e+299 +}; +static double const stbsp__negtop[13] = { + 1e-023, 1e-046, 1e-069, 1e-092, 1e-115, 1e-138, 1e-161, 1e-184, 1e-207, 1e-230, 1e-253, 1e-276, 1e-299 +}; +static double const stbsp__toperr[13] = { + 8388608, + 6.8601809640529717e+028, + -7.253143638152921e+052, + -4.3377296974619174e+075, + -1.5559416129466825e+098, + -3.2841562489204913e+121, + -3.7745893248228135e+144, + -1.7356668416969134e+167, + -3.8893577551088374e+190, + -9.9566444326005119e+213, + 6.3641293062232429e+236, + -5.2069140800249813e+259, + -5.2504760255204387e+282 +}; +static double const stbsp__negtoperr[13] = { + 3.9565301985100693e-040, -2.299904345391321e-063, 3.6506201437945798e-086, 1.1875228833981544e-109, + -5.0644902316928607e-132, -6.7156837247865426e-155, -2.812077463003139e-178, -5.7778912386589953e-201, + 7.4997100559334532e-224, -4.6439668915134491e-247, -6.3691100762962136e-270, -9.436808465446358e-293, + 8.0970921678014997e-317 +}; + +#if defined(_MSC_VER) && (_MSC_VER <= 1200) +static stbsp__uint64 const stbsp__powten[20] = { + 1, + 10, + 100, + 1000, + 10000, + 100000, + 1000000, + 10000000, + 100000000, + 1000000000, + 10000000000, + 100000000000, + 1000000000000, + 10000000000000, + 100000000000000, + 1000000000000000, + 10000000000000000, + 100000000000000000, + 1000000000000000000, + 10000000000000000000U +}; +#define stbsp__tento19th ((stbsp__uint64)1000000000000000000) +#else +static stbsp__uint64 const stbsp__powten[20] = { + 1, + 10, + 100, + 1000, + 10000, + 100000, + 1000000, + 10000000, + 100000000, + 1000000000, + 10000000000ULL, + 100000000000ULL, + 1000000000000ULL, + 10000000000000ULL, + 100000000000000ULL, + 1000000000000000ULL, + 10000000000000000ULL, + 100000000000000000ULL, + 1000000000000000000ULL, + 10000000000000000000ULL +}; +#define stbsp__tento19th (1000000000000000000ULL) +#endif + +#define stbsp__ddmulthi(oh, ol, xh, yh) \ + { \ + double ahi = 0, alo, bhi = 0, blo; \ + stbsp__int64 bt; \ + oh = xh * yh; \ + STBSP__COPYFP(bt, xh); \ + bt &= ((~(stbsp__uint64)0) << 27); \ + STBSP__COPYFP(ahi, bt); \ + alo = xh - ahi; \ + STBSP__COPYFP(bt, yh); \ + bt &= ((~(stbsp__uint64)0) << 27); \ + STBSP__COPYFP(bhi, bt); \ + blo = yh - bhi; \ + ol = ((ahi * bhi - oh) + ahi * blo + alo * bhi) + alo * blo; \ + } + +#define stbsp__ddtoS64(ob, xh, xl) \ + { \ + double ahi = 0, alo, vh, t; \ + ob = (stbsp__int64)xh; \ + vh = (double)ob; \ + ahi = (xh - vh); \ + t = (ahi - xh); \ + alo = (xh - (ahi - t)) - (vh + t); \ + ob += (stbsp__int64)(ahi + alo + xl); \ + } + +#define stbsp__ddrenorm(oh, ol) \ + { \ + double s; \ + s = oh + ol; \ + ol = ol - (s - oh); \ + oh = s; \ + } + +#define stbsp__ddmultlo(oh, ol, xh, xl, yh, yl) ol = ol + (xh * yl + xl * yh); + +#define stbsp__ddmultlos(oh, ol, xh, yl) ol = ol + (xh * yl); + +static void stbsp__raise_to_power10(double *ohi, double *olo, double d, stbsp__int32 power) // power can be -323 to +350 +{ + double ph, pl; + if ((power >= 0) && (power <= 22)) { + stbsp__ddmulthi(ph, pl, d, stbsp__bot[power]); + } else { + stbsp__int32 e, et, eb; + double p2h, p2l; + + e = power; + if (power < 0) + e = -e; + et = (e * 0x2c9) >> 14; /* %23 */ + if (et > 13) + et = 13; + eb = e - (et * 23); + + ph = d; + pl = 0.0; + if (power < 0) { + if (eb) { + --eb; + stbsp__ddmulthi(ph, pl, d, stbsp__negbot[eb]); + stbsp__ddmultlos(ph, pl, d, stbsp__negboterr[eb]); + } + if (et) { + stbsp__ddrenorm(ph, pl); + --et; + stbsp__ddmulthi(p2h, p2l, ph, stbsp__negtop[et]); + stbsp__ddmultlo(p2h, p2l, ph, pl, stbsp__negtop[et], stbsp__negtoperr[et]); + ph = p2h; + pl = p2l; + } + } else { + if (eb) { + e = eb; + if (eb > 22) + eb = 22; + e -= eb; + stbsp__ddmulthi(ph, pl, d, stbsp__bot[eb]); + if (e) { + stbsp__ddrenorm(ph, pl); + stbsp__ddmulthi(p2h, p2l, ph, stbsp__bot[e]); + stbsp__ddmultlos(p2h, p2l, stbsp__bot[e], pl); + ph = p2h; + pl = p2l; + } + } + if (et) { + stbsp__ddrenorm(ph, pl); + --et; + stbsp__ddmulthi(p2h, p2l, ph, stbsp__top[et]); + stbsp__ddmultlo(p2h, p2l, ph, pl, stbsp__top[et], stbsp__toperr[et]); + ph = p2h; + pl = p2l; + } + } + } + stbsp__ddrenorm(ph, pl); + *ohi = ph; + *olo = pl; +} + +// given a float value, returns the significant bits in bits, and the position of the +// decimal point in decimal_pos. +/-INF and NAN are specified by special values +// returned in the decimal_pos parameter. +// frac_digits is absolute normally, but if you want from first significant digits (got %g and %e), or in 0x80000000 +static stbsp__int32 stbsp__real_to_str(char const **start, stbsp__uint32 *len, char *out, stbsp__int32 *decimal_pos, double value, stbsp__uint32 frac_digits) +{ + double d; + stbsp__int64 bits = 0; + stbsp__int32 expo, e, ng, tens; + + d = value; + STBSP__COPYFP(bits, d); + expo = (stbsp__int32)((bits >> 52) & 2047); + ng = (stbsp__int32)((stbsp__uint64) bits >> 63); + if (ng) + d = -d; + + if (expo == 2047) // is nan or inf? + { + *start = (bits & ((((stbsp__uint64)1) << 52) - 1)) ? "NaN" : "Inf"; + *decimal_pos = STBSP__SPECIAL; + *len = 3; + return ng; + } + + if (expo == 0) // is zero or denormal + { + if (((stbsp__uint64) bits << 1) == 0) // do zero + { + *decimal_pos = 1; + *start = out; + out[0] = '0'; + *len = 1; + return ng; + } + // find the right expo for denormals + { + stbsp__int64 v = ((stbsp__uint64)1) << 51; + while ((bits & v) == 0) { + --expo; + v >>= 1; + } + } + } + + // find the decimal exponent as well as the decimal bits of the value + { + double ph, pl; + + // log10 estimate - very specifically tweaked to hit or undershoot by no more than 1 of log10 of all expos 1..2046 + tens = expo - 1023; + tens = (tens < 0) ? ((tens * 617) / 2048) : (((tens * 1233) / 4096) + 1); + + // move the significant bits into position and stick them into an int + stbsp__raise_to_power10(&ph, &pl, d, 18 - tens); + + // get full as much precision from double-double as possible + stbsp__ddtoS64(bits, ph, pl); + + // check if we undershot + if (((stbsp__uint64)bits) >= stbsp__tento19th) + ++tens; + } + + // now do the rounding in integer land + frac_digits = (frac_digits & 0x80000000) ? ((frac_digits & 0x7ffffff) + 1) : (tens + frac_digits); + if ((frac_digits < 24)) { + stbsp__uint32 dg = 1; + if ((stbsp__uint64)bits >= stbsp__powten[9]) + dg = 10; + while ((stbsp__uint64)bits >= stbsp__powten[dg]) { + ++dg; + if (dg == 20) + goto noround; + } + if (frac_digits < dg) { + stbsp__uint64 r; + // add 0.5 at the right position and round + e = dg - frac_digits; + if ((stbsp__uint32)e >= 24) + goto noround; + r = stbsp__powten[e]; + bits = bits + (r / 2); + if ((stbsp__uint64)bits >= stbsp__powten[dg]) + ++tens; + bits /= r; + } + noround:; + } + + // kill long trailing runs of zeros + if (bits) { + stbsp__uint32 n; + for (;;) { + if (bits <= 0xffffffff) + break; + if (bits % 1000) + goto donez; + bits /= 1000; + } + n = (stbsp__uint32)bits; + while ((n % 1000) == 0) + n /= 1000; + bits = n; + donez:; + } + + // convert to string + out += 64; + e = 0; + for (;;) { + stbsp__uint32 n; + char *o = out - 8; + // do the conversion in chunks of U32s (avoid most 64-bit divides, worth it, constant denomiators be damned) + if (bits >= 100000000) { + n = (stbsp__uint32)(bits % 100000000); + bits /= 100000000; + } else { + n = (stbsp__uint32)bits; + bits = 0; + } + while (n) { + out -= 2; + *(stbsp__uint16 *)out = *(stbsp__uint16 *)&stbsp__digitpair.pair[(n % 100) * 2]; + n /= 100; + e += 2; + } + if (bits == 0) { + if ((e) && (out[0] == '0')) { + ++out; + --e; + } + break; + } + while (out != o) { + *--out = '0'; + ++e; + } + } + + *decimal_pos = tens; + *start = out; + *len = e; + return ng; +} + +#undef stbsp__ddmulthi +#undef stbsp__ddrenorm +#undef stbsp__ddmultlo +#undef stbsp__ddmultlos +#undef STBSP__SPECIAL +#undef STBSP__COPYFP + +#endif // STB_SPRINTF_NOFLOAT + +// clean up +#undef stbsp__uint16 +#undef stbsp__uint32 +#undef stbsp__int32 +#undef stbsp__uint64 +#undef stbsp__int64 +#undef STBSP__UNALIGNED + +#endif // STB_SPRINTF_IMPLEMENTATION + +/* +------------------------------------------------------------------------------ +This software is available under 2 licenses -- choose whichever you prefer. +------------------------------------------------------------------------------ +ALTERNATIVE A - MIT License +Copyright (c) 2017 Sean Barrett +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is furnished to do +so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +------------------------------------------------------------------------------ +ALTERNATIVE B - Public Domain (www.unlicense.org) +This is free and unencumbered software released into the public domain. +Anyone is free to copy, modify, publish, use, compile, sell, or distribute this +software, either in source code form or as a compiled binary, for any purpose, +commercial or non-commercial, and by any means. +In jurisdictions that recognize copyright laws, the author or authors of this +software dedicate any and all copyright interest in the software to the public +domain. We make this dedication for the benefit of the public at large and to +the detriment of our heirs and successors. We intend this dedication to be an +overt act of relinquishment in perpetuity of all present and future rights to +this software under copyright law. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN +ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +------------------------------------------------------------------------------ +*/ diff --git a/tests/data/c/stb/stb_textedit.h b/tests/data/c/stb/stb_textedit.h new file mode 100644 index 000000000..14424935f --- /dev/null +++ b/tests/data/c/stb/stb_textedit.h @@ -0,0 +1,1429 @@ +// stb_textedit.h - v1.14 - public domain - Sean Barrett +// Development of this library was sponsored by RAD Game Tools +// +// This C header file implements the guts of a multi-line text-editing +// widget; you implement display, word-wrapping, and low-level string +// insertion/deletion, and stb_textedit will map user inputs into +// insertions & deletions, plus updates to the cursor position, +// selection state, and undo state. +// +// It is intended for use in games and other systems that need to build +// their own custom widgets and which do not have heavy text-editing +// requirements (this library is not recommended for use for editing large +// texts, as its performance does not scale and it has limited undo). +// +// Non-trivial behaviors are modelled after Windows text controls. +// +// +// LICENSE +// +// See end of file for license information. +// +// +// DEPENDENCIES +// +// Uses the C runtime function 'memmove', which you can override +// by defining STB_TEXTEDIT_memmove before the implementation. +// Uses no other functions. Performs no runtime allocations. +// +// +// VERSION HISTORY +// +// 1.14 (2021-07-11) page up/down, various fixes +// 1.13 (2019-02-07) fix bug in undo size management +// 1.12 (2018-01-29) user can change STB_TEXTEDIT_KEYTYPE, fix redo to avoid crash +// 1.11 (2017-03-03) fix HOME on last line, dragging off single-line textfield +// 1.10 (2016-10-25) supress warnings about casting away const with -Wcast-qual +// 1.9 (2016-08-27) customizable move-by-word +// 1.8 (2016-04-02) better keyboard handling when mouse button is down +// 1.7 (2015-09-13) change y range handling in case baseline is non-0 +// 1.6 (2015-04-15) allow STB_TEXTEDIT_memmove +// 1.5 (2014-09-10) add support for secondary keys for OS X +// 1.4 (2014-08-17) fix signed/unsigned warnings +// 1.3 (2014-06-19) fix mouse clicking to round to nearest char boundary +// 1.2 (2014-05-27) fix some RAD types that had crept into the new code +// 1.1 (2013-12-15) move-by-word (requires STB_TEXTEDIT_IS_SPACE ) +// 1.0 (2012-07-26) improve documentation, initial public release +// 0.3 (2012-02-24) bugfixes, single-line mode; insert mode +// 0.2 (2011-11-28) fixes to undo/redo +// 0.1 (2010-07-08) initial version +// +// ADDITIONAL CONTRIBUTORS +// +// Ulf Winklemann: move-by-word in 1.1 +// Fabian Giesen: secondary key inputs in 1.5 +// Martins Mozeiko: STB_TEXTEDIT_memmove in 1.6 +// Louis Schnellbach: page up/down in 1.14 +// +// Bugfixes: +// Scott Graham +// Daniel Keller +// Omar Cornut +// Dan Thompson +// +// USAGE +// +// This file behaves differently depending on what symbols you define +// before including it. +// +// +// Header-file mode: +// +// If you do not define STB_TEXTEDIT_IMPLEMENTATION before including this, +// it will operate in "header file" mode. In this mode, it declares a +// single public symbol, STB_TexteditState, which encapsulates the current +// state of a text widget (except for the string, which you will store +// separately). +// +// To compile in this mode, you must define STB_TEXTEDIT_CHARTYPE to a +// primitive type that defines a single character (e.g. char, wchar_t, etc). +// +// To save space or increase undo-ability, you can optionally define the +// following things that are used by the undo system: +// +// STB_TEXTEDIT_POSITIONTYPE small int type encoding a valid cursor position +// STB_TEXTEDIT_UNDOSTATECOUNT the number of undo states to allow +// STB_TEXTEDIT_UNDOCHARCOUNT the number of characters to store in the undo buffer +// +// If you don't define these, they are set to permissive types and +// moderate sizes. The undo system does no memory allocations, so +// it grows STB_TexteditState by the worst-case storage which is (in bytes): +// +// [4 + 3 * sizeof(STB_TEXTEDIT_POSITIONTYPE)] * STB_TEXTEDIT_UNDOSTATECOUNT +// + sizeof(STB_TEXTEDIT_CHARTYPE) * STB_TEXTEDIT_UNDOCHARCOUNT +// +// +// Implementation mode: +// +// If you define STB_TEXTEDIT_IMPLEMENTATION before including this, it +// will compile the implementation of the text edit widget, depending +// on a large number of symbols which must be defined before the include. +// +// The implementation is defined only as static functions. You will then +// need to provide your own APIs in the same file which will access the +// static functions. +// +// The basic concept is that you provide a "string" object which +// behaves like an array of characters. stb_textedit uses indices to +// refer to positions in the string, implicitly representing positions +// in the displayed textedit. This is true for both plain text and +// rich text; even with rich text stb_truetype interacts with your +// code as if there was an array of all the displayed characters. +// +// Symbols that must be the same in header-file and implementation mode: +// +// STB_TEXTEDIT_CHARTYPE the character type +// STB_TEXTEDIT_POSITIONTYPE small type that is a valid cursor position +// STB_TEXTEDIT_UNDOSTATECOUNT the number of undo states to allow +// STB_TEXTEDIT_UNDOCHARCOUNT the number of characters to store in the undo buffer +// +// Symbols you must define for implementation mode: +// +// STB_TEXTEDIT_STRING the type of object representing a string being edited, +// typically this is a wrapper object with other data you need +// +// STB_TEXTEDIT_STRINGLEN(obj) the length of the string (ideally O(1)) +// STB_TEXTEDIT_LAYOUTROW(&r,obj,n) returns the results of laying out a line of characters +// starting from character #n (see discussion below) +// STB_TEXTEDIT_GETWIDTH(obj,n,i) returns the pixel delta from the xpos of the i'th character +// to the xpos of the i+1'th char for a line of characters +// starting at character #n (i.e. accounts for kerning +// with previous char) +// STB_TEXTEDIT_KEYTOTEXT(k) maps a keyboard input to an insertable character +// (return type is int, -1 means not valid to insert) +// STB_TEXTEDIT_GETCHAR(obj,i) returns the i'th character of obj, 0-based +// STB_TEXTEDIT_NEWLINE the character returned by _GETCHAR() we recognize +// as manually wordwrapping for end-of-line positioning +// +// STB_TEXTEDIT_DELETECHARS(obj,i,n) delete n characters starting at i +// STB_TEXTEDIT_INSERTCHARS(obj,i,c*,n) insert n characters at i (pointed to by STB_TEXTEDIT_CHARTYPE*) +// +// STB_TEXTEDIT_K_SHIFT a power of two that is or'd in to a keyboard input to represent the shift key +// +// STB_TEXTEDIT_K_LEFT keyboard input to move cursor left +// STB_TEXTEDIT_K_RIGHT keyboard input to move cursor right +// STB_TEXTEDIT_K_UP keyboard input to move cursor up +// STB_TEXTEDIT_K_DOWN keyboard input to move cursor down +// STB_TEXTEDIT_K_PGUP keyboard input to move cursor up a page +// STB_TEXTEDIT_K_PGDOWN keyboard input to move cursor down a page +// STB_TEXTEDIT_K_LINESTART keyboard input to move cursor to start of line // e.g. HOME +// STB_TEXTEDIT_K_LINEEND keyboard input to move cursor to end of line // e.g. END +// STB_TEXTEDIT_K_TEXTSTART keyboard input to move cursor to start of text // e.g. ctrl-HOME +// STB_TEXTEDIT_K_TEXTEND keyboard input to move cursor to end of text // e.g. ctrl-END +// STB_TEXTEDIT_K_DELETE keyboard input to delete selection or character under cursor +// STB_TEXTEDIT_K_BACKSPACE keyboard input to delete selection or character left of cursor +// STB_TEXTEDIT_K_UNDO keyboard input to perform undo +// STB_TEXTEDIT_K_REDO keyboard input to perform redo +// +// Optional: +// STB_TEXTEDIT_K_INSERT keyboard input to toggle insert mode +// STB_TEXTEDIT_IS_SPACE(ch) true if character is whitespace (e.g. 'isspace'), +// required for default WORDLEFT/WORDRIGHT handlers +// STB_TEXTEDIT_MOVEWORDLEFT(obj,i) custom handler for WORDLEFT, returns index to move cursor to +// STB_TEXTEDIT_MOVEWORDRIGHT(obj,i) custom handler for WORDRIGHT, returns index to move cursor to +// STB_TEXTEDIT_K_WORDLEFT keyboard input to move cursor left one word // e.g. ctrl-LEFT +// STB_TEXTEDIT_K_WORDRIGHT keyboard input to move cursor right one word // e.g. ctrl-RIGHT +// STB_TEXTEDIT_K_LINESTART2 secondary keyboard input to move cursor to start of line +// STB_TEXTEDIT_K_LINEEND2 secondary keyboard input to move cursor to end of line +// STB_TEXTEDIT_K_TEXTSTART2 secondary keyboard input to move cursor to start of text +// STB_TEXTEDIT_K_TEXTEND2 secondary keyboard input to move cursor to end of text +// +// Keyboard input must be encoded as a single integer value; e.g. a character code +// and some bitflags that represent shift states. to simplify the interface, SHIFT must +// be a bitflag, so we can test the shifted state of cursor movements to allow selection, +// i.e. (STB_TEXTEDIT_K_RIGHT|STB_TEXTEDIT_K_SHIFT) should be shifted right-arrow. +// +// You can encode other things, such as CONTROL or ALT, in additional bits, and +// then test for their presence in e.g. STB_TEXTEDIT_K_WORDLEFT. For example, +// my Windows implementations add an additional CONTROL bit, and an additional KEYDOWN +// bit. Then all of the STB_TEXTEDIT_K_ values bitwise-or in the KEYDOWN bit, +// and I pass both WM_KEYDOWN and WM_CHAR events to the "key" function in the +// API below. The control keys will only match WM_KEYDOWN events because of the +// keydown bit I add, and STB_TEXTEDIT_KEYTOTEXT only tests for the KEYDOWN +// bit so it only decodes WM_CHAR events. +// +// STB_TEXTEDIT_LAYOUTROW returns information about the shape of one displayed +// row of characters assuming they start on the i'th character--the width and +// the height and the number of characters consumed. This allows this library +// to traverse the entire layout incrementally. You need to compute word-wrapping +// here. +// +// Each textfield keeps its own insert mode state, which is not how normal +// applications work. To keep an app-wide insert mode, update/copy the +// "insert_mode" field of STB_TexteditState before/after calling API functions. +// +// API +// +// void stb_textedit_initialize_state(STB_TexteditState *state, int is_single_line) +// +// void stb_textedit_click(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, float x, float y) +// void stb_textedit_drag(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, float x, float y) +// int stb_textedit_cut(STB_TEXTEDIT_STRING *str, STB_TexteditState *state) +// int stb_textedit_paste(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, STB_TEXTEDIT_CHARTYPE *text, int len) +// void stb_textedit_key(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, STB_TEXEDIT_KEYTYPE key) +// +// Each of these functions potentially updates the string and updates the +// state. +// +// initialize_state: +// set the textedit state to a known good default state when initially +// constructing the textedit. +// +// click: +// call this with the mouse x,y on a mouse down; it will update the cursor +// and reset the selection start/end to the cursor point. the x,y must +// be relative to the text widget, with (0,0) being the top left. +// +// drag: +// call this with the mouse x,y on a mouse drag/up; it will update the +// cursor and the selection end point +// +// cut: +// call this to delete the current selection; returns true if there was +// one. you should FIRST copy the current selection to the system paste buffer. +// (To copy, just copy the current selection out of the string yourself.) +// +// paste: +// call this to paste text at the current cursor point or over the current +// selection if there is one. +// +// key: +// call this for keyboard inputs sent to the textfield. you can use it +// for "key down" events or for "translated" key events. if you need to +// do both (as in Win32), or distinguish Unicode characters from control +// inputs, set a high bit to distinguish the two; then you can define the +// various definitions like STB_TEXTEDIT_K_LEFT have the is-key-event bit +// set, and make STB_TEXTEDIT_KEYTOCHAR check that the is-key-event bit is +// clear. STB_TEXTEDIT_KEYTYPE defaults to int, but you can #define it to +// anything other type you wante before including. +// +// +// When rendering, you can read the cursor position and selection state from +// the STB_TexteditState. +// +// +// Notes: +// +// This is designed to be usable in IMGUI, so it allows for the possibility of +// running in an IMGUI that has NOT cached the multi-line layout. For this +// reason, it provides an interface that is compatible with computing the +// layout incrementally--we try to make sure we make as few passes through +// as possible. (For example, to locate the mouse pointer in the text, we +// could define functions that return the X and Y positions of characters +// and binary search Y and then X, but if we're doing dynamic layout this +// will run the layout algorithm many times, so instead we manually search +// forward in one pass. Similar logic applies to e.g. up-arrow and +// down-arrow movement.) +// +// If it's run in a widget that *has* cached the layout, then this is less +// efficient, but it's not horrible on modern computers. But you wouldn't +// want to edit million-line files with it. + + +//////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////// +//// +//// Header-file mode +//// +//// + +#ifndef INCLUDE_STB_TEXTEDIT_H +#define INCLUDE_STB_TEXTEDIT_H + +//////////////////////////////////////////////////////////////////////// +// +// STB_TexteditState +// +// Definition of STB_TexteditState which you should store +// per-textfield; it includes cursor position, selection state, +// and undo state. +// + +#ifndef STB_TEXTEDIT_UNDOSTATECOUNT +#define STB_TEXTEDIT_UNDOSTATECOUNT 99 +#endif +#ifndef STB_TEXTEDIT_UNDOCHARCOUNT +#define STB_TEXTEDIT_UNDOCHARCOUNT 999 +#endif +#ifndef STB_TEXTEDIT_CHARTYPE +#define STB_TEXTEDIT_CHARTYPE int +#endif +#ifndef STB_TEXTEDIT_POSITIONTYPE +#define STB_TEXTEDIT_POSITIONTYPE int +#endif + +typedef struct +{ + // private data + STB_TEXTEDIT_POSITIONTYPE where; + STB_TEXTEDIT_POSITIONTYPE insert_length; + STB_TEXTEDIT_POSITIONTYPE delete_length; + int char_storage; +} StbUndoRecord; + +typedef struct +{ + // private data + StbUndoRecord undo_rec [STB_TEXTEDIT_UNDOSTATECOUNT]; + STB_TEXTEDIT_CHARTYPE undo_char[STB_TEXTEDIT_UNDOCHARCOUNT]; + short undo_point, redo_point; + int undo_char_point, redo_char_point; +} StbUndoState; + +typedef struct +{ + ///////////////////// + // + // public data + // + + int cursor; + // position of the text cursor within the string + + int select_start; // selection start point + int select_end; + // selection start and end point in characters; if equal, no selection. + // note that start may be less than or greater than end (e.g. when + // dragging the mouse, start is where the initial click was, and you + // can drag in either direction) + + unsigned char insert_mode; + // each textfield keeps its own insert mode state. to keep an app-wide + // insert mode, copy this value in/out of the app state + + int row_count_per_page; + // page size in number of row. + // this value MUST be set to >0 for pageup or pagedown in multilines documents. + + ///////////////////// + // + // private data + // + unsigned char cursor_at_end_of_line; // not implemented yet + unsigned char initialized; + unsigned char has_preferred_x; + unsigned char single_line; + unsigned char padding1, padding2, padding3; + float preferred_x; // this determines where the cursor up/down tries to seek to along x + StbUndoState undostate; +} STB_TexteditState; + + +//////////////////////////////////////////////////////////////////////// +// +// StbTexteditRow +// +// Result of layout query, used by stb_textedit to determine where +// the text in each row is. + +// result of layout query +typedef struct +{ + float x0,x1; // starting x location, end x location (allows for align=right, etc) + float baseline_y_delta; // position of baseline relative to previous row's baseline + float ymin,ymax; // height of row above and below baseline + int num_chars; +} StbTexteditRow; +#endif //INCLUDE_STB_TEXTEDIT_H + + +//////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////// +//// +//// Implementation mode +//// +//// + + +// implementation isn't include-guarded, since it might have indirectly +// included just the "header" portion +#ifdef STB_TEXTEDIT_IMPLEMENTATION + +#ifndef STB_TEXTEDIT_memmove +#include +#define STB_TEXTEDIT_memmove memmove +#endif + + +///////////////////////////////////////////////////////////////////////////// +// +// Mouse input handling +// + +// traverse the layout to locate the nearest character to a display position +static int stb_text_locate_coord(STB_TEXTEDIT_STRING *str, float x, float y) +{ + StbTexteditRow r; + int n = STB_TEXTEDIT_STRINGLEN(str); + float base_y = 0, prev_x; + int i=0, k; + + r.x0 = r.x1 = 0; + r.ymin = r.ymax = 0; + r.num_chars = 0; + + // search rows to find one that straddles 'y' + while (i < n) { + STB_TEXTEDIT_LAYOUTROW(&r, str, i); + if (r.num_chars <= 0) + return n; + + if (i==0 && y < base_y + r.ymin) + return 0; + + if (y < base_y + r.ymax) + break; + + i += r.num_chars; + base_y += r.baseline_y_delta; + } + + // below all text, return 'after' last character + if (i >= n) + return n; + + // check if it's before the beginning of the line + if (x < r.x0) + return i; + + // check if it's before the end of the line + if (x < r.x1) { + // search characters in row for one that straddles 'x' + prev_x = r.x0; + for (k=0; k < r.num_chars; ++k) { + float w = STB_TEXTEDIT_GETWIDTH(str, i, k); + if (x < prev_x+w) { + if (x < prev_x+w/2) + return k+i; + else + return k+i+1; + } + prev_x += w; + } + // shouldn't happen, but if it does, fall through to end-of-line case + } + + // if the last character is a newline, return that. otherwise return 'after' the last character + if (STB_TEXTEDIT_GETCHAR(str, i+r.num_chars-1) == STB_TEXTEDIT_NEWLINE) + return i+r.num_chars-1; + else + return i+r.num_chars; +} + +// API click: on mouse down, move the cursor to the clicked location, and reset the selection +static void stb_textedit_click(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, float x, float y) +{ + // In single-line mode, just always make y = 0. This lets the drag keep working if the mouse + // goes off the top or bottom of the text + if( state->single_line ) + { + StbTexteditRow r; + STB_TEXTEDIT_LAYOUTROW(&r, str, 0); + y = r.ymin; + } + + state->cursor = stb_text_locate_coord(str, x, y); + state->select_start = state->cursor; + state->select_end = state->cursor; + state->has_preferred_x = 0; +} + +// API drag: on mouse drag, move the cursor and selection endpoint to the clicked location +static void stb_textedit_drag(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, float x, float y) +{ + int p = 0; + + // In single-line mode, just always make y = 0. This lets the drag keep working if the mouse + // goes off the top or bottom of the text + if( state->single_line ) + { + StbTexteditRow r; + STB_TEXTEDIT_LAYOUTROW(&r, str, 0); + y = r.ymin; + } + + if (state->select_start == state->select_end) + state->select_start = state->cursor; + + p = stb_text_locate_coord(str, x, y); + state->cursor = state->select_end = p; +} + +///////////////////////////////////////////////////////////////////////////// +// +// Keyboard input handling +// + +// forward declarations +static void stb_text_undo(STB_TEXTEDIT_STRING *str, STB_TexteditState *state); +static void stb_text_redo(STB_TEXTEDIT_STRING *str, STB_TexteditState *state); +static void stb_text_makeundo_delete(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, int where, int length); +static void stb_text_makeundo_insert(STB_TexteditState *state, int where, int length); +static void stb_text_makeundo_replace(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, int where, int old_length, int new_length); + +typedef struct +{ + float x,y; // position of n'th character + float height; // height of line + int first_char, length; // first char of row, and length + int prev_first; // first char of previous row +} StbFindState; + +// find the x/y location of a character, and remember info about the previous row in +// case we get a move-up event (for page up, we'll have to rescan) +static void stb_textedit_find_charpos(StbFindState *find, STB_TEXTEDIT_STRING *str, int n, int single_line) +{ + StbTexteditRow r; + int prev_start = 0; + int z = STB_TEXTEDIT_STRINGLEN(str); + int i=0, first; + + if (n == z) { + // if it's at the end, then find the last line -- simpler than trying to + // explicitly handle this case in the regular code + if (single_line) { + STB_TEXTEDIT_LAYOUTROW(&r, str, 0); + find->y = 0; + find->first_char = 0; + find->length = z; + find->height = r.ymax - r.ymin; + find->x = r.x1; + } else { + find->y = 0; + find->x = 0; + find->height = 1; + while (i < z) { + STB_TEXTEDIT_LAYOUTROW(&r, str, i); + prev_start = i; + i += r.num_chars; + } + find->first_char = i; + find->length = 0; + find->prev_first = prev_start; + } + return; + } + + // search rows to find the one that straddles character n + find->y = 0; + + for(;;) { + STB_TEXTEDIT_LAYOUTROW(&r, str, i); + if (n < i + r.num_chars) + break; + prev_start = i; + i += r.num_chars; + find->y += r.baseline_y_delta; + } + + find->first_char = first = i; + find->length = r.num_chars; + find->height = r.ymax - r.ymin; + find->prev_first = prev_start; + + // now scan to find xpos + find->x = r.x0; + for (i=0; first+i < n; ++i) + find->x += STB_TEXTEDIT_GETWIDTH(str, first, i); +} + +#define STB_TEXT_HAS_SELECTION(s) ((s)->select_start != (s)->select_end) + +// make the selection/cursor state valid if client altered the string +static void stb_textedit_clamp(STB_TEXTEDIT_STRING *str, STB_TexteditState *state) +{ + int n = STB_TEXTEDIT_STRINGLEN(str); + if (STB_TEXT_HAS_SELECTION(state)) { + if (state->select_start > n) state->select_start = n; + if (state->select_end > n) state->select_end = n; + // if clamping forced them to be equal, move the cursor to match + if (state->select_start == state->select_end) + state->cursor = state->select_start; + } + if (state->cursor > n) state->cursor = n; +} + +// delete characters while updating undo +static void stb_textedit_delete(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, int where, int len) +{ + stb_text_makeundo_delete(str, state, where, len); + STB_TEXTEDIT_DELETECHARS(str, where, len); + state->has_preferred_x = 0; +} + +// delete the section +static void stb_textedit_delete_selection(STB_TEXTEDIT_STRING *str, STB_TexteditState *state) +{ + stb_textedit_clamp(str, state); + if (STB_TEXT_HAS_SELECTION(state)) { + if (state->select_start < state->select_end) { + stb_textedit_delete(str, state, state->select_start, state->select_end - state->select_start); + state->select_end = state->cursor = state->select_start; + } else { + stb_textedit_delete(str, state, state->select_end, state->select_start - state->select_end); + state->select_start = state->cursor = state->select_end; + } + state->has_preferred_x = 0; + } +} + +// canoncialize the selection so start <= end +static void stb_textedit_sortselection(STB_TexteditState *state) +{ + if (state->select_end < state->select_start) { + int temp = state->select_end; + state->select_end = state->select_start; + state->select_start = temp; + } +} + +// move cursor to first character of selection +static void stb_textedit_move_to_first(STB_TexteditState *state) +{ + if (STB_TEXT_HAS_SELECTION(state)) { + stb_textedit_sortselection(state); + state->cursor = state->select_start; + state->select_end = state->select_start; + state->has_preferred_x = 0; + } +} + +// move cursor to last character of selection +static void stb_textedit_move_to_last(STB_TEXTEDIT_STRING *str, STB_TexteditState *state) +{ + if (STB_TEXT_HAS_SELECTION(state)) { + stb_textedit_sortselection(state); + stb_textedit_clamp(str, state); + state->cursor = state->select_end; + state->select_start = state->select_end; + state->has_preferred_x = 0; + } +} + +#ifdef STB_TEXTEDIT_IS_SPACE +static int is_word_boundary( STB_TEXTEDIT_STRING *str, int idx ) +{ + return idx > 0 ? (STB_TEXTEDIT_IS_SPACE( STB_TEXTEDIT_GETCHAR(str,idx-1) ) && !STB_TEXTEDIT_IS_SPACE( STB_TEXTEDIT_GETCHAR(str, idx) ) ) : 1; +} + +#ifndef STB_TEXTEDIT_MOVEWORDLEFT +static int stb_textedit_move_to_word_previous( STB_TEXTEDIT_STRING *str, int c ) +{ + --c; // always move at least one character + while( c >= 0 && !is_word_boundary( str, c ) ) + --c; + + if( c < 0 ) + c = 0; + + return c; +} +#define STB_TEXTEDIT_MOVEWORDLEFT stb_textedit_move_to_word_previous +#endif + +#ifndef STB_TEXTEDIT_MOVEWORDRIGHT +static int stb_textedit_move_to_word_next( STB_TEXTEDIT_STRING *str, int c ) +{ + const int len = STB_TEXTEDIT_STRINGLEN(str); + ++c; // always move at least one character + while( c < len && !is_word_boundary( str, c ) ) + ++c; + + if( c > len ) + c = len; + + return c; +} +#define STB_TEXTEDIT_MOVEWORDRIGHT stb_textedit_move_to_word_next +#endif + +#endif + +// update selection and cursor to match each other +static void stb_textedit_prep_selection_at_cursor(STB_TexteditState *state) +{ + if (!STB_TEXT_HAS_SELECTION(state)) + state->select_start = state->select_end = state->cursor; + else + state->cursor = state->select_end; +} + +// API cut: delete selection +static int stb_textedit_cut(STB_TEXTEDIT_STRING *str, STB_TexteditState *state) +{ + if (STB_TEXT_HAS_SELECTION(state)) { + stb_textedit_delete_selection(str,state); // implicitly clamps + state->has_preferred_x = 0; + return 1; + } + return 0; +} + +// API paste: replace existing selection with passed-in text +static int stb_textedit_paste_internal(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, STB_TEXTEDIT_CHARTYPE *text, int len) +{ + // if there's a selection, the paste should delete it + stb_textedit_clamp(str, state); + stb_textedit_delete_selection(str,state); + // try to insert the characters + if (STB_TEXTEDIT_INSERTCHARS(str, state->cursor, text, len)) { + stb_text_makeundo_insert(state, state->cursor, len); + state->cursor += len; + state->has_preferred_x = 0; + return 1; + } + // note: paste failure will leave deleted selection, may be restored with an undo (see https://github.com/nothings/stb/issues/734 for details) + return 0; +} + +#ifndef STB_TEXTEDIT_KEYTYPE +#define STB_TEXTEDIT_KEYTYPE int +#endif + +// API key: process a keyboard input +static void stb_textedit_key(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, STB_TEXTEDIT_KEYTYPE key) +{ +retry: + switch (key) { + default: { + int c = STB_TEXTEDIT_KEYTOTEXT(key); + if (c > 0) { + STB_TEXTEDIT_CHARTYPE ch = (STB_TEXTEDIT_CHARTYPE) c; + + // can't add newline in single-line mode + if (c == '\n' && state->single_line) + break; + + if (state->insert_mode && !STB_TEXT_HAS_SELECTION(state) && state->cursor < STB_TEXTEDIT_STRINGLEN(str)) { + stb_text_makeundo_replace(str, state, state->cursor, 1, 1); + STB_TEXTEDIT_DELETECHARS(str, state->cursor, 1); + if (STB_TEXTEDIT_INSERTCHARS(str, state->cursor, &ch, 1)) { + ++state->cursor; + state->has_preferred_x = 0; + } + } else { + stb_textedit_delete_selection(str,state); // implicitly clamps + if (STB_TEXTEDIT_INSERTCHARS(str, state->cursor, &ch, 1)) { + stb_text_makeundo_insert(state, state->cursor, 1); + ++state->cursor; + state->has_preferred_x = 0; + } + } + } + break; + } + +#ifdef STB_TEXTEDIT_K_INSERT + case STB_TEXTEDIT_K_INSERT: + state->insert_mode = !state->insert_mode; + break; +#endif + + case STB_TEXTEDIT_K_UNDO: + stb_text_undo(str, state); + state->has_preferred_x = 0; + break; + + case STB_TEXTEDIT_K_REDO: + stb_text_redo(str, state); + state->has_preferred_x = 0; + break; + + case STB_TEXTEDIT_K_LEFT: + // if currently there's a selection, move cursor to start of selection + if (STB_TEXT_HAS_SELECTION(state)) + stb_textedit_move_to_first(state); + else + if (state->cursor > 0) + --state->cursor; + state->has_preferred_x = 0; + break; + + case STB_TEXTEDIT_K_RIGHT: + // if currently there's a selection, move cursor to end of selection + if (STB_TEXT_HAS_SELECTION(state)) + stb_textedit_move_to_last(str, state); + else + ++state->cursor; + stb_textedit_clamp(str, state); + state->has_preferred_x = 0; + break; + + case STB_TEXTEDIT_K_LEFT | STB_TEXTEDIT_K_SHIFT: + stb_textedit_clamp(str, state); + stb_textedit_prep_selection_at_cursor(state); + // move selection left + if (state->select_end > 0) + --state->select_end; + state->cursor = state->select_end; + state->has_preferred_x = 0; + break; + +#ifdef STB_TEXTEDIT_MOVEWORDLEFT + case STB_TEXTEDIT_K_WORDLEFT: + if (STB_TEXT_HAS_SELECTION(state)) + stb_textedit_move_to_first(state); + else { + state->cursor = STB_TEXTEDIT_MOVEWORDLEFT(str, state->cursor); + stb_textedit_clamp( str, state ); + } + break; + + case STB_TEXTEDIT_K_WORDLEFT | STB_TEXTEDIT_K_SHIFT: + if( !STB_TEXT_HAS_SELECTION( state ) ) + stb_textedit_prep_selection_at_cursor(state); + + state->cursor = STB_TEXTEDIT_MOVEWORDLEFT(str, state->cursor); + state->select_end = state->cursor; + + stb_textedit_clamp( str, state ); + break; +#endif + +#ifdef STB_TEXTEDIT_MOVEWORDRIGHT + case STB_TEXTEDIT_K_WORDRIGHT: + if (STB_TEXT_HAS_SELECTION(state)) + stb_textedit_move_to_last(str, state); + else { + state->cursor = STB_TEXTEDIT_MOVEWORDRIGHT(str, state->cursor); + stb_textedit_clamp( str, state ); + } + break; + + case STB_TEXTEDIT_K_WORDRIGHT | STB_TEXTEDIT_K_SHIFT: + if( !STB_TEXT_HAS_SELECTION( state ) ) + stb_textedit_prep_selection_at_cursor(state); + + state->cursor = STB_TEXTEDIT_MOVEWORDRIGHT(str, state->cursor); + state->select_end = state->cursor; + + stb_textedit_clamp( str, state ); + break; +#endif + + case STB_TEXTEDIT_K_RIGHT | STB_TEXTEDIT_K_SHIFT: + stb_textedit_prep_selection_at_cursor(state); + // move selection right + ++state->select_end; + stb_textedit_clamp(str, state); + state->cursor = state->select_end; + state->has_preferred_x = 0; + break; + + case STB_TEXTEDIT_K_DOWN: + case STB_TEXTEDIT_K_DOWN | STB_TEXTEDIT_K_SHIFT: + case STB_TEXTEDIT_K_PGDOWN: + case STB_TEXTEDIT_K_PGDOWN | STB_TEXTEDIT_K_SHIFT: { + StbFindState find; + StbTexteditRow row; + int i, j, sel = (key & STB_TEXTEDIT_K_SHIFT) != 0; + int is_page = (key & ~STB_TEXTEDIT_K_SHIFT) == STB_TEXTEDIT_K_PGDOWN; + int row_count = is_page ? state->row_count_per_page : 1; + + if (!is_page && state->single_line) { + // on windows, up&down in single-line behave like left&right + key = STB_TEXTEDIT_K_RIGHT | (key & STB_TEXTEDIT_K_SHIFT); + goto retry; + } + + if (sel) + stb_textedit_prep_selection_at_cursor(state); + else if (STB_TEXT_HAS_SELECTION(state)) + stb_textedit_move_to_last(str, state); + + // compute current position of cursor point + stb_textedit_clamp(str, state); + stb_textedit_find_charpos(&find, str, state->cursor, state->single_line); + + for (j = 0; j < row_count; ++j) { + float x, goal_x = state->has_preferred_x ? state->preferred_x : find.x; + int start = find.first_char + find.length; + + if (find.length == 0) + break; + + // now find character position down a row + state->cursor = start; + STB_TEXTEDIT_LAYOUTROW(&row, str, state->cursor); + x = row.x0; + for (i=0; i < row.num_chars; ++i) { + float dx = STB_TEXTEDIT_GETWIDTH(str, start, i); + #ifdef STB_TEXTEDIT_GETWIDTH_NEWLINE + if (dx == STB_TEXTEDIT_GETWIDTH_NEWLINE) + break; + #endif + x += dx; + if (x > goal_x) + break; + ++state->cursor; + } + stb_textedit_clamp(str, state); + + state->has_preferred_x = 1; + state->preferred_x = goal_x; + + if (sel) + state->select_end = state->cursor; + + // go to next line + find.first_char = find.first_char + find.length; + find.length = row.num_chars; + } + break; + } + + case STB_TEXTEDIT_K_UP: + case STB_TEXTEDIT_K_UP | STB_TEXTEDIT_K_SHIFT: + case STB_TEXTEDIT_K_PGUP: + case STB_TEXTEDIT_K_PGUP | STB_TEXTEDIT_K_SHIFT: { + StbFindState find; + StbTexteditRow row; + int i, j, prev_scan, sel = (key & STB_TEXTEDIT_K_SHIFT) != 0; + int is_page = (key & ~STB_TEXTEDIT_K_SHIFT) == STB_TEXTEDIT_K_PGUP; + int row_count = is_page ? state->row_count_per_page : 1; + + if (!is_page && state->single_line) { + // on windows, up&down become left&right + key = STB_TEXTEDIT_K_LEFT | (key & STB_TEXTEDIT_K_SHIFT); + goto retry; + } + + if (sel) + stb_textedit_prep_selection_at_cursor(state); + else if (STB_TEXT_HAS_SELECTION(state)) + stb_textedit_move_to_first(state); + + // compute current position of cursor point + stb_textedit_clamp(str, state); + stb_textedit_find_charpos(&find, str, state->cursor, state->single_line); + + for (j = 0; j < row_count; ++j) { + float x, goal_x = state->has_preferred_x ? state->preferred_x : find.x; + + // can only go up if there's a previous row + if (find.prev_first == find.first_char) + break; + + // now find character position up a row + state->cursor = find.prev_first; + STB_TEXTEDIT_LAYOUTROW(&row, str, state->cursor); + x = row.x0; + for (i=0; i < row.num_chars; ++i) { + float dx = STB_TEXTEDIT_GETWIDTH(str, find.prev_first, i); + #ifdef STB_TEXTEDIT_GETWIDTH_NEWLINE + if (dx == STB_TEXTEDIT_GETWIDTH_NEWLINE) + break; + #endif + x += dx; + if (x > goal_x) + break; + ++state->cursor; + } + stb_textedit_clamp(str, state); + + state->has_preferred_x = 1; + state->preferred_x = goal_x; + + if (sel) + state->select_end = state->cursor; + + // go to previous line + // (we need to scan previous line the hard way. maybe we could expose this as a new API function?) + prev_scan = find.prev_first > 0 ? find.prev_first - 1 : 0; + while (prev_scan > 0 && STB_TEXTEDIT_GETCHAR(str, prev_scan - 1) != STB_TEXTEDIT_NEWLINE) + --prev_scan; + find.first_char = find.prev_first; + find.prev_first = prev_scan; + } + break; + } + + case STB_TEXTEDIT_K_DELETE: + case STB_TEXTEDIT_K_DELETE | STB_TEXTEDIT_K_SHIFT: + if (STB_TEXT_HAS_SELECTION(state)) + stb_textedit_delete_selection(str, state); + else { + int n = STB_TEXTEDIT_STRINGLEN(str); + if (state->cursor < n) + stb_textedit_delete(str, state, state->cursor, 1); + } + state->has_preferred_x = 0; + break; + + case STB_TEXTEDIT_K_BACKSPACE: + case STB_TEXTEDIT_K_BACKSPACE | STB_TEXTEDIT_K_SHIFT: + if (STB_TEXT_HAS_SELECTION(state)) + stb_textedit_delete_selection(str, state); + else { + stb_textedit_clamp(str, state); + if (state->cursor > 0) { + stb_textedit_delete(str, state, state->cursor-1, 1); + --state->cursor; + } + } + state->has_preferred_x = 0; + break; + +#ifdef STB_TEXTEDIT_K_TEXTSTART2 + case STB_TEXTEDIT_K_TEXTSTART2: +#endif + case STB_TEXTEDIT_K_TEXTSTART: + state->cursor = state->select_start = state->select_end = 0; + state->has_preferred_x = 0; + break; + +#ifdef STB_TEXTEDIT_K_TEXTEND2 + case STB_TEXTEDIT_K_TEXTEND2: +#endif + case STB_TEXTEDIT_K_TEXTEND: + state->cursor = STB_TEXTEDIT_STRINGLEN(str); + state->select_start = state->select_end = 0; + state->has_preferred_x = 0; + break; + +#ifdef STB_TEXTEDIT_K_TEXTSTART2 + case STB_TEXTEDIT_K_TEXTSTART2 | STB_TEXTEDIT_K_SHIFT: +#endif + case STB_TEXTEDIT_K_TEXTSTART | STB_TEXTEDIT_K_SHIFT: + stb_textedit_prep_selection_at_cursor(state); + state->cursor = state->select_end = 0; + state->has_preferred_x = 0; + break; + +#ifdef STB_TEXTEDIT_K_TEXTEND2 + case STB_TEXTEDIT_K_TEXTEND2 | STB_TEXTEDIT_K_SHIFT: +#endif + case STB_TEXTEDIT_K_TEXTEND | STB_TEXTEDIT_K_SHIFT: + stb_textedit_prep_selection_at_cursor(state); + state->cursor = state->select_end = STB_TEXTEDIT_STRINGLEN(str); + state->has_preferred_x = 0; + break; + + +#ifdef STB_TEXTEDIT_K_LINESTART2 + case STB_TEXTEDIT_K_LINESTART2: +#endif + case STB_TEXTEDIT_K_LINESTART: + stb_textedit_clamp(str, state); + stb_textedit_move_to_first(state); + if (state->single_line) + state->cursor = 0; + else while (state->cursor > 0 && STB_TEXTEDIT_GETCHAR(str, state->cursor-1) != STB_TEXTEDIT_NEWLINE) + --state->cursor; + state->has_preferred_x = 0; + break; + +#ifdef STB_TEXTEDIT_K_LINEEND2 + case STB_TEXTEDIT_K_LINEEND2: +#endif + case STB_TEXTEDIT_K_LINEEND: { + int n = STB_TEXTEDIT_STRINGLEN(str); + stb_textedit_clamp(str, state); + stb_textedit_move_to_first(state); + if (state->single_line) + state->cursor = n; + else while (state->cursor < n && STB_TEXTEDIT_GETCHAR(str, state->cursor) != STB_TEXTEDIT_NEWLINE) + ++state->cursor; + state->has_preferred_x = 0; + break; + } + +#ifdef STB_TEXTEDIT_K_LINESTART2 + case STB_TEXTEDIT_K_LINESTART2 | STB_TEXTEDIT_K_SHIFT: +#endif + case STB_TEXTEDIT_K_LINESTART | STB_TEXTEDIT_K_SHIFT: + stb_textedit_clamp(str, state); + stb_textedit_prep_selection_at_cursor(state); + if (state->single_line) + state->cursor = 0; + else while (state->cursor > 0 && STB_TEXTEDIT_GETCHAR(str, state->cursor-1) != STB_TEXTEDIT_NEWLINE) + --state->cursor; + state->select_end = state->cursor; + state->has_preferred_x = 0; + break; + +#ifdef STB_TEXTEDIT_K_LINEEND2 + case STB_TEXTEDIT_K_LINEEND2 | STB_TEXTEDIT_K_SHIFT: +#endif + case STB_TEXTEDIT_K_LINEEND | STB_TEXTEDIT_K_SHIFT: { + int n = STB_TEXTEDIT_STRINGLEN(str); + stb_textedit_clamp(str, state); + stb_textedit_prep_selection_at_cursor(state); + if (state->single_line) + state->cursor = n; + else while (state->cursor < n && STB_TEXTEDIT_GETCHAR(str, state->cursor) != STB_TEXTEDIT_NEWLINE) + ++state->cursor; + state->select_end = state->cursor; + state->has_preferred_x = 0; + break; + } + } +} + +///////////////////////////////////////////////////////////////////////////// +// +// Undo processing +// +// @OPTIMIZE: the undo/redo buffer should be circular + +static void stb_textedit_flush_redo(StbUndoState *state) +{ + state->redo_point = STB_TEXTEDIT_UNDOSTATECOUNT; + state->redo_char_point = STB_TEXTEDIT_UNDOCHARCOUNT; +} + +// discard the oldest entry in the undo list +static void stb_textedit_discard_undo(StbUndoState *state) +{ + if (state->undo_point > 0) { + // if the 0th undo state has characters, clean those up + if (state->undo_rec[0].char_storage >= 0) { + int n = state->undo_rec[0].insert_length, i; + // delete n characters from all other records + state->undo_char_point -= n; + STB_TEXTEDIT_memmove(state->undo_char, state->undo_char + n, (size_t) (state->undo_char_point*sizeof(STB_TEXTEDIT_CHARTYPE))); + for (i=0; i < state->undo_point; ++i) + if (state->undo_rec[i].char_storage >= 0) + state->undo_rec[i].char_storage -= n; // @OPTIMIZE: get rid of char_storage and infer it + } + --state->undo_point; + STB_TEXTEDIT_memmove(state->undo_rec, state->undo_rec+1, (size_t) (state->undo_point*sizeof(state->undo_rec[0]))); + } +} + +// discard the oldest entry in the redo list--it's bad if this +// ever happens, but because undo & redo have to store the actual +// characters in different cases, the redo character buffer can +// fill up even though the undo buffer didn't +static void stb_textedit_discard_redo(StbUndoState *state) +{ + int k = STB_TEXTEDIT_UNDOSTATECOUNT-1; + + if (state->redo_point <= k) { + // if the k'th undo state has characters, clean those up + if (state->undo_rec[k].char_storage >= 0) { + int n = state->undo_rec[k].insert_length, i; + // move the remaining redo character data to the end of the buffer + state->redo_char_point += n; + STB_TEXTEDIT_memmove(state->undo_char + state->redo_char_point, state->undo_char + state->redo_char_point-n, (size_t) ((STB_TEXTEDIT_UNDOCHARCOUNT - state->redo_char_point)*sizeof(STB_TEXTEDIT_CHARTYPE))); + // adjust the position of all the other records to account for above memmove + for (i=state->redo_point; i < k; ++i) + if (state->undo_rec[i].char_storage >= 0) + state->undo_rec[i].char_storage += n; + } + // now move all the redo records towards the end of the buffer; the first one is at 'redo_point' + STB_TEXTEDIT_memmove(state->undo_rec + state->redo_point+1, state->undo_rec + state->redo_point, (size_t) ((STB_TEXTEDIT_UNDOSTATECOUNT - state->redo_point)*sizeof(state->undo_rec[0]))); + // now move redo_point to point to the new one + ++state->redo_point; + } +} + +static StbUndoRecord *stb_text_create_undo_record(StbUndoState *state, int numchars) +{ + // any time we create a new undo record, we discard redo + stb_textedit_flush_redo(state); + + // if we have no free records, we have to make room, by sliding the + // existing records down + if (state->undo_point == STB_TEXTEDIT_UNDOSTATECOUNT) + stb_textedit_discard_undo(state); + + // if the characters to store won't possibly fit in the buffer, we can't undo + if (numchars > STB_TEXTEDIT_UNDOCHARCOUNT) { + state->undo_point = 0; + state->undo_char_point = 0; + return NULL; + } + + // if we don't have enough free characters in the buffer, we have to make room + while (state->undo_char_point + numchars > STB_TEXTEDIT_UNDOCHARCOUNT) + stb_textedit_discard_undo(state); + + return &state->undo_rec[state->undo_point++]; +} + +static STB_TEXTEDIT_CHARTYPE *stb_text_createundo(StbUndoState *state, int pos, int insert_len, int delete_len) +{ + StbUndoRecord *r = stb_text_create_undo_record(state, insert_len); + if (r == NULL) + return NULL; + + r->where = pos; + r->insert_length = (STB_TEXTEDIT_POSITIONTYPE) insert_len; + r->delete_length = (STB_TEXTEDIT_POSITIONTYPE) delete_len; + + if (insert_len == 0) { + r->char_storage = -1; + return NULL; + } else { + r->char_storage = state->undo_char_point; + state->undo_char_point += insert_len; + return &state->undo_char[r->char_storage]; + } +} + +static void stb_text_undo(STB_TEXTEDIT_STRING *str, STB_TexteditState *state) +{ + StbUndoState *s = &state->undostate; + StbUndoRecord u, *r; + if (s->undo_point == 0) + return; + + // we need to do two things: apply the undo record, and create a redo record + u = s->undo_rec[s->undo_point-1]; + r = &s->undo_rec[s->redo_point-1]; + r->char_storage = -1; + + r->insert_length = u.delete_length; + r->delete_length = u.insert_length; + r->where = u.where; + + if (u.delete_length) { + // if the undo record says to delete characters, then the redo record will + // need to re-insert the characters that get deleted, so we need to store + // them. + + // there are three cases: + // there's enough room to store the characters + // characters stored for *redoing* don't leave room for redo + // characters stored for *undoing* don't leave room for redo + // if the last is true, we have to bail + + if (s->undo_char_point + u.delete_length >= STB_TEXTEDIT_UNDOCHARCOUNT) { + // the undo records take up too much character space; there's no space to store the redo characters + r->insert_length = 0; + } else { + int i; + + // there's definitely room to store the characters eventually + while (s->undo_char_point + u.delete_length > s->redo_char_point) { + // should never happen: + if (s->redo_point == STB_TEXTEDIT_UNDOSTATECOUNT) + return; + // there's currently not enough room, so discard a redo record + stb_textedit_discard_redo(s); + } + r = &s->undo_rec[s->redo_point-1]; + + r->char_storage = s->redo_char_point - u.delete_length; + s->redo_char_point = s->redo_char_point - u.delete_length; + + // now save the characters + for (i=0; i < u.delete_length; ++i) + s->undo_char[r->char_storage + i] = STB_TEXTEDIT_GETCHAR(str, u.where + i); + } + + // now we can carry out the deletion + STB_TEXTEDIT_DELETECHARS(str, u.where, u.delete_length); + } + + // check type of recorded action: + if (u.insert_length) { + // easy case: was a deletion, so we need to insert n characters + STB_TEXTEDIT_INSERTCHARS(str, u.where, &s->undo_char[u.char_storage], u.insert_length); + s->undo_char_point -= u.insert_length; + } + + state->cursor = u.where + u.insert_length; + + s->undo_point--; + s->redo_point--; +} + +static void stb_text_redo(STB_TEXTEDIT_STRING *str, STB_TexteditState *state) +{ + StbUndoState *s = &state->undostate; + StbUndoRecord *u, r; + if (s->redo_point == STB_TEXTEDIT_UNDOSTATECOUNT) + return; + + // we need to do two things: apply the redo record, and create an undo record + u = &s->undo_rec[s->undo_point]; + r = s->undo_rec[s->redo_point]; + + // we KNOW there must be room for the undo record, because the redo record + // was derived from an undo record + + u->delete_length = r.insert_length; + u->insert_length = r.delete_length; + u->where = r.where; + u->char_storage = -1; + + if (r.delete_length) { + // the redo record requires us to delete characters, so the undo record + // needs to store the characters + + if (s->undo_char_point + u->insert_length > s->redo_char_point) { + u->insert_length = 0; + u->delete_length = 0; + } else { + int i; + u->char_storage = s->undo_char_point; + s->undo_char_point = s->undo_char_point + u->insert_length; + + // now save the characters + for (i=0; i < u->insert_length; ++i) + s->undo_char[u->char_storage + i] = STB_TEXTEDIT_GETCHAR(str, u->where + i); + } + + STB_TEXTEDIT_DELETECHARS(str, r.where, r.delete_length); + } + + if (r.insert_length) { + // easy case: need to insert n characters + STB_TEXTEDIT_INSERTCHARS(str, r.where, &s->undo_char[r.char_storage], r.insert_length); + s->redo_char_point += r.insert_length; + } + + state->cursor = r.where + r.insert_length; + + s->undo_point++; + s->redo_point++; +} + +static void stb_text_makeundo_insert(STB_TexteditState *state, int where, int length) +{ + stb_text_createundo(&state->undostate, where, 0, length); +} + +static void stb_text_makeundo_delete(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, int where, int length) +{ + int i; + STB_TEXTEDIT_CHARTYPE *p = stb_text_createundo(&state->undostate, where, length, 0); + if (p) { + for (i=0; i < length; ++i) + p[i] = STB_TEXTEDIT_GETCHAR(str, where+i); + } +} + +static void stb_text_makeundo_replace(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, int where, int old_length, int new_length) +{ + int i; + STB_TEXTEDIT_CHARTYPE *p = stb_text_createundo(&state->undostate, where, old_length, new_length); + if (p) { + for (i=0; i < old_length; ++i) + p[i] = STB_TEXTEDIT_GETCHAR(str, where+i); + } +} + +// reset the state to default +static void stb_textedit_clear_state(STB_TexteditState *state, int is_single_line) +{ + state->undostate.undo_point = 0; + state->undostate.undo_char_point = 0; + state->undostate.redo_point = STB_TEXTEDIT_UNDOSTATECOUNT; + state->undostate.redo_char_point = STB_TEXTEDIT_UNDOCHARCOUNT; + state->select_end = state->select_start = 0; + state->cursor = 0; + state->has_preferred_x = 0; + state->preferred_x = 0; + state->cursor_at_end_of_line = 0; + state->initialized = 1; + state->single_line = (unsigned char) is_single_line; + state->insert_mode = 0; + state->row_count_per_page = 0; +} + +// API initialize +static void stb_textedit_initialize_state(STB_TexteditState *state, int is_single_line) +{ + stb_textedit_clear_state(state, is_single_line); +} + +#if defined(__GNUC__) || defined(__clang__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wcast-qual" +#endif + +static int stb_textedit_paste(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, STB_TEXTEDIT_CHARTYPE const *ctext, int len) +{ + return stb_textedit_paste_internal(str, state, (STB_TEXTEDIT_CHARTYPE *) ctext, len); +} + +#if defined(__GNUC__) || defined(__clang__) +#pragma GCC diagnostic pop +#endif + +#endif//STB_TEXTEDIT_IMPLEMENTATION + +/* +------------------------------------------------------------------------------ +This software is available under 2 licenses -- choose whichever you prefer. +------------------------------------------------------------------------------ +ALTERNATIVE A - MIT License +Copyright (c) 2017 Sean Barrett +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is furnished to do +so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +------------------------------------------------------------------------------ +ALTERNATIVE B - Public Domain (www.unlicense.org) +This is free and unencumbered software released into the public domain. +Anyone is free to copy, modify, publish, use, compile, sell, or distribute this +software, either in source code form or as a compiled binary, for any purpose, +commercial or non-commercial, and by any means. +In jurisdictions that recognize copyright laws, the author or authors of this +software dedicate any and all copyright interest in the software to the public +domain. We make this dedication for the benefit of the public at large and to +the detriment of our heirs and successors. We intend this dedication to be an +overt act of relinquishment in perpetuity of all present and future rights to +this software under copyright law. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN +ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +------------------------------------------------------------------------------ +*/ diff --git a/tests/data/c/stb/stb_tilemap_editor.h b/tests/data/c/stb/stb_tilemap_editor.h new file mode 100644 index 000000000..fbd338808 --- /dev/null +++ b/tests/data/c/stb/stb_tilemap_editor.h @@ -0,0 +1,4187 @@ +// stb_tilemap_editor.h - v0.42 - Sean Barrett - http://nothings.org/stb +// placed in the public domain - not copyrighted - first released 2014-09 +// +// Embeddable tilemap editor for C/C++ +// +// +// TABLE OF CONTENTS +// FAQ +// How to compile/use the library +// Additional configuration macros +// API documentation +// Info on editing multiple levels +// Revision history +// Todo +// Credits +// License +// +// +// FAQ +// +// Q: What counts as a tilemap for this library? +// +// A: An array of rectangles, where each rectangle contains a small +// stack of images. +// +// Q: What are the limitations? +// +// A: Maps are limited to 4096x4096 in dimension. +// Each map square can only contain a stack of at most 32 images. +// A map can only use up to 32768 distinct image tiles. +// +// Q: How do I compile this? +// +// A: You need to #define several symbols before #including it, but only +// in one file. This will cause all the function definitions to be +// generated in that file. See the "HOW TO COMPILE" section. +// +// Q: What advantages does this have over a standalone editor? +// +// A: For one, you can integrate the editor into your game so you can +// flip between editing and testing without even switching windows. +// For another, you don't need an XML parser to get at the map data. +// +// Q: Can I live-edit my game maps? +// +// A: Not really, the editor keeps its own map representation. +// +// Q: How do I save and load maps? +// +// A: You have to do this yourself. The editor provides serialization +// functions (get & set) for reading and writing the map it holds. +// You can choose whatever format you want to store the map to on +// disk; you just need to provide functions to convert. (For example, +// I actually store the editor's map representation to disk basically +// as-is; then I have a single function that converts from the editor +// map representation to the game representation, which is used both +// to go from editor-to-game and from loaded-map-to-game.) +// +// Q: I want to have tiles change appearance based on what's +// adjacent, or other tile-display/substitution trickiness. +// +// A: You can do this when you convert from the editor's map +// representation to the game representation, but there's +// no way to show this live in the editor. +// +// Q: The editor appears to be put map location (0,0) at the top left? +// I want to use a different coordinate system in my game (e.g. y +// increasing upwards, or origin at the center). +// +// A: You can do this when you convert from the editor's map +// representation to the game representation. (Don't forget to +// translate link coordinates as well!) +// +// Q: The editor appears to put pixel (0,0) at the top left? I want +// to use a different coordinate system in my game. +// +// A: The editor defines an "editor pixel coordinate system" with +// (0,0) at the top left and requires you to display things in +// that coordinate system. You can freely remap those coordinates +// to anything you want on screen. +// +// Q: How do I scale the user interface? +// +// A: Since you do all the rendering, you can scale up all the rendering +// calls that the library makes to you. If you do, (a) you need +// to also scale up the mouse coordinates, and (b) you may want +// to scale the map display back down so that you're only scaling +// the UI and not everything. See the next question. +// +// Q: How do I scale the map display? +// +// A: Use stbte_set_spacing() to change the size that the map is displayed +// at. Note that the "callbacks" to draw tiles are used for both drawing +// the map and drawing the tile palette, so that callback may need to +// draw at two different scales. You should choose the scales to match +// You can tell them apart because the +// tile palette gets NULL for the property pointer. +// +// Q: How does object editing work? +// +// A: One way to think of this is that in the editor, you're placing +// spawners, not objects. Each spawner must be tile-aligned, because +// it's only a tile editor. Each tile (stack of layers) gets +// an associated set of properties, and it's up to you to +// determine what properties should appear for a given tile, +// based on e.g. the spawners that are in it. +// +// Q: How are properties themselves handled? +// +// A: All properties, regardless of UI behavior, are internally floats. +// Each tile has an array of floats associated with it, which is +// passed back to you when drawing the tiles so you can draw +// objects appropriately modified by the properties. +// +// Q: What if I want to have two different objects/spawners in +// one tile, both of which have their own properties? +// +// A: Make sure STBTE_MAX_PROPERTIES is large enough for the sum of +// properties in both objects, and then you have to explicitly +// map the property slot #s to the appropriate objects. They'll +// still all appear in a single property panel; there's no way +// to get multiple panels. +// +// Q: Can I do one-to-many linking? +// +// A: The library only supports one link per tile. However, you +// can have multiple tiles all link to a single tile. So, you +// can fake one-to-many linking by linking in the reverse +// direction. +// +// Q: What if I have two objects in the same tile, and they each +// need an independent link? Or I have two kinds of link associated +// with a single object? +// +// A: There is no way to do this. (Unless you can reverse one link.) +// +// Q: How does cut & paste interact with object properties & links? +// +// A: Currently the library has no idea which properties or links +// are associated with which layers of a tile. So currently, the +// library will only copy properties & links if the layer panel +// is set to allow all layers to be copied, OR if you set the +// "props" in the layer panel to "always". Similarly, you can +// set "props" to "none" so it will never copy. +// +// Q: What happens if the library gets a memory allocation failure +// while I'm editing? Will I lose my work? +// +// A: The library allocates all editor memory when you create +// the tilemap. It allocates a maximally-sized map and a +// fixed-size undo buffer (and the fixed-size copy buffer +// is static), and never allocates memory while it's running. +// So it can't fail due to running out of memory. +// +// Q: What happens if the library crashes while I'm editing? Will +// I lose my work? +// +// A: Yes. Save often. +// +// +// HOW TO COMPILE +// +// This header file contains both the header file and the +// implementation file in one. To create the implementation, +// in one source file define a few symbols first and then +// include this header: +// +// #define STB_TILEMAP_EDITOR_IMPLEMENTATION +// // this triggers the implementation +// +// void STBTE_DRAW_RECT(int x0, int y0, int x1, int y1, unsigned int color); +// // this must draw a filled rectangle (exclusive on right/bottom) +// // color = (r<<16)|(g<<8)|(b) +// +// void STBTE_DRAW_TILE(int x0, int y0, +// unsigned short id, int highlight, float *data); +// // this draws the tile image identified by 'id' in one of several +// // highlight modes (see STBTE_drawmode_* in the header section); +// // if 'data' is NULL, it's drawing the tile in the palette; if 'data' +// // is not NULL, it's drawing a tile on the map, and that is the data +// // associated with that map tile +// +// #include "stb_tilemap_editor.h" +// +// Optionally you can define the following functions before the include; +// note these must be macros (but they can just call a function) so +// this library can #ifdef to detect if you've defined them: +// +// #define STBTE_PROP_TYPE(int n, short *tiledata, float *params) ... +// // Returns the type of the n'th property of a given tile, which +// // controls how it is edited. Legal types are: +// // 0 /* no editable property in this slot */ +// // STBTE_PROP_int /* uses a slider to adjust value */ +// // STBTE_PROP_float /* uses a weird multi-axis control */ +// // STBTE_PROP_bool /* uses a checkbox to change value */ +// // And you can bitwise-OR in the following flags: +// // STBTE_PROP_disabled +// // Note that all of these are stored as floats in the param array. +// // The integer slider is limited in precision based on the space +// // available on screen, so for wide-ranged integers you may want +// // to use floats instead. +// // +// // Since the tiledata is passed to you, you can choose which property +// // is bound to that slot based on that data. +// // +// // Changing the type of a parameter does not cause the underlying +// // value to be clamped to the type min/max except when the tile is +// // explicitly selected. +// +// #define STBTE_PROP_NAME(int n, short *tiledata, float *params) ... +// // these return a string with the name for slot #n in the float +// // property list for the tile. +// +// #define STBTE_PROP_MIN(int n, short *tiledata) ...your code here... +// #define STBTE_PROP_MAX(int n, short *tiledata) ...your code here... +// // These return the allowable range for the property values for +// // the specified slot. It is never called for boolean types. +// +// #define STBTE_PROP_FLOAT_SCALE(int n, short *tiledata, float *params) +// // This rescales the float control for a given property; by default +// // left mouse drags add integers, right mouse drags adds fractions, +// // but you can rescale this per-property. +// +// #define STBTE_FLOAT_CONTROL_GRANULARITY ... value ... +// // This returns the number of pixels of mouse motion necessary +// // to advance the object float control. Default is 4 +// +// #define STBTE_ALLOW_LINK(short *src, float *src_data, \ +// short *dest, float *dest_data) ...your code... +// // this returns true or false depending on whether you allow a link +// // to be drawn from a tile 'src' to a tile 'dest'. if you don't +// // define this, linking will not be supported +// +// #define STBTE_LINK_COLOR(short *src, float *src_data, \ +// short *dest, float *dest_data) ...your code... +// // return a color encoded as a 24-bit unsigned integer in the +// // form 0xRRGGBB. If you don't define this, default colors will +// // be used. +// +// +// [[ support for those below is not implemented yet ]] +// +// #define STBTE_HITTEST_TILE(x0,y0,id,mx,my) ...your code here... +// // this returns true or false depending on whether the mouse +// // pointer at mx,my is over (touching) a tile of type 'id' +// // displayed at x0,y0. Normally stb_tilemap_editor just does +// // this hittest based on the tile geometry, but if you have +// // tiles whose images extend out of the tile, you'll need this. +// +// ADDITIONAL CONFIGURATION +// +// The following symbols set static limits which determine how much +// memory will be allocated for the editor. You can override them +// by making similar definitions, but memory usage will increase. +// +// #define STBTE_MAX_TILEMAP_X 200 // max 4096 +// #define STBTE_MAX_TILEMAP_Y 200 // max 4096 +// #define STBTE_MAX_LAYERS 8 // max 32 +// #define STBTE_MAX_CATEGORIES 100 +// #define STBTE_UNDO_BUFFER_BYTES (1 << 24) // 16 MB +// #define STBTE_MAX_COPY 90000 // e.g. 300x300 +// #define STBTE_MAX_PROPERTIES 10 // max properties per tile +// +// API +// +// Further documentation appears in the header-file section below. +// +// EDITING MULTIPLE LEVELS +// +// You can only have one active editor instance. To switch between multiple +// levels, you can either store the levels in your own format and copy them +// in and out of the editor format, or you can create multiple stbte_tilemap +// objects and switch between them. The latter has the advantage that each +// stbte_tilemap keeps its own undo state. (The clipboard is global, so +// either approach allows cut&pasting between levels.) +// +// REVISION HISTORY +// 0.42 fix compilation errors +// 0.41 fix warnings +// 0.40 fix warning +// 0.39 fix warning +// 0.38 fix warning +// 0.37 fix warning +// 0.36 minor compiler support +// 0.35 layername button changes +// - layername buttons grow with the layer panel +// - fix stbte_create_map being declared as stbte_create +// - fix declaration of stbte_create_map +// 0.30 properties release +// - properties panel for editing user-defined "object" properties +// - can link each tile to one other tile +// - keyboard interface +// - fix eraser tool bug (worked in complex cases, failed in simple) +// - undo/redo tools have visible disabled state +// - tiles on higher layers draw on top of adjacent lower-layer tiles +// 0.20 erasable release +// - eraser tool +// - fix bug when pasting into protected layer +// - better color scheme +// - internal-use color picker +// 0.10 initial release +// +// TODO +// +// Separate scroll state for each category +// Implement paint bucket +// Support STBTE_HITTEST_TILE above +// ?Cancel drags by clicking other button? - may be fixed +// Finish support for toolbar at side +// +// CREDITS +// +// +// Main editor & features +// Sean Barrett +// Additional features: +// Josh Huelsman +// Bugfixes: +// Ryan Whitworth +// Eugene Opalev +// Rob Loach +// github:wernsey +// +// LICENSE +// +// See end of file for license information. + + + +/////////////////////////////////////////////////////////////////////// +// +// HEADER SECTION + +#ifndef STB_TILEMAP_INCLUDE_STB_TILEMAP_EDITOR_H +#define STB_TILEMAP_INCLUDE_STB_TILEMAP_EDITOR_H + +#ifdef _WIN32 + #ifndef _CRT_SECURE_NO_WARNINGS + #define _CRT_SECURE_NO_WARNINGS + #endif + #include + #include +#endif + +typedef struct stbte_tilemap stbte_tilemap; + +// these are the drawmodes used in STBTE_DRAW_TILE +enum +{ + STBTE_drawmode_deemphasize = -1, + STBTE_drawmode_normal = 0, + STBTE_drawmode_emphasize = 1, +}; + +// these are the property types +#define STBTE_PROP_none 0 +#define STBTE_PROP_int 1 +#define STBTE_PROP_float 2 +#define STBTE_PROP_bool 3 +#define STBTE_PROP_disabled 4 + +//////// +// +// creation +// + +extern stbte_tilemap *stbte_create_map(int map_x, int map_y, int map_layers, int spacing_x, int spacing_y, int max_tiles); +// create an editable tilemap +// map_x : dimensions of map horizontally (user can change this in editor), <= STBTE_MAX_TILEMAP_X +// map_y : dimensions of map vertically (user can change this in editor) <= STBTE_MAX_TILEMAP_Y +// map_layers : number of layers to use (fixed), <= STBTE_MAX_LAYERS +// spacing_x : initial horizontal distance between left edges of map tiles in stb_tilemap_editor pixels +// spacing_y : initial vertical distance between top edges of map tiles in stb_tilemap_editor pixels +// max_tiles : maximum number of tiles that can defined +// +// If insufficient memory, returns NULL + +extern void stbte_define_tile(stbte_tilemap *tm, unsigned short id, unsigned int layermask, const char * category); +// call this repeatedly for each tile to install the tile definitions into the editable tilemap +// tm : tilemap created by stbte_create_map +// id : unique identifier for each tile, 0 <= id < 32768 +// layermask : bitmask of which layers tile is allowed on: 1 = layer 0, 255 = layers 0..7 +// (note that onscreen, the editor numbers the layers from 1 not 0) +// layer 0 is the furthest back, layer 1 is just in front of layer 0, etc +// category : which category this tile is grouped in + +extern void stbte_set_display(int x0, int y0, int x1, int y1); +// call this once to set the size; if you resize, call it again + + +///////// +// +// every frame +// + +extern void stbte_draw(stbte_tilemap *tm); + +extern void stbte_tick(stbte_tilemap *tm, float time_in_seconds_since_last_frame); + +//////////// +// +// user input +// + +// if you're using SDL, call the next function for SDL_MOUSEMOTION, SDL_MOUSEBUTTONDOWN, SDL_MOUSEBUTTONUP, SDL_MOUSEWHEEL; +// the transformation lets you scale from SDL mouse coords to stb_tilemap_editor coords +extern void stbte_mouse_sdl(stbte_tilemap *tm, const void *sdl_event, float xscale, float yscale, int xoffset, int yoffset); + +// otherwise, hook these up explicitly: +extern void stbte_mouse_move(stbte_tilemap *tm, int x, int y, int shifted, int scrollkey); +extern void stbte_mouse_button(stbte_tilemap *tm, int x, int y, int right, int down, int shifted, int scrollkey); +extern void stbte_mouse_wheel(stbte_tilemap *tm, int x, int y, int vscroll); + +// note: at the moment, mouse wheel events (SDL_MOUSEWHEEL) are ignored. + +// for keyboard, define your own mapping from keys to the following actions. +// this is totally optional, as all features are accessible with the mouse +enum stbte_action +{ + STBTE_tool_select, + STBTE_tool_brush, + STBTE_tool_erase, + STBTE_tool_rectangle, + STBTE_tool_eyedropper, + STBTE_tool_link, + STBTE_act_toggle_grid, + STBTE_act_toggle_links, + STBTE_act_undo, + STBTE_act_redo, + STBTE_act_cut, + STBTE_act_copy, + STBTE_act_paste, + STBTE_scroll_left, + STBTE_scroll_right, + STBTE_scroll_up, + STBTE_scroll_down, +}; +extern void stbte_action(stbte_tilemap *tm, enum stbte_action act); + +//////////////// +// +// save/load +// +// There is no editor file format. You have to save and load the data yourself +// through the following functions. You can also use these functions to get the +// data to generate game-formatted levels directly. (But make sure you save +// first! You may also want to autosave to a temp file periodically, etc etc.) + +#define STBTE_EMPTY -1 + +extern void stbte_get_dimensions(stbte_tilemap *tm, int *max_x, int *max_y); +// get the dimensions of the level, since the user can change them + +extern short* stbte_get_tile(stbte_tilemap *tm, int x, int y); +// returns an array of shorts that is 'map_layers' in length. each short is +// either one of the tile_id values from define_tile, or STBTE_EMPTY. + +extern float *stbte_get_properties(stbte_tilemap *tm, int x, int y); +// get the property array associated with the tile at x,y. this is an +// array of floats that is STBTE_MAX_PROPERTIES in length; you have to +// interpret the slots according to the semantics you've chosen + +extern void stbte_get_link(stbte_tilemap *tm, int x, int y, int *destx, int *desty); +// gets the link associated with the tile at x,y. + +extern void stbte_set_dimensions(stbte_tilemap *tm, int max_x, int max_y); +// set the dimensions of the level, overrides previous stbte_create_map() +// values or anything the user has changed + +extern void stbte_clear_map(stbte_tilemap *tm); +// clears the map, including the region outside the defined region, so if the +// user expands the map, they won't see garbage there + +extern void stbte_set_tile(stbte_tilemap *tm, int x, int y, int layer, signed short tile); +// tile is your tile_id from define_tile, or STBTE_EMPTY + +extern void stbte_set_property(stbte_tilemap *tm, int x, int y, int n, float val); +// set the value of the n'th slot of the tile at x,y + +extern void stbte_set_link(stbte_tilemap *tm, int x, int y, int destx, int desty); +// set a link going from x,y to destx,desty. to force no link, +// use destx=desty=-1 + +//////// +// +// optional +// + +extern void stbte_set_background_tile(stbte_tilemap *tm, short id); +// selects the tile to fill the bottom layer with and used to clear bottom tiles to; +// should be same ID as + +extern void stbte_set_sidewidths(int left, int right); +// call this once to set the left & right side widths. don't call +// it again since the user can change it + +extern void stbte_set_spacing(stbte_tilemap *tm, int spacing_x, int spacing_y, int palette_spacing_x, int palette_spacing_y); +// call this to set the spacing of map tiles and the spacing of palette tiles. +// if you rescale your display, call it again (e.g. you can implement map zooming yourself) + +extern void stbte_set_layername(stbte_tilemap *tm, int layer, const char *layername); +// sets a string name for your layer that shows in the layer selector. note that this +// makes the layer selector wider. 'layer' is from 0..(map_layers-1) + +#endif + +#ifdef STB_TILEMAP_EDITOR_IMPLEMENTATION + +#ifndef STBTE_ASSERT +#define STBTE_ASSERT assert +#include +#endif + +#ifdef _MSC_VER +#define STBTE__NOTUSED(v) (void)(v) +#else +#define STBTE__NOTUSED(v) (void)sizeof(v) +#endif + +#ifndef STBTE_MAX_TILEMAP_X +#define STBTE_MAX_TILEMAP_X 200 +#endif + +#ifndef STBTE_MAX_TILEMAP_Y +#define STBTE_MAX_TILEMAP_Y 200 +#endif + +#ifndef STBTE_MAX_LAYERS +#define STBTE_MAX_LAYERS 8 +#endif + +#ifndef STBTE_MAX_CATEGORIES +#define STBTE_MAX_CATEGORIES 100 +#endif + +#ifndef STBTE_MAX_COPY +#define STBTE_MAX_COPY 65536 +#endif + +#ifndef STBTE_UNDO_BUFFER_BYTES +#define STBTE_UNDO_BUFFER_BYTES (1 << 24) // 16 MB +#endif + +#ifndef STBTE_PROP_TYPE +#define STBTE__NO_PROPS +#define STBTE_PROP_TYPE(n,td,tp) 0 +#endif + +#ifndef STBTE_PROP_NAME +#define STBTE_PROP_NAME(n,td,tp) "" +#endif + +#ifndef STBTE_MAX_PROPERTIES +#define STBTE_MAX_PROPERTIES 10 +#endif + +#ifndef STBTE_PROP_MIN +#define STBTE_PROP_MIN(n,td,tp) 0 +#endif + +#ifndef STBTE_PROP_MAX +#define STBTE_PROP_MAX(n,td,tp) 100.0 +#endif + +#ifndef STBTE_PROP_FLOAT_SCALE +#define STBTE_PROP_FLOAT_SCALE(n,td,tp) 1 // default scale size +#endif + +#ifndef STBTE_FLOAT_CONTROL_GRANULARITY +#define STBTE_FLOAT_CONTROL_GRANULARITY 4 +#endif + + +#define STBTE__UNDO_BUFFER_COUNT (STBTE_UNDO_BUFFER_BYTES>>1) + +#if STBTE_MAX_TILEMAP_X > 4096 || STBTE_MAX_TILEMAP_Y > 4096 +#error "Maximum editable map size is 4096 x 4096" +#endif +#if STBTE_MAX_LAYERS > 32 +#error "Maximum layers allowed is 32" +#endif +#if STBTE_UNDO_BUFFER_COUNT & (STBTE_UNDO_BUFFER_COUNT-1) +#error "Undo buffer size must be a power of 2" +#endif + +#if STBTE_MAX_PROPERTIES == 0 +#define STBTE__NO_PROPS +#endif + +#ifdef STBTE__NO_PROPS +#undef STBTE_MAX_PROPERTIES +#define STBTE_MAX_PROPERTIES 1 // so we can declare arrays +#endif + +typedef struct +{ + short x,y; +} stbte__link; + +enum +{ + STBTE__base, + STBTE__outline, + STBTE__text, + + STBTE__num_color_aspects, +}; + +enum +{ + STBTE__idle, + STBTE__over, + STBTE__down, + STBTE__over_down, + STBTE__selected, + STBTE__selected_over, + STBTE__disabled, + STBTE__num_color_states, +}; + +enum +{ + STBTE__cexpander, + STBTE__ctoolbar, + STBTE__ctoolbar_button, + STBTE__cpanel, + STBTE__cpanel_sider, + STBTE__cpanel_sizer, + STBTE__cscrollbar, + STBTE__cmapsize, + STBTE__clayer_button, + STBTE__clayer_hide, + STBTE__clayer_lock, + STBTE__clayer_solo, + STBTE__ccategory_button, + + STBTE__num_color_modes, +}; + +#ifdef STBTE__COLORPICKER +static char *stbte__color_names[] = +{ + "expander", "toolbar", "tool button", "panel", + "panel c1", "panel c2", "scollbar", "map button", + "layer", "hide", "lock", "solo", + "category", +}; +#endif // STBTE__COLORPICKER + + // idle, over, down, over&down, selected, sel&over, disabled +static int stbte__color_table[STBTE__num_color_modes][STBTE__num_color_aspects][STBTE__num_color_states] = +{ + { + { 0x000000, 0x84987c, 0xdcdca8, 0xdcdca8, 0x40c040, 0x60d060, 0x505050, }, + { 0xa4b090, 0xe0ec80, 0xffffc0, 0xffffc0, 0x80ff80, 0x80ff80, 0x606060, }, + { 0xffffff, 0xffffff, 0xffffff, 0xffffff, 0xffffff, 0xffffff, 0x909090, }, + }, { + { 0x808890, 0x606060, 0x606060, 0x606060, 0x606060, 0x606060, 0x606060, }, + { 0x605860, 0x606060, 0x606060, 0x606060, 0x606060, 0x606060, 0x606060, }, + { 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, }, + }, { + { 0x3c5068, 0x7088a8, 0x647488, 0x94b4dc, 0x8890c4, 0x9caccc, 0x404040, }, + { 0x889cb8, 0x889cb8, 0x889cb8, 0x889cb8, 0x84c4e8, 0xacc8ff, 0x0c0c08, }, + { 0xbcc4cc, 0xffffff, 0xffffff, 0xffffff, 0xffffff, 0xffffff, 0x707074, }, + }, { + { 0x403848, 0x403010, 0x403010, 0x403010, 0x403010, 0x403010, 0x303024, }, + { 0x68546c, 0xc08040, 0xc08040, 0xc08040, 0xc08040, 0xc08040, 0x605030, }, + { 0xf4e4ff, 0xffffff, 0xffffff, 0xffffff, 0xffffff, 0xffffff, 0x909090, }, + }, { + { 0xb4b04c, 0xacac60, 0xc0ffc0, 0xc0ffc0, 0x40c040, 0x60d060, 0x505050, }, + { 0xa0a04c, 0xd0d04c, 0xffff80, 0xffff80, 0x80ff80, 0x80ff80, 0x606060, }, + { 0xffffff, 0xffffff, 0xffffff, 0xffffff, 0xffffff, 0xffffff, 0x909090, }, + }, { + { 0x40c440, 0x60d060, 0xc0ffc0, 0xc0ffc0, 0x40c040, 0x60d060, 0x505050, }, + { 0x40c040, 0x80ff80, 0x80ff80, 0x80ff80, 0x80ff80, 0x80ff80, 0x606060, }, + { 0xffffff, 0xffffff, 0xffffff, 0xffffff, 0xffffff, 0xffffff, 0x909090, }, + }, { + { 0x9090ac, 0xa0a0b8, 0xbcb8cc, 0xbcb8cc, 0x909040, 0x909040, 0x909040, }, + { 0xa0a0b8, 0xb0b4d0, 0xa0a0b8, 0xa0a0b8, 0xa0a050, 0xa0a050, 0xa0a050, }, + { 0x808088, 0x808030, 0x808030, 0x808030, 0x808030, 0x808030, 0x808030, }, + }, { + { 0x704c70, 0x885c8c, 0x9c68a4, 0xb870bc, 0xb490bc, 0xb490bc, 0x302828, }, + { 0x646064, 0xcca8d4, 0xc060c0, 0xa07898, 0xe0b8e0, 0xe0b8e0, 0x403838, }, + { 0xdccce4, 0xffffff, 0xffffff, 0xffffff, 0xffffff, 0xffffff, 0x909090, }, + }, { + { 0x704c70, 0x885c8c, 0x9c68a4, 0xb870bc, 0xb490bc, 0xb490bc, 0x302828, }, + { 0xb09cb4, 0xcca8d4, 0xc060c0, 0xa07898, 0xe0b8e0, 0xe0b8e0, 0x403838, }, + { 0xdccce4, 0xffffff, 0xffffff, 0xffffff, 0xffffff, 0xffffff, 0x909090, }, + }, { + { 0x646494, 0x888cb8, 0xb0b0b0, 0xb0b0cc, 0x9c9cf4, 0x8888b0, 0x50506c, }, + { 0x9090a4, 0xb0b4d4, 0xb0b0dc, 0xb0b0cc, 0xd0d0fc, 0xd0d4f0, 0x606060, }, + { 0xb4b4d4, 0xe4e4ff, 0xffffff, 0xffffff, 0xe0e4ff, 0xececff, 0x909090, }, + }, { + { 0x646444, 0x888c64, 0xb0b0b0, 0xb0b088, 0xaca858, 0x88886c, 0x505050, }, + { 0x88886c, 0xb0b490, 0xb0b0b0, 0xb0b088, 0xd8d898, 0xd0d4b0, 0x606060, }, + { 0xb4b49c, 0xffffd8, 0xffffff, 0xffffd4, 0xffffdc, 0xffffcc, 0x909090, }, + }, { + { 0x906464, 0xb48c8c, 0xd4b0b0, 0xdcb0b0, 0xff9c9c, 0xc88888, 0x505050, }, + { 0xb47c80, 0xd4b4b8, 0xc4a8a8, 0xdcb0b0, 0xffc0c0, 0xfce8ec, 0x606060, }, + { 0xe0b4b4, 0xffdcd8, 0xffd8d4, 0xffe0e4, 0xffece8, 0xffffff, 0x909090, }, + }, { + { 0x403848, 0x403848, 0x403848, 0x886894, 0x7c80c8, 0x7c80c8, 0x302828, }, + { 0x403848, 0x403848, 0x403848, 0x403848, 0x7c80c8, 0x7c80c8, 0x403838, }, + { 0xc8c4c8, 0xffffff, 0xffffff, 0xffffff, 0xe8e8ec, 0xffffff, 0x909090, }, + }, +}; + +#define STBTE_COLOR_TILEMAP_BACKGROUND 0x000000 +#define STBTE_COLOR_TILEMAP_BORDER 0x203060 +#define STBTE_COLOR_TILEMAP_HIGHLIGHT 0xffffff +#define STBTE_COLOR_GRID 0x404040 +#define STBTE_COLOR_SELECTION_OUTLINE1 0xdfdfdf +#define STBTE_COLOR_SELECTION_OUTLINE2 0x303030 +#define STBTE_COLOR_TILEPALETTE_OUTLINE 0xffffff +#define STBTE_COLOR_TILEPALETTE_BACKGROUND 0x000000 + +#ifndef STBTE_LINK_COLOR +#define STBTE_LINK_COLOR(src,sp,dest,dp) 0x5030ff +#endif + +#ifndef STBTE_LINK_COLOR_DRAWING +#define STBTE_LINK_COLOR_DRAWING 0xff40ff +#endif + +#ifndef STBTE_LINK_COLOR_DISALLOWED +#define STBTE_LINK_COLOR_DISALLOWED 0x602060 +#endif + + +// disabled, selected, down, over +static unsigned char stbte__state_to_index[2][2][2][2] = +{ + { + { { STBTE__idle , STBTE__over }, { STBTE__down , STBTE__over_down }, }, + { { STBTE__selected, STBTE__selected_over }, { STBTE__down , STBTE__over_down }, }, + },{ + { { STBTE__disabled, STBTE__disabled }, { STBTE__disabled, STBTE__disabled }, }, + { { STBTE__selected, STBTE__selected_over }, { STBTE__disabled, STBTE__disabled }, }, + } +}; +#define STBTE__INDEX_FOR_STATE(disable,select,down,over) stbte__state_to_index[disable][select][down][over] +#define STBTE__INDEX_FOR_ID(id,disable,select) STBTE__INDEX_FOR_STATE(disable,select,STBTE__IS_ACTIVE(id),STBTE__IS_HOT(id)) + +#define STBTE__FONT_HEIGHT 9 +static short stbte__font_offset[95+16]; +static short stbte__fontdata[769] = +{ + 4,9,6,9,9,9,9,8,9,8,4,9,7,7,7,7,4,2,6,8,6,6,7,3,4,4,8,6,3,6,2,6,6,6,6,6,6, + 6,6,6,6,6,2,3,5,4,5,6,6,6,6,6,6,6,6,6,6,6,6,7,6,7,7,7,6,7,6,6,6,6,7,7,6,6, + 6,4,6,4,7,7,3,6,6,5,6,6,5,6,6,4,5,6,4,7,6,6,6,6,6,6,6,6,6,7,6,6,6,5,2,5,8, + 0,0,0,0,2,253,130,456,156,8,72,184,64,2,125,66,64,160,64,146,511,146,146, + 511,146,146,511,146,511,257,341,297,341,297,341,257,511,16,56,124,16,16,16, + 124,56,16,96,144,270,261,262,136,80,48,224,192,160,80,40,22,14,15,3,448,496, + 496,240,232,20,10,5,2,112,232,452,450,225,113,58,28,63,30,60,200,455,257, + 257,0,0,0,257,257,455,120,204,132,132,159,14,4,4,14,159,132,132,204,120,8, + 24,56,120,56,24,8,32,48,56,60,56,48,32,0,0,0,0,111,111,7,7,0,0,7,7,34,127, + 127,34,34,127,127,34,36,46,107,107,58,18,99,51,24,12,102,99,48,122,79,93, + 55,114,80,4,7,3,62,127,99,65,65,99,127,62,8,42,62,28,28,62,42,8,8,8,62,62, + 8,8,128,224,96,8,8,8,8,8,8,96,96,96,48,24,12,6,3,62,127,89,77,127,62,64,66, + 127,127,64,64,98,115,89,77,71,66,33,97,73,93,119,35,24,28,22,127,127,16,39, + 103,69,69,125,57,62,127,73,73,121,48,1,1,113,121,15,7,54,127,73,73,127,54, + 6,79,73,105,63,30,54,54,128,246,118,8,28,54,99,65,20,20,20,20,65,99,54,28, + 8,2,3,105,109,7,2,30,63,33,45,47,46,124,126,19,19,126,124,127,127,73,73,127, + 54,62,127,65,65,99,34,127,127,65,99,62,28,127,127,73,73,73,65,127,127,9,9, + 9,1,62,127,65,73,121,121,127,127,8,8,127,127,65,65,127,127,65,65,32,96,64, + 64,127,63,127,127,8,28,54,99,65,127,127,64,64,64,64,127,127,6,12,6,127,127, + 127,127,6,12,24,127,127,62,127,65,65,65,127,62,127,127,9,9,15,6,62,127,65, + 81,49,127,94,127,127,9,25,127,102,70,79,73,73,121,49,1,1,127,127,1,1,63,127, + 64,64,127,63,15,31,48,96,48,31,15,127,127,48,24,48,127,127,99,119,28,28,119, + 99,7,15,120,120,15,7,97,113,89,77,71,67,127,127,65,65,3,6,12,24,48,96,65, + 65,127,127,8,12,6,3,6,12,8,64,64,64,64,64,64,64,3,7,4,32,116,84,84,124,120, + 127,127,68,68,124,56,56,124,68,68,68,56,124,68,68,127,127,56,124,84,84,92, + 24,8,124,126,10,10,56,380,324,324,508,252,127,127,4,4,124,120,72,122,122, + 64,256,256,256,506,250,126,126,16,56,104,64,66,126,126,64,124,124,24,56,28, + 124,120,124,124,4,4,124,120,56,124,68,68,124,56,508,508,68,68,124,56,56,124, + 68,68,508,508,124,124,4,4,12,8,72,92,84,84,116,36,4,4,62,126,68,68,60,124, + 64,64,124,124,28,60,96,96,60,28,28,124,112,56,112,124,28,68,108,56,56,108, + 68,284,316,352,320,508,252,68,100,116,92,76,68,8,62,119,65,65,127,127,65, + 65,119,62,8,16,24,12,12,24,24,12,4, +}; + +typedef struct +{ + short id; + unsigned short category_id; + char *category; + unsigned int layermask; +} stbte__tileinfo; + +#define MAX_LAYERMASK (1 << (8*sizeof(unsigned int))) + +typedef short stbte__tiledata; + +#define STBTE__NO_TILE -1 + +enum +{ + STBTE__panel_toolbar, + STBTE__panel_colorpick, + STBTE__panel_info, + STBTE__panel_layers, + STBTE__panel_props, + STBTE__panel_categories, + STBTE__panel_tiles, + + STBTE__num_panel, +}; + +enum +{ + STBTE__side_left, + STBTE__side_right, + STBTE__side_top, + STBTE__side_bottom, +}; + +enum +{ + STBTE__tool_select, + STBTE__tool_brush, + STBTE__tool_erase, + STBTE__tool_rect, + STBTE__tool_eyedrop, + STBTE__tool_fill, + STBTE__tool_link, + + STBTE__tool_showgrid, + STBTE__tool_showlinks, + + STBTE__tool_undo, + STBTE__tool_redo, + // copy/cut/paste aren't included here because they're displayed differently + + STBTE__num_tool, +}; + +// icons are stored in the 0-31 range of ASCII in the font +static int toolchar[] = { 26,24,25,20,23,22,18, 19,17, 29,28, }; + +enum +{ + STBTE__propmode_default, + STBTE__propmode_always, + STBTE__propmode_never, +}; + +enum +{ + STBTE__paint, + + // from here down does hittesting + STBTE__tick, + STBTE__mousemove, + STBTE__mousewheel, + STBTE__leftdown, + STBTE__leftup, + STBTE__rightdown, + STBTE__rightup, +}; + +typedef struct +{ + int expanded, mode; + int delta_height; // number of rows they've requested for this + int side; + int width,height; + int x0,y0; +} stbte__panel; + +typedef struct +{ + int x0,y0,x1,y1,color; +} stbte__colorrect; + +#define STBTE__MAX_DELAYRECT 256 + +typedef struct +{ + int tool, active_event; + int active_id, hot_id, next_hot_id; + int event; + int mx,my, dx,dy; + int ms_time; + int shift, scrollkey; + int initted; + int side_extended[2]; + stbte__colorrect delayrect[STBTE__MAX_DELAYRECT]; + int delaycount; + int show_grid, show_links; + int brush_state; // used to decide which kind of erasing + int eyedrop_x, eyedrop_y, eyedrop_last_layer; + int pasting, paste_x, paste_y; + int scrolling, start_x, start_y; + int last_mouse_x, last_mouse_y; + int accum_x, accum_y; + int linking; + int dragging; + int drag_x, drag_y, drag_w, drag_h; + int drag_offx, drag_offy, drag_dest_x, drag_dest_y; + int undoing; + int has_selection, select_x0, select_y0, select_x1, select_y1; + int sx,sy; + int x0,y0,x1,y1, left_width, right_width; // configurable widths + float alert_timer; + const char *alert_msg; + float dt; + stbte__panel panel[STBTE__num_panel]; + short copybuffer[STBTE_MAX_COPY][STBTE_MAX_LAYERS]; + float copyprops[STBTE_MAX_COPY][STBTE_MAX_PROPERTIES]; +#ifdef STBTE_ALLOW_LINK + stbte__link copylinks[STBTE_MAX_COPY]; +#endif + int copy_src_x, copy_src_y; + stbte_tilemap *copy_src; + int copy_width,copy_height,has_copy,copy_has_props; +} stbte__ui_t; + +// there's only one UI system at a time, so we can globalize this +static stbte__ui_t stbte__ui = { STBTE__tool_brush, 0 }; + +#define STBTE__INACTIVE() (stbte__ui.active_id == 0) +#define STBTE__IS_ACTIVE(id) (stbte__ui.active_id == (id)) +#define STBTE__IS_HOT(id) (stbte__ui.hot_id == (id)) + +#define STBTE__BUTTON_HEIGHT (STBTE__FONT_HEIGHT + 2 * STBTE__BUTTON_INTERNAL_SPACING) +#define STBTE__BUTTON_INTERNAL_SPACING (2 + (STBTE__FONT_HEIGHT>>4)) + +typedef struct +{ + const char *name; + int locked; + int hidden; +} stbte__layer; + +enum +{ + STBTE__unlocked, + STBTE__protected, + STBTE__locked, +}; + +struct stbte_tilemap +{ + stbte__tiledata data[STBTE_MAX_TILEMAP_Y][STBTE_MAX_TILEMAP_X][STBTE_MAX_LAYERS]; + float props[STBTE_MAX_TILEMAP_Y][STBTE_MAX_TILEMAP_X][STBTE_MAX_PROPERTIES]; + #ifdef STBTE_ALLOW_LINK + stbte__link link[STBTE_MAX_TILEMAP_Y][STBTE_MAX_TILEMAP_X]; + int linkcount[STBTE_MAX_TILEMAP_Y][STBTE_MAX_TILEMAP_X]; + #endif + int max_x, max_y, num_layers; + int spacing_x, spacing_y; + int palette_spacing_x, palette_spacing_y; + int scroll_x,scroll_y; + int cur_category, cur_tile, cur_layer; + char *categories[STBTE_MAX_CATEGORIES]; + int num_categories, category_scroll; + stbte__tileinfo *tiles; + int num_tiles, max_tiles, digits; + unsigned char undo_available_valid; + unsigned char undo_available; + unsigned char redo_available; + unsigned char padding; + int cur_palette_count; + int palette_scroll; + int tileinfo_dirty; + stbte__layer layerinfo[STBTE_MAX_LAYERS]; + int has_layer_names; + int layername_width; + int layer_scroll; + int propmode; + int solo_layer; + int undo_pos, undo_len, redo_len; + short background_tile; + unsigned char id_in_use[32768>>3]; + short *undo_buffer; +}; + +static char *default_category = (char*) "[unassigned]"; + +static void stbte__init_gui(void) +{ + int i,n; + stbte__ui.initted = 1; + // init UI state + stbte__ui.show_links = 1; + for (i=0; i < STBTE__num_panel; ++i) { + stbte__ui.panel[i].expanded = 1; // visible if not autohidden + stbte__ui.panel[i].delta_height = 0; + stbte__ui.panel[i].side = STBTE__side_left; + } + stbte__ui.panel[STBTE__panel_toolbar ].side = STBTE__side_top; + stbte__ui.panel[STBTE__panel_colorpick].side = STBTE__side_right; + + if (stbte__ui.left_width == 0) + stbte__ui.left_width = 80; + if (stbte__ui.right_width == 0) + stbte__ui.right_width = 80; + + // init font + n=95+16; + for (i=0; i < 95+16; ++i) { + stbte__font_offset[i] = n; + n += stbte__fontdata[i]; + } +} + +stbte_tilemap *stbte_create_map(int map_x, int map_y, int map_layers, int spacing_x, int spacing_y, int max_tiles) +{ + int i; + stbte_tilemap *tm; + STBTE_ASSERT(map_layers >= 0 && map_layers <= STBTE_MAX_LAYERS); + STBTE_ASSERT(map_x >= 0 && map_x <= STBTE_MAX_TILEMAP_X); + STBTE_ASSERT(map_y >= 0 && map_y <= STBTE_MAX_TILEMAP_Y); + if (map_x < 0 || map_y < 0 || map_layers < 0 || + map_x > STBTE_MAX_TILEMAP_X || map_y > STBTE_MAX_TILEMAP_Y || map_layers > STBTE_MAX_LAYERS) + return NULL; + + if (!stbte__ui.initted) + stbte__init_gui(); + + tm = (stbte_tilemap *) malloc(sizeof(*tm) + sizeof(*tm->tiles) * max_tiles + STBTE_UNDO_BUFFER_BYTES); + if (tm == NULL) + return NULL; + + tm->tiles = (stbte__tileinfo *) (tm+1); + tm->undo_buffer = (short *) (tm->tiles + max_tiles); + tm->num_layers = map_layers; + tm->max_x = map_x; + tm->max_y = map_y; + tm->spacing_x = spacing_x; + tm->spacing_y = spacing_y; + tm->scroll_x = 0; + tm->scroll_y = 0; + tm->palette_scroll = 0; + tm->palette_spacing_x = spacing_x+1; + tm->palette_spacing_y = spacing_y+1; + tm->cur_category = -1; + tm->cur_tile = 0; + tm->solo_layer = -1; + tm->undo_len = 0; + tm->redo_len = 0; + tm->undo_pos = 0; + tm->category_scroll = 0; + tm->layer_scroll = 0; + tm->propmode = 0; + tm->has_layer_names = 0; + tm->layername_width = 0; + tm->undo_available_valid = 0; + + for (i=0; i < tm->num_layers; ++i) { + tm->layerinfo[i].hidden = 0; + tm->layerinfo[i].locked = STBTE__unlocked; + tm->layerinfo[i].name = 0; + } + + tm->background_tile = STBTE__NO_TILE; + stbte_clear_map(tm); + + tm->max_tiles = max_tiles; + tm->num_tiles = 0; + for (i=0; i < 32768/8; ++i) + tm->id_in_use[i] = 0; + tm->tileinfo_dirty = 1; + return tm; +} + +void stbte_set_background_tile(stbte_tilemap *tm, short id) +{ + int i; + STBTE_ASSERT(id >= -1); + // STBTE_ASSERT(id < 32768); + if (id < -1) + return; + for (i=0; i < STBTE_MAX_TILEMAP_X * STBTE_MAX_TILEMAP_Y; ++i) + if (tm->data[0][i][0] == -1) + tm->data[0][i][0] = id; + tm->background_tile = id; +} + +void stbte_set_spacing(stbte_tilemap *tm, int spacing_x, int spacing_y, int palette_spacing_x, int palette_spacing_y) +{ + tm->spacing_x = spacing_x; + tm->spacing_y = spacing_y; + tm->palette_spacing_x = palette_spacing_x; + tm->palette_spacing_y = palette_spacing_y; +} + +void stbte_set_sidewidths(int left, int right) +{ + stbte__ui.left_width = left; + stbte__ui.right_width = right; +} + +void stbte_set_display(int x0, int y0, int x1, int y1) +{ + stbte__ui.x0 = x0; + stbte__ui.y0 = y0; + stbte__ui.x1 = x1; + stbte__ui.y1 = y1; +} + +void stbte_define_tile(stbte_tilemap *tm, unsigned short id, unsigned int layermask, const char * category_c) +{ + char *category = (char *) category_c; + STBTE_ASSERT(id < 32768); + STBTE_ASSERT(tm->num_tiles < tm->max_tiles); + STBTE_ASSERT((tm->id_in_use[id>>3]&(1<<(id&7))) == 0); + if (id >= 32768 || tm->num_tiles >= tm->max_tiles || (tm->id_in_use[id>>3]&(1<<(id&7)))) + return; + + if (category == NULL) + category = (char*) default_category; + tm->id_in_use[id>>3] |= 1 << (id&7); + tm->tiles[tm->num_tiles].category = category; + tm->tiles[tm->num_tiles].id = id; + tm->tiles[tm->num_tiles].layermask = layermask; + ++tm->num_tiles; + tm->tileinfo_dirty = 1; +} + +static int stbte__text_width(const char *str); + +void stbte_set_layername(stbte_tilemap *tm, int layer, const char *layername) +{ + STBTE_ASSERT(layer >= 0 && layer < tm->num_layers); + if (layer >= 0 && layer < tm->num_layers) { + int width; + tm->layerinfo[layer].name = layername; + tm->has_layer_names = 1; + width = stbte__text_width(layername); + tm->layername_width = (width > tm->layername_width ? width : tm->layername_width); + } +} + +void stbte_get_dimensions(stbte_tilemap *tm, int *max_x, int *max_y) +{ + *max_x = tm->max_x; + *max_y = tm->max_y; +} + +short* stbte_get_tile(stbte_tilemap *tm, int x, int y) +{ + STBTE_ASSERT(x >= 0 && x < tm->max_x && y >= 0 && y < tm->max_y); + if (x < 0 || x >= STBTE_MAX_TILEMAP_X || y < 0 || y >= STBTE_MAX_TILEMAP_Y) + return NULL; + return tm->data[y][x]; +} + +float *stbte_get_properties(stbte_tilemap *tm, int x, int y) +{ + STBTE_ASSERT(x >= 0 && x < tm->max_x && y >= 0 && y < tm->max_y); + if (x < 0 || x >= STBTE_MAX_TILEMAP_X || y < 0 || y >= STBTE_MAX_TILEMAP_Y) + return NULL; + return tm->props[y][x]; +} + +void stbte_get_link(stbte_tilemap *tm, int x, int y, int *destx, int *desty) +{ + int gx=-1,gy=-1; + STBTE_ASSERT(x >= 0 && x < tm->max_x && y >= 0 && y < tm->max_y); +#ifdef STBTE_ALLOW_LINK + if (x >= 0 && x < STBTE_MAX_TILEMAP_X && y >= 0 && y < STBTE_MAX_TILEMAP_Y) { + gx = tm->link[y][x].x; + gy = tm->link[y][x].y; + if (gx >= 0) + if (!STBTE_ALLOW_LINK(tm->data[y][x], tm->props[y][x], tm->data[gy][gx], tm->props[gy][gx])) + gx = gy = -1; + } +#endif + *destx = gx; + *desty = gy; +} + +void stbte_set_property(stbte_tilemap *tm, int x, int y, int n, float val) +{ + tm->props[y][x][n] = val; +} + +#ifdef STBTE_ALLOW_LINK +static void stbte__set_link(stbte_tilemap *tm, int src_x, int src_y, int dest_x, int dest_y, int undo_mode); +#endif + +enum +{ + STBTE__undo_none, + STBTE__undo_record, + STBTE__undo_block, +}; + +void stbte_set_link(stbte_tilemap *tm, int x, int y, int destx, int desty) +{ +#ifdef STBTE_ALLOW_LINK + stbte__set_link(tm, x, y, destx, desty, STBTE__undo_none); +#else + STBTE_ASSERT(0); +#endif +} + + +// returns an array of map_layers shorts. each short is either +// one of the tile_id values from define_tile, or STBTE_EMPTY + +void stbte_set_dimensions(stbte_tilemap *tm, int map_x, int map_y) +{ + STBTE_ASSERT(map_x >= 0 && map_x <= STBTE_MAX_TILEMAP_X); + STBTE_ASSERT(map_y >= 0 && map_y <= STBTE_MAX_TILEMAP_Y); + if (map_x < 0 || map_y < 0 || map_x > STBTE_MAX_TILEMAP_X || map_y > STBTE_MAX_TILEMAP_Y) + return; + tm->max_x = map_x; + tm->max_y = map_y; +} + +void stbte_clear_map(stbte_tilemap *tm) +{ + int i,j; + for (i=0; i < STBTE_MAX_TILEMAP_X * STBTE_MAX_TILEMAP_Y; ++i) { + tm->data[0][i][0] = tm->background_tile; + for (j=1; j < tm->num_layers; ++j) + tm->data[0][i][j] = STBTE__NO_TILE; + for (j=0; j < STBTE_MAX_PROPERTIES; ++j) + tm->props[0][i][j] = 0; + #ifdef STBTE_ALLOW_LINK + tm->link[0][i].x = -1; + tm->link[0][i].y = -1; + tm->linkcount[0][i] = 0; + #endif + } +} + +void stbte_set_tile(stbte_tilemap *tm, int x, int y, int layer, signed short tile) +{ + STBTE_ASSERT(x >= 0 && x < tm->max_x && y >= 0 && y < tm->max_y); + STBTE_ASSERT(layer >= 0 && layer < tm->num_layers); + STBTE_ASSERT(tile >= -1); + //STBTE_ASSERT(tile < 32768); + if (x < 0 || x >= STBTE_MAX_TILEMAP_X || y < 0 || y >= STBTE_MAX_TILEMAP_Y) + return; + if (layer < 0 || layer >= tm->num_layers || tile < -1) + return; + tm->data[y][x][layer] = tile; +} + +static void stbte__choose_category(stbte_tilemap *tm, int category) +{ + int i,n=0; + tm->cur_category = category; + for (i=0; i < tm->num_tiles; ++i) + if (tm->tiles[i].category_id == category || category == -1) + ++n; + tm->cur_palette_count = n; + tm->palette_scroll = 0; +} + +static int stbte__strequal(char *p, char *q) +{ + while (*p) + if (*p++ != *q++) return 0; + return *q == 0; +} + +static void stbte__compute_tileinfo(stbte_tilemap *tm) +{ + int i,j; + + tm->num_categories=0; + + for (i=0; i < tm->num_tiles; ++i) { + stbte__tileinfo *t = &tm->tiles[i]; + // find category + for (j=0; j < tm->num_categories; ++j) + if (stbte__strequal(t->category, tm->categories[j])) + goto found; + tm->categories[j] = t->category; + ++tm->num_categories; + found: + t->category_id = (unsigned short) j; + } + + // currently number of categories can never decrease because you + // can't remove tile definitions, but let's get it right anyway + if (tm->cur_category > tm->num_categories) { + tm->cur_category = -1; + } + + stbte__choose_category(tm, tm->cur_category); + + tm->tileinfo_dirty = 0; +} + +static void stbte__prepare_tileinfo(stbte_tilemap *tm) +{ + if (tm->tileinfo_dirty) + stbte__compute_tileinfo(tm); +} + + +/////////////////////// undo system //////////////////////// + +// the undo system works by storing "commands" into a buffer, and +// then playing back those commands. undo and redo have to store +// the commands in different order. +// +// the commands are: +// +// 1) end_of_undo_record +// -1:short +// +// 2) end_of_redo_record +// -2:short +// +// 3) tile update +// tile_id:short (-1..32767) +// x_coord:short +// y_coord:short +// layer:short (0..31) +// +// 4) property update (also used for links) +// value_hi:short +// value_lo:short +// y_coord:short +// x_coord:short +// property:short (256+prop#) +// +// Since we use a circular buffer, we might overwrite the undo storage. +// To detect this, before playing back commands we scan back and see +// if we see an end_of_undo_record before hitting the relevant boundary, +// it's wholly contained. +// +// When we read back through, we see them in reverse order, so +// we'll see the layer number or property number first +// +// To be clearer about the circular buffer, there are two cases: +// 1. a single record is larger than the whole buffer. +// this is caught because the end_of_undo_record will +// get overwritten. +// 2. multiple records written are larger than the whole +// buffer, so some of them have been overwritten by +// the later ones. this is handled by explicitly tracking +// the undo length; we never try to parse the data that +// got overwritten + +// given two points, compute the length between them +#define stbte__wrap(pos) ((pos) & (STBTE__UNDO_BUFFER_COUNT-1)) + +#define STBTE__undo_record -2 +#define STBTE__redo_record -3 +#define STBTE__undo_junk -4 // this is written underneath the undo pointer, never used + +static void stbte__write_undo(stbte_tilemap *tm, short value) +{ + int pos = tm->undo_pos; + tm->undo_buffer[pos] = value; + tm->undo_pos = stbte__wrap(pos+1); + tm->undo_len += (tm->undo_len < STBTE__UNDO_BUFFER_COUNT-2); + tm->redo_len -= (tm->redo_len > 0); + tm->undo_available_valid = 0; +} + +static void stbte__write_redo(stbte_tilemap *tm, short value) +{ + int pos = tm->undo_pos; + tm->undo_buffer[pos] = value; + tm->undo_pos = stbte__wrap(pos-1); + tm->redo_len += (tm->redo_len < STBTE__UNDO_BUFFER_COUNT-2); + tm->undo_len -= (tm->undo_len > 0); + tm->undo_available_valid = 0; +} + +static void stbte__begin_undo(stbte_tilemap *tm) +{ + tm->redo_len = 0; + stbte__write_undo(tm, STBTE__undo_record); + stbte__ui.undoing = 1; + stbte__ui.alert_msg = 0; // clear alert if they start doing something +} + +static void stbte__end_undo(stbte_tilemap *tm) +{ + if (stbte__ui.undoing) { + // check if anything got written + int pos = stbte__wrap(tm->undo_pos-1); + if (tm->undo_buffer[pos] == STBTE__undo_record) { + // empty undo record, move back + tm->undo_pos = pos; + STBTE_ASSERT(tm->undo_len > 0); + tm->undo_len -= 1; + } + tm->undo_buffer[tm->undo_pos] = STBTE__undo_junk; + // otherwise do nothing + + stbte__ui.undoing = 0; + } +} + +static void stbte__undo_record(stbte_tilemap *tm, int x, int y, int i, int v) +{ + STBTE_ASSERT(stbte__ui.undoing); + if (stbte__ui.undoing) { + stbte__write_undo(tm, v); + stbte__write_undo(tm, x); + stbte__write_undo(tm, y); + stbte__write_undo(tm, i); + } +} + +static void stbte__redo_record(stbte_tilemap *tm, int x, int y, int i, int v) +{ + stbte__write_redo(tm, v); + stbte__write_redo(tm, x); + stbte__write_redo(tm, y); + stbte__write_redo(tm, i); +} + +static float stbte__extract_float(short s0, short s1) +{ + union { float f; short s[2]; } converter; + converter.s[0] = s0; + converter.s[1] = s1; + return converter.f; +} + +static short stbte__extract_short(float f, int slot) +{ + union { float f; short s[2]; } converter; + converter.f = f; + return converter.s[slot]; +} + +static void stbte__undo_record_prop(stbte_tilemap *tm, int x, int y, int i, short s0, short s1) +{ + STBTE_ASSERT(stbte__ui.undoing); + if (stbte__ui.undoing) { + stbte__write_undo(tm, s1); + stbte__write_undo(tm, s0); + stbte__write_undo(tm, x); + stbte__write_undo(tm, y); + stbte__write_undo(tm, 256+i); + } +} + +static void stbte__undo_record_prop_float(stbte_tilemap *tm, int x, int y, int i, float f) +{ + stbte__undo_record_prop(tm, x,y,i, stbte__extract_short(f,0), stbte__extract_short(f,1)); +} + +static void stbte__redo_record_prop(stbte_tilemap *tm, int x, int y, int i, short s0, short s1) +{ + stbte__write_redo(tm, s1); + stbte__write_redo(tm, s0); + stbte__write_redo(tm, x); + stbte__write_redo(tm, y); + stbte__write_redo(tm, 256+i); +} + + +static int stbte__undo_find_end(stbte_tilemap *tm) +{ + // first scan through for the end record + int i, pos = stbte__wrap(tm->undo_pos-1); + for (i=0; i < tm->undo_len;) { + STBTE_ASSERT(tm->undo_buffer[pos] != STBTE__undo_junk); + if (tm->undo_buffer[pos] == STBTE__undo_record) + break; + if (tm->undo_buffer[pos] >= 255) + pos = stbte__wrap(pos-5), i += 5; + else + pos = stbte__wrap(pos-4), i += 4; + } + if (i >= tm->undo_len) + return -1; + return pos; +} + +static void stbte__undo(stbte_tilemap *tm) +{ + int i, pos, endpos; + endpos = stbte__undo_find_end(tm); + if (endpos < 0) + return; + + // we found a complete undo record + pos = stbte__wrap(tm->undo_pos-1); + + // start a redo record + stbte__write_redo(tm, STBTE__redo_record); + + // so now go back through undo and apply in reverse + // order, and copy it to redo + for (i=0; endpos != pos; i += 4) { + int x,y,n,v; + // get the undo entry + n = tm->undo_buffer[pos]; + y = tm->undo_buffer[stbte__wrap(pos-1)]; + x = tm->undo_buffer[stbte__wrap(pos-2)]; + v = tm->undo_buffer[stbte__wrap(pos-3)]; + if (n >= 255) { + short s0=0,s1=0; + int v2 = tm->undo_buffer[stbte__wrap(pos-4)]; + pos = stbte__wrap(pos-5); + if (n > 255) { + float vf = stbte__extract_float(v, v2); + s0 = stbte__extract_short(tm->props[y][x][n-256], 0); + s1 = stbte__extract_short(tm->props[y][x][n-256], 1); + tm->props[y][x][n-256] = vf; + } else { +#ifdef STBTE_ALLOW_LINK + s0 = tm->link[y][x].x; + s1 = tm->link[y][x].y; + stbte__set_link(tm, x,y, v, v2, STBTE__undo_none); +#endif + } + // write the redo entry + stbte__redo_record_prop(tm, x, y, n-256, s0,s1); + // apply the undo entry + } else { + pos = stbte__wrap(pos-4); + // write the redo entry + stbte__redo_record(tm, x, y, n, tm->data[y][x][n]); + // apply the undo entry + tm->data[y][x][n] = (short) v; + } + } + // overwrite undo record with junk + tm->undo_buffer[tm->undo_pos] = STBTE__undo_junk; +} + +static int stbte__redo_find_end(stbte_tilemap *tm) +{ + // first scan through for the end record + int i, pos = stbte__wrap(tm->undo_pos+1); + for (i=0; i < tm->redo_len;) { + STBTE_ASSERT(tm->undo_buffer[pos] != STBTE__undo_junk); + if (tm->undo_buffer[pos] == STBTE__redo_record) + break; + if (tm->undo_buffer[pos] >= 255) + pos = stbte__wrap(pos+5), i += 5; + else + pos = stbte__wrap(pos+4), i += 4; + } + if (i >= tm->redo_len) + return -1; // this should only ever happen if redo buffer is empty + return pos; +} + +static void stbte__redo(stbte_tilemap *tm) +{ + // first scan through for the end record + int i, pos, endpos; + endpos = stbte__redo_find_end(tm); + if (endpos < 0) + return; + + // we found a complete redo record + pos = stbte__wrap(tm->undo_pos+1); + + // start an undo record + stbte__write_undo(tm, STBTE__undo_record); + + for (i=0; pos != endpos; i += 4) { + int x,y,n,v; + n = tm->undo_buffer[pos]; + y = tm->undo_buffer[stbte__wrap(pos+1)]; + x = tm->undo_buffer[stbte__wrap(pos+2)]; + v = tm->undo_buffer[stbte__wrap(pos+3)]; + if (n >= 255) { + int v2 = tm->undo_buffer[stbte__wrap(pos+4)]; + short s0=0,s1=0; + pos = stbte__wrap(pos+5); + if (n > 255) { + float vf = stbte__extract_float(v, v2); + s0 = stbte__extract_short(tm->props[y][x][n-256],0); + s1 = stbte__extract_short(tm->props[y][x][n-256],1); + tm->props[y][x][n-256] = vf; + } else { +#ifdef STBTE_ALLOW_LINK + s0 = tm->link[y][x].x; + s1 = tm->link[y][x].y; + stbte__set_link(tm, x,y,v,v2, STBTE__undo_none); +#endif + } + // don't use stbte__undo_record_prop because it's guarded + stbte__write_undo(tm, s1); + stbte__write_undo(tm, s0); + stbte__write_undo(tm, x); + stbte__write_undo(tm, y); + stbte__write_undo(tm, n); + } else { + pos = stbte__wrap(pos+4); + // don't use stbte__undo_record because it's guarded + stbte__write_undo(tm, tm->data[y][x][n]); + stbte__write_undo(tm, x); + stbte__write_undo(tm, y); + stbte__write_undo(tm, n); + tm->data[y][x][n] = (short) v; + } + } + tm->undo_buffer[tm->undo_pos] = STBTE__undo_junk; +} + +// because detecting that undo is available +static void stbte__recompute_undo_available(stbte_tilemap *tm) +{ + tm->undo_available = (stbte__undo_find_end(tm) >= 0); + tm->redo_available = (stbte__redo_find_end(tm) >= 0); +} + +static int stbte__undo_available(stbte_tilemap *tm) +{ + if (!tm->undo_available_valid) + stbte__recompute_undo_available(tm); + return tm->undo_available; +} + +static int stbte__redo_available(stbte_tilemap *tm) +{ + if (!tm->undo_available_valid) + stbte__recompute_undo_available(tm); + return tm->redo_available; +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +#ifdef STBTE_ALLOW_LINK +static void stbte__set_link(stbte_tilemap *tm, int src_x, int src_y, int dest_x, int dest_y, int undo_mode) +{ + stbte__link *a; + STBTE_ASSERT(src_x >= 0 && src_x < STBTE_MAX_TILEMAP_X && src_y >= 0 && src_y < STBTE_MAX_TILEMAP_Y); + a = &tm->link[src_y][src_x]; + // check if it's a do nothing + if (a->x == dest_x && a->y == dest_y) + return; + if (undo_mode != STBTE__undo_none ) { + if (undo_mode == STBTE__undo_block) stbte__begin_undo(tm); + stbte__undo_record_prop(tm, src_x, src_y, -1, a->x, a->y); + if (undo_mode == STBTE__undo_block) stbte__end_undo(tm); + } + // check if there's an existing link + if (a->x >= 0) { + // decrement existing link refcount + STBTE_ASSERT(tm->linkcount[a->y][a->x] > 0); + --tm->linkcount[a->y][a->x]; + } + // increment new dest + if (dest_x >= 0) { + ++tm->linkcount[dest_y][dest_x]; + } + a->x = dest_x; + a->y = dest_y; +} +#endif + + +static void stbte__draw_rect(int x0, int y0, int x1, int y1, unsigned int color) +{ + STBTE_DRAW_RECT(x0,y0,x1,y1, color); +} + +#ifdef STBTE_ALLOW_LINK +static void stbte__draw_line(int x0, int y0, int x1, int y1, unsigned int color) +{ + int temp; + if (x1 < x0) temp=x0,x0=x1,x1=temp; + if (y1 < y0) temp=y0,y0=y1,y1=temp; + stbte__draw_rect(x0,y0,x1+1,y1+1,color); +} + +static void stbte__draw_link(int x0, int y0, int x1, int y1, unsigned int color) +{ + stbte__draw_line(x0,y0,x0,y1, color); + stbte__draw_line(x0,y1,x1,y1, color); +} +#endif + +static void stbte__draw_frame(int x0, int y0, int x1, int y1, unsigned int color) +{ + stbte__draw_rect(x0,y0,x1-1,y0+1,color); + stbte__draw_rect(x1-1,y0,x1,y1-1,color); + stbte__draw_rect(x0+1,y1-1,x1,y1,color); + stbte__draw_rect(x0,y0+1,x0+1,y1,color); +} + +static int stbte__get_char_width(int ch) +{ + return stbte__fontdata[ch-16]; +} + +static short *stbte__get_char_bitmap(int ch) +{ + return stbte__fontdata + stbte__font_offset[ch-16]; +} + +static void stbte__draw_bitmask_as_columns(int x, int y, short bitmask, int color) +{ + int start_i = -1, i=0; + while (bitmask) { + if (bitmask & (1<= 0) { + stbte__draw_rect(x, y+start_i, x+1, y+i, color); + start_i = -1; + bitmask &= ~((1< x_end) + break; + stbte__draw_bitmap(x, y, cw, stbte__get_char_bitmap(c), color); + if (digitspace && c == ' ') + cw = stbte__get_char_width('0'); + x += cw+1; + } +} + +static void stbte__draw_text(int x, int y, const char *str, int w, int color) +{ + stbte__draw_text_core(x,y,str,w,color,0); +} + +static int stbte__text_width(const char *str) +{ + int x = 0; + while (*str) { + int c = *str++; + int cw = stbte__get_char_width(c); + x += cw+1; + } + return x; +} + +static void stbte__draw_frame_delayed(int x0, int y0, int x1, int y1, int color) +{ + if (stbte__ui.delaycount < STBTE__MAX_DELAYRECT) { + stbte__colorrect r = { x0,y0,x1,y1,color }; + stbte__ui.delayrect[stbte__ui.delaycount++] = r; + } +} + +static void stbte__flush_delay(void) +{ + stbte__colorrect *r; + int i; + r = stbte__ui.delayrect; + for (i=0; i < stbte__ui.delaycount; ++i,++r) + stbte__draw_frame(r->x0,r->y0,r->x1,r->y1,r->color); + stbte__ui.delaycount = 0; +} + +static void stbte__activate(int id) +{ + stbte__ui.active_id = id; + stbte__ui.active_event = stbte__ui.event; + stbte__ui.accum_x = 0; + stbte__ui.accum_y = 0; +} + +static int stbte__hittest(int x0, int y0, int x1, int y1, int id) +{ + int over = stbte__ui.mx >= x0 && stbte__ui.my >= y0 + && stbte__ui.mx < x1 && stbte__ui.my < y1; + + if (over && stbte__ui.event >= STBTE__tick) + stbte__ui.next_hot_id = id; + + return over; +} + +static int stbte__button_core(int id) +{ + switch (stbte__ui.event) { + case STBTE__leftdown: + if (stbte__ui.hot_id == id && STBTE__INACTIVE()) + stbte__activate(id); + break; + case STBTE__leftup: + if (stbte__ui.active_id == id && STBTE__IS_HOT(id)) { + stbte__activate(0); + return 1; + } + break; + case STBTE__rightdown: + if (stbte__ui.hot_id == id && STBTE__INACTIVE()) + stbte__activate(id); + break; + case STBTE__rightup: + if (stbte__ui.active_id == id && STBTE__IS_HOT(id)) { + stbte__activate(0); + return -1; + } + break; + } + return 0; +} + +static void stbte__draw_box(int x0, int y0, int x1, int y1, int colormode, int colorindex) +{ + stbte__draw_rect (x0,y0,x1,y1, stbte__color_table[colormode][STBTE__base ][colorindex]); + stbte__draw_frame(x0,y0,x1,y1, stbte__color_table[colormode][STBTE__outline][colorindex]); +} + +static void stbte__draw_textbox(int x0, int y0, int x1, int y1, char *text, int xoff, int yoff, int colormode, int colorindex) +{ + stbte__draw_box(x0,y0,x1,y1,colormode,colorindex); + stbte__draw_text(x0+xoff,y0+yoff, text, x1-x0-xoff-1, stbte__color_table[colormode][STBTE__text][colorindex]); +} + +static int stbte__button(int colormode, const char *label, int x, int y, int textoff, int width, int id, int toggled, int disabled) +{ + int x0=x,y0=y, x1=x+width,y1=y+STBTE__BUTTON_HEIGHT; + int s = STBTE__BUTTON_INTERNAL_SPACING; + + if(!disabled) stbte__hittest(x0,y0,x1,y1,id); + + if (stbte__ui.event == STBTE__paint) + stbte__draw_textbox(x0,y0,x1,y1, (char*) label,s+textoff,s, colormode, STBTE__INDEX_FOR_ID(id,disabled,toggled)); + if (disabled) + return 0; + return (stbte__button_core(id) == 1); +} + +static int stbte__button_icon(int colormode, char ch, int x, int y, int width, int id, int toggled, int disabled) +{ + int x0=x,y0=y, x1=x+width,y1=y+STBTE__BUTTON_HEIGHT; + int s = STBTE__BUTTON_INTERNAL_SPACING; + + stbte__hittest(x0,y0,x1,y1,id); + + if (stbte__ui.event == STBTE__paint) { + char label[2] = { ch, 0 }; + int pad = (9 - stbte__get_char_width(ch))/2; + stbte__draw_textbox(x0,y0,x1,y1, label,s+pad,s, colormode, STBTE__INDEX_FOR_ID(id,disabled,toggled)); + } + if (disabled) + return 0; + return (stbte__button_core(id) == 1); +} + +static int stbte__minibutton(int colormode, int x, int y, int ch, int id) +{ + int x0 = x, y0 = y, x1 = x+8, y1 = y+7; + stbte__hittest(x0,y0,x1,y1,id); + if (stbte__ui.event == STBTE__paint) { + char str[2] = { (char)ch, 0 }; + stbte__draw_textbox(x0,y0,x1,y1, str,1,0,colormode, STBTE__INDEX_FOR_ID(id,0,0)); + } + return stbte__button_core(id); +} + +static int stbte__layerbutton(int x, int y, int ch, int id, int toggled, int disabled, int colormode) +{ + int x0 = x, y0 = y, x1 = x+10, y1 = y+11; + if(!disabled) stbte__hittest(x0,y0,x1,y1,id); + if (stbte__ui.event == STBTE__paint) { + char str[2] = { (char)ch, 0 }; + int off = (9-stbte__get_char_width(ch))/2; + stbte__draw_textbox(x0,y0,x1,y1, str, off+1,2, colormode, STBTE__INDEX_FOR_ID(id,disabled,toggled)); + } + if (disabled) + return 0; + return stbte__button_core(id); +} + +static int stbte__microbutton(int x, int y, int size, int id, int colormode) +{ + int x0 = x, y0 = y, x1 = x+size, y1 = y+size; + stbte__hittest(x0,y0,x1,y1,id); + if (stbte__ui.event == STBTE__paint) { + stbte__draw_box(x0,y0,x1,y1, colormode, STBTE__INDEX_FOR_ID(id,0,0)); + } + return stbte__button_core(id); +} + +static int stbte__microbutton_dragger(int x, int y, int size, int id, int *pos) +{ + int x0 = x, y0 = y, x1 = x+size, y1 = y+size; + stbte__hittest(x0,y0,x1,y1,id); + switch (stbte__ui.event) { + case STBTE__paint: + stbte__draw_box(x0,y0,x1,y1, STBTE__cexpander, STBTE__INDEX_FOR_ID(id,0,0)); + break; + case STBTE__leftdown: + if (STBTE__IS_HOT(id) && STBTE__INACTIVE()) { + stbte__activate(id); + stbte__ui.sx = stbte__ui.mx - *pos; + } + break; + case STBTE__mousemove: + if (STBTE__IS_ACTIVE(id) && stbte__ui.active_event == STBTE__leftdown) { + *pos = stbte__ui.mx - stbte__ui.sx; + } + break; + case STBTE__leftup: + if (STBTE__IS_ACTIVE(id)) + stbte__activate(0); + break; + default: + return stbte__button_core(id); + } + return 0; +} + +static int stbte__category_button(const char *label, int x, int y, int width, int id, int toggled) +{ + int x0=x,y0=y, x1=x+width,y1=y+STBTE__BUTTON_HEIGHT; + int s = STBTE__BUTTON_INTERNAL_SPACING; + + stbte__hittest(x0,y0,x1,y1,id); + + if (stbte__ui.event == STBTE__paint) + stbte__draw_textbox(x0,y0,x1,y1, (char*) label, s,s, STBTE__ccategory_button, STBTE__INDEX_FOR_ID(id,0,toggled)); + + return (stbte__button_core(id) == 1); +} + +enum +{ + STBTE__none, + STBTE__begin, + STBTE__end, + STBTE__change, +}; + +// returns -1 if value changes, 1 at end of drag +static int stbte__slider(int x0, int w, int y, int range, int *value, int id) +{ + int x1 = x0+w; + int pos = *value * w / (range+1); + stbte__hittest(x0,y-2,x1,y+3,id); + int event_mouse_move = STBTE__change; + switch (stbte__ui.event) { + case STBTE__paint: + stbte__draw_rect(x0,y,x1,y+1, 0x808080); + stbte__draw_rect(x0+pos-1,y-1,x0+pos+2,y+2, 0xffffff); + break; + case STBTE__leftdown: + if (STBTE__IS_HOT(id) && STBTE__INACTIVE()) { + stbte__activate(id); + event_mouse_move = STBTE__begin; + } + // fall through + case STBTE__mousemove: + if (STBTE__IS_ACTIVE(id)) { + int v = (stbte__ui.mx-x0)*(range+1)/w; + if (v < 0) v = 0; else if (v > range) v = range; + *value = v; + return event_mouse_move; + } + break; + case STBTE__leftup: + if (STBTE__IS_ACTIVE(id)) { + stbte__activate(0); + return STBTE__end; + } + break; + } + return STBTE__none; +} + +#if defined(_WIN32) && defined(__STDC_WANT_SECURE_LIB__) + #define stbte__sprintf sprintf_s + #define stbte__sizeof(s) , sizeof(s) +#else + #define stbte__sprintf sprintf + #define stbte__sizeof(s) +#endif + +static int stbte__float_control(int x0, int y0, int w, float minv, float maxv, float scale, const char *fmt, float *value, int colormode, int id) +{ + int x1 = x0+w; + int y1 = y0+11; + stbte__hittest(x0,y0,x1,y1,id); + switch (stbte__ui.event) { + case STBTE__paint: { + char text[32]; + stbte__sprintf(text stbte__sizeof(text), fmt ? fmt : "%6.2f", *value); + stbte__draw_textbox(x0,y0,x1,y1, text, 1,2, colormode, STBTE__INDEX_FOR_ID(id,0,0)); + break; + } + case STBTE__leftdown: + case STBTE__rightdown: + if (STBTE__IS_HOT(id) && STBTE__INACTIVE()) + stbte__activate(id); + return STBTE__begin; + break; + case STBTE__leftup: + case STBTE__rightup: + if (STBTE__IS_ACTIVE(id)) { + stbte__activate(0); + return STBTE__end; + } + break; + case STBTE__mousemove: + if (STBTE__IS_ACTIVE(id)) { + float v = *value, delta; + int ax = stbte__ui.accum_x/STBTE_FLOAT_CONTROL_GRANULARITY; + int ay = stbte__ui.accum_y/STBTE_FLOAT_CONTROL_GRANULARITY; + stbte__ui.accum_x -= ax*STBTE_FLOAT_CONTROL_GRANULARITY; + stbte__ui.accum_y -= ay*STBTE_FLOAT_CONTROL_GRANULARITY; + if (stbte__ui.shift) { + if (stbte__ui.active_event == STBTE__leftdown) + delta = ax * 16.0f + ay; + else + delta = ax / 16.0f + ay / 256.0f; + } else { + if (stbte__ui.active_event == STBTE__leftdown) + delta = ax*10.0f + ay; + else + delta = ax * 0.1f + ay * 0.01f; + } + v += delta * scale; + if (v < minv) v = minv; + if (v > maxv) v = maxv; + *value = v; + return STBTE__change; + } + break; + } + return STBTE__none; +} + +static void stbte__scrollbar(int x, int y0, int y1, int *val, int v0, int v1, int num_vis, int id) +{ + int thumbpos; + if (v1 - v0 <= num_vis) + return; + + // generate thumbpos from numvis + thumbpos = y0+2 + (y1-y0-4) * *val / (v1 - v0 - num_vis); + if (thumbpos < y0) thumbpos = y0; + if (thumbpos >= y1) thumbpos = y1; + stbte__hittest(x-1,y0,x+2,y1,id); + switch (stbte__ui.event) { + case STBTE__paint: + stbte__draw_rect(x,y0,x+1,y1, stbte__color_table[STBTE__cscrollbar][STBTE__text][STBTE__idle]); + stbte__draw_box(x-1,thumbpos-3,x+2,thumbpos+4, STBTE__cscrollbar, STBTE__INDEX_FOR_ID(id,0,0)); + break; + case STBTE__leftdown: + if (STBTE__IS_HOT(id) && STBTE__INACTIVE()) { + // check if it's over the thumb + stbte__activate(id); + *val = ((stbte__ui.my-y0) * (v1 - v0 - num_vis) + (y1-y0)/2)/ (y1-y0); + } + break; + case STBTE__mousemove: + if (STBTE__IS_ACTIVE(id) && stbte__ui.mx >= x-15 && stbte__ui.mx <= x+15) + *val = ((stbte__ui.my-y0) * (v1 - v0 - num_vis) + (y1-y0)/2)/ (y1-y0); + break; + case STBTE__leftup: + if (STBTE__IS_ACTIVE(id)) + stbte__activate(0); + break; + + } + + if (*val >= v1-num_vis) + *val = v1-num_vis; + if (*val <= v0) + *val = v0; +} + + +static void stbte__compute_digits(stbte_tilemap *tm) +{ + if (tm->max_x >= 1000 || tm->max_y >= 1000) + tm->digits = 4; + else if (tm->max_x >= 100 || tm->max_y >= 100) + tm->digits = 3; + else + tm->digits = 2; +} + +static int stbte__is_single_selection(void) +{ + return stbte__ui.has_selection + && stbte__ui.select_x0 == stbte__ui.select_x1 + && stbte__ui.select_y0 == stbte__ui.select_y1; +} + +typedef struct +{ + int width, height; + int x,y; + int active; + float retracted; +} stbte__region_t; + +static stbte__region_t stbte__region[4]; + +#define STBTE__TOOLBAR_ICON_SIZE (9+2*2) +#define STBTE__TOOLBAR_PASTE_SIZE (34+2*2) + +// This routine computes where every panel goes onscreen: computes +// a minimum width for each side based on which panels are on that +// side, and accounts for width-dependent layout of certain panels. +static void stbte__compute_panel_locations(stbte_tilemap *tm) +{ + int i, limit, w, k; + int window_width = stbte__ui.x1 - stbte__ui.x0; + int window_height = stbte__ui.y1 - stbte__ui.y0; + int min_width[STBTE__num_panel]={0,0,0,0,0,0,0}; + int height[STBTE__num_panel]={0,0,0,0,0,0,0}; + int panel_active[STBTE__num_panel]={1,0,1,1,1,1,1}; + int vpos[4] = { 0,0,0,0 }; + stbte__panel *p = stbte__ui.panel; + stbte__panel *pt = &p[STBTE__panel_toolbar]; +#ifdef STBTE__NO_PROPS + int props = 0; +#else + int props = 1; +#endif + + for (i=0; i < 4; ++i) { + stbte__region[i].active = 0; + stbte__region[i].width = 0; + stbte__region[i].height = 0; + } + + // compute number of digits needs for info panel + stbte__compute_digits(tm); + + // determine which panels are active + panel_active[STBTE__panel_categories] = tm->num_categories != 0; + panel_active[STBTE__panel_layers ] = tm->num_layers > 1; +#ifdef STBTE__COLORPICKER + panel_active[STBTE__panel_colorpick ] = 1; +#endif + + panel_active[STBTE__panel_props ] = props && stbte__is_single_selection(); + + // compute minimum widths for each panel (assuming they're on sides not top) + min_width[STBTE__panel_info ] = 8 + 11 + 7*tm->digits+17+7; // estimate min width of "w:0000" + min_width[STBTE__panel_colorpick ] = 120; + min_width[STBTE__panel_tiles ] = 4 + tm->palette_spacing_x + 5; // 5 for scrollbar + min_width[STBTE__panel_categories] = 4 + 42 + 5; // 42 is enough to show ~7 chars; 5 for scrollbar + min_width[STBTE__panel_layers ] = 4 + 54 + 30*tm->has_layer_names; // 2 digits plus 3 buttons plus scrollbar + min_width[STBTE__panel_toolbar ] = 4 + STBTE__TOOLBAR_PASTE_SIZE; // wide enough for 'Paste' button + min_width[STBTE__panel_props ] = 80; // narrowest info panel + + // compute minimum widths for left & right panels based on the above + stbte__region[0].width = stbte__ui.left_width; + stbte__region[1].width = stbte__ui.right_width; + + for (i=0; i < STBTE__num_panel; ++i) { + if (panel_active[i]) { + int side = stbte__ui.panel[i].side; + if (min_width[i] > stbte__region[side].width) + stbte__region[side].width = min_width[i]; + stbte__region[side].active = 1; + } + } + + // now compute the heights of each panel + + // if toolbar at top, compute its size & push the left and right start points down + if (stbte__region[STBTE__side_top].active) { + int height = STBTE__TOOLBAR_ICON_SIZE+2; + pt->x0 = stbte__ui.x0; + pt->y0 = stbte__ui.y0; + pt->width = window_width; + pt->height = height; + vpos[STBTE__side_left] = vpos[STBTE__side_right] = height; + } else { + int num_rows = STBTE__num_tool * ((stbte__region[pt->side].width-4)/STBTE__TOOLBAR_ICON_SIZE); + height[STBTE__panel_toolbar] = num_rows*13 + 3*15 + 4; // 3*15 for cut/copy/paste, which are stacked vertically + } + + for (i=0; i < 4; ++i) + stbte__region[i].y = stbte__ui.y0 + vpos[i]; + + for (i=0; i < 2; ++i) { + int anim = (int) (stbte__region[i].width * stbte__region[i].retracted); + stbte__region[i].x = (i == STBTE__side_left) ? stbte__ui.x0 - anim : stbte__ui.x1 - stbte__region[i].width + anim; + } + + // color picker + height[STBTE__panel_colorpick] = 300; + + // info panel + w = stbte__region[p[STBTE__panel_info].side].width; + p[STBTE__panel_info].mode = (w >= 8 + (11+7*tm->digits+17)*2 + 4); + if (p[STBTE__panel_info].mode) + height[STBTE__panel_info] = 5 + 11*2 + 2 + tm->palette_spacing_y; + else + height[STBTE__panel_info] = 5 + 11*4 + 2 + tm->palette_spacing_y; + + // layers + limit = 6 + stbte__ui.panel[STBTE__panel_layers].delta_height; + height[STBTE__panel_layers] = (tm->num_layers > limit ? limit : tm->num_layers)*15 + 7 + (tm->has_layer_names ? 0 : 11) + props*13; + + // categories + limit = 6 + stbte__ui.panel[STBTE__panel_categories].delta_height; + height[STBTE__panel_categories] = (tm->num_categories+1 > limit ? limit : tm->num_categories+1)*11 + 14; + if (stbte__ui.panel[STBTE__panel_categories].side == stbte__ui.panel[STBTE__panel_categories].side) + height[STBTE__panel_categories] -= 4; + + // palette + k = (stbte__region[p[STBTE__panel_tiles].side].width - 8) / tm->palette_spacing_x; + if (k == 0) k = 1; + height[STBTE__panel_tiles] = ((tm->num_tiles+k-1)/k) * tm->palette_spacing_y + 8; + + // properties panel + height[STBTE__panel_props] = 9 + STBTE_MAX_PROPERTIES*14; + + // now compute the locations of all the panels + for (i=0; i < STBTE__num_panel; ++i) { + if (panel_active[i]) { + int side = p[i].side; + if (side == STBTE__side_left || side == STBTE__side_right) { + p[i].width = stbte__region[side].width; + p[i].x0 = stbte__region[side].x; + p[i].y0 = stbte__ui.y0 + vpos[side]; + p[i].height = height[i]; + vpos[side] += height[i]; + if (vpos[side] > window_height) { + vpos[side] = window_height; + p[i].height = stbte__ui.y1 - p[i].y0; + } + } else { + ; // it's at top, it's already been explicitly set up earlier + } + } else { + // inactive panel + p[i].height = 0; + p[i].width = 0; + p[i].x0 = stbte__ui.x1; + p[i].y0 = stbte__ui.y1; + } + } +} + +// unique identifiers for imgui +enum +{ + STBTE__map=1, + STBTE__region, + STBTE__panel, // panel background to hide map, and misc controls + STBTE__info, // info data + STBTE__toolbarA, STBTE__toolbarB, // toolbar buttons: param is tool number + STBTE__palette, // palette selectors: param is tile index + STBTE__categories, // category selectors: param is category index + STBTE__layer, // + STBTE__solo, STBTE__hide, STBTE__lock, // layer controls: param is layer + STBTE__scrollbar, // param is panel ID + STBTE__panel_mover, // p1 is panel ID, p2 is destination side + STBTE__panel_sizer, // param panel ID + STBTE__scrollbar_id, + STBTE__colorpick_id, + STBTE__prop_flag, + STBTE__prop_float, + STBTE__prop_int, +}; + +// id is: [ 24-bit data : 7-bit identifier ] +// map id is: [ 12-bit y : 12 bit x : 7-bit identifier ] + +#define STBTE__ID(n,p) ((n) + ((p)<<7)) +#define STBTE__ID2(n,p,q) STBTE__ID(n, ((p)<<12)+(q) ) +#define STBTE__IDMAP(x,y) STBTE__ID2(STBTE__map, x,y) + +static void stbte__activate_map(int x, int y) +{ + stbte__ui.active_id = STBTE__IDMAP(x,y); + stbte__ui.active_event = stbte__ui.event; + stbte__ui.sx = x; + stbte__ui.sy = y; +} + +static void stbte__alert(const char *msg) +{ + stbte__ui.alert_msg = msg; + stbte__ui.alert_timer = 3; +} + +#define STBTE__BG(tm,layer) ((layer) == 0 ? (tm)->background_tile : STBTE__NO_TILE) + + + +static void stbte__brush_predict(stbte_tilemap *tm, short result[]) +{ + stbte__tileinfo *ti; + int i; + + if (tm->cur_tile < 0) return; + + ti = &tm->tiles[tm->cur_tile]; + + // find lowest legit layer to paint it on, and put it there + for (i=0; i < tm->num_layers; ++i) { + // check if object is allowed on layer + if (!(ti->layermask & (1 << i))) + continue; + + if (i != tm->solo_layer) { + // if there's a selected layer, can only paint on that + if (tm->cur_layer >= 0 && i != tm->cur_layer) + continue; + + // if the layer is hidden, we can't see it + if (tm->layerinfo[i].hidden) + continue; + + // if the layer is locked, we can't write to it + if (tm->layerinfo[i].locked == STBTE__locked) + continue; + + // if the layer is non-empty and protected, can't write to it + if (tm->layerinfo[i].locked == STBTE__protected && result[i] != STBTE__BG(tm,i)) + continue; + } + + result[i] = ti->id; + return; + } +} + +static void stbte__brush(stbte_tilemap *tm, int x, int y) +{ + stbte__tileinfo *ti; + + // find lowest legit layer to paint it on, and put it there + int i; + + if (tm->cur_tile < 0) return; + + ti = &tm->tiles[tm->cur_tile]; + + for (i=0; i < tm->num_layers; ++i) { + // check if object is allowed on layer + if (!(ti->layermask & (1 << i))) + continue; + + if (i != tm->solo_layer) { + // if there's a selected layer, can only paint on that + if (tm->cur_layer >= 0 && i != tm->cur_layer) + continue; + + // if the layer is hidden, we can't see it + if (tm->layerinfo[i].hidden) + continue; + + // if the layer is locked, we can't write to it + if (tm->layerinfo[i].locked == STBTE__locked) + continue; + + // if the layer is non-empty and protected, can't write to it + if (tm->layerinfo[i].locked == STBTE__protected && tm->data[y][x][i] != STBTE__BG(tm,i)) + continue; + } + + stbte__undo_record(tm,x,y,i,tm->data[y][x][i]); + tm->data[y][x][i] = ti->id; + return; + } + + //stbte__alert("Selected tile not valid on active layer(s)"); +} + +enum +{ + STBTE__erase_none = -1, + STBTE__erase_brushonly = 0, + STBTE__erase_any = 1, + STBTE__erase_all = 2, +}; + +static int stbte__erase_predict(stbte_tilemap *tm, short result[], int allow_any) +{ + stbte__tileinfo *ti = tm->cur_tile >= 0 ? &tm->tiles[tm->cur_tile] : NULL; + int i; + + if (allow_any == STBTE__erase_none) + return allow_any; + + // first check if only one layer is legit + i = tm->cur_layer; + if (tm->solo_layer >= 0) + i = tm->solo_layer; + + // if only one layer is legit, directly process that one for clarity + if (i >= 0) { + short bg = (i == 0 ? tm->background_tile : -1); + if (tm->solo_layer < 0) { + // check that we're allowed to write to it + if (tm->layerinfo[i].hidden) return STBTE__erase_none; + if (tm->layerinfo[i].locked) return STBTE__erase_none; + } + if (result[i] == bg) + return STBTE__erase_none; // didn't erase anything + if (ti && result[i] == ti->id && (i != 0 || ti->id != tm->background_tile)) { + result[i] = bg; + return STBTE__erase_brushonly; + } + if (allow_any == STBTE__erase_any) { + result[i] = bg; + return STBTE__erase_any; + } + return STBTE__erase_none; + } + + // if multiple layers are legit, first scan all for brush data + + if (ti && allow_any != STBTE__erase_all) { + for (i=tm->num_layers-1; i >= 0; --i) { + if (result[i] != ti->id) + continue; + if (tm->layerinfo[i].locked || tm->layerinfo[i].hidden) + continue; + if (i == 0 && result[i] == tm->background_tile) + return STBTE__erase_none; + result[i] = STBTE__BG(tm,i); + return STBTE__erase_brushonly; + } + } + + if (allow_any != STBTE__erase_any && allow_any != STBTE__erase_all) + return STBTE__erase_none; + + // apply layer filters, erase from top + for (i=tm->num_layers-1; i >= 0; --i) { + if (result[i] < 0) + continue; + if (tm->layerinfo[i].locked || tm->layerinfo[i].hidden) + continue; + if (i == 0 && result[i] == tm->background_tile) + return STBTE__erase_none; + result[i] = STBTE__BG(tm,i); + if (allow_any != STBTE__erase_all) + return STBTE__erase_any; + } + + if (allow_any == STBTE__erase_all) + return allow_any; + return STBTE__erase_none; +} + +static int stbte__erase(stbte_tilemap *tm, int x, int y, int allow_any) +{ + stbte__tileinfo *ti = tm->cur_tile >= 0 ? &tm->tiles[tm->cur_tile] : NULL; + int i; + + if (allow_any == STBTE__erase_none) + return allow_any; + + // first check if only one layer is legit + i = tm->cur_layer; + if (tm->solo_layer >= 0) + i = tm->solo_layer; + + // if only one layer is legit, directly process that one for clarity + if (i >= 0) { + short bg = (i == 0 ? tm->background_tile : -1); + if (tm->solo_layer < 0) { + // check that we're allowed to write to it + if (tm->layerinfo[i].hidden) return STBTE__erase_none; + if (tm->layerinfo[i].locked) return STBTE__erase_none; + } + if (tm->data[y][x][i] == bg) + return -1; // didn't erase anything + if (ti && tm->data[y][x][i] == ti->id && (i != 0 || ti->id != tm->background_tile)) { + stbte__undo_record(tm,x,y,i,tm->data[y][x][i]); + tm->data[y][x][i] = bg; + return STBTE__erase_brushonly; + } + if (allow_any == STBTE__erase_any) { + stbte__undo_record(tm,x,y,i,tm->data[y][x][i]); + tm->data[y][x][i] = bg; + return STBTE__erase_any; + } + return STBTE__erase_none; + } + + // if multiple layers are legit, first scan all for brush data + + if (ti && allow_any != STBTE__erase_all) { + for (i=tm->num_layers-1; i >= 0; --i) { + if (tm->data[y][x][i] != ti->id) + continue; + if (tm->layerinfo[i].locked || tm->layerinfo[i].hidden) + continue; + if (i == 0 && tm->data[y][x][i] == tm->background_tile) + return STBTE__erase_none; + stbte__undo_record(tm,x,y,i,tm->data[y][x][i]); + tm->data[y][x][i] = STBTE__BG(tm,i); + return STBTE__erase_brushonly; + } + } + + if (allow_any != STBTE__erase_any && allow_any != STBTE__erase_all) + return STBTE__erase_none; + + // apply layer filters, erase from top + for (i=tm->num_layers-1; i >= 0; --i) { + if (tm->data[y][x][i] < 0) + continue; + if (tm->layerinfo[i].locked || tm->layerinfo[i].hidden) + continue; + if (i == 0 && tm->data[y][x][i] == tm->background_tile) + return STBTE__erase_none; + stbte__undo_record(tm,x,y,i,tm->data[y][x][i]); + tm->data[y][x][i] = STBTE__BG(tm,i); + if (allow_any != STBTE__erase_all) + return STBTE__erase_any; + } + if (allow_any == STBTE__erase_all) + return allow_any; + return STBTE__erase_none; +} + +static int stbte__find_tile(stbte_tilemap *tm, int tile_id) +{ + int i; + for (i=0; i < tm->num_tiles; ++i) + if (tm->tiles[i].id == tile_id) + return i; + stbte__alert("Eyedropped tile that isn't in tileset"); + return -1; +} + +static void stbte__eyedrop(stbte_tilemap *tm, int x, int y) +{ + int i,j; + + // flush eyedropper state + if (stbte__ui.eyedrop_x != x || stbte__ui.eyedrop_y != y) { + stbte__ui.eyedrop_x = x; + stbte__ui.eyedrop_y = y; + stbte__ui.eyedrop_last_layer = tm->num_layers; + } + + // if only one layer is active, query that + i = tm->cur_layer; + if (tm->solo_layer >= 0) + i = tm->solo_layer; + if (i >= 0) { + if (tm->data[y][x][i] == STBTE__NO_TILE) + return; + tm->cur_tile = stbte__find_tile(tm, tm->data[y][x][i]); + return; + } + + // if multiple layers, continue from previous + i = stbte__ui.eyedrop_last_layer; + for (j=0; j < tm->num_layers; ++j) { + if (--i < 0) + i = tm->num_layers-1; + if (tm->layerinfo[i].hidden) + continue; + if (tm->data[y][x][i] == STBTE__NO_TILE) + continue; + stbte__ui.eyedrop_last_layer = i; + tm->cur_tile = stbte__find_tile(tm, tm->data[y][x][i]); + return; + } +} + +static int stbte__should_copy_properties(stbte_tilemap *tm) +{ + int i; + if (tm->propmode == STBTE__propmode_always) + return 1; + if (tm->propmode == STBTE__propmode_never) + return 0; + if (tm->solo_layer >= 0 || tm->cur_layer >= 0) + return 0; + for (i=0; i < tm->num_layers; ++i) + if (tm->layerinfo[i].hidden || tm->layerinfo[i].locked) + return 0; + return 1; +} + +// compute the result of pasting into a tile non-destructively so we can preview it +static void stbte__paste_stack(stbte_tilemap *tm, short result[], short dest[], short src[], int dragging) +{ + int i; + + // special case single-layer + i = tm->cur_layer; + if (tm->solo_layer >= 0) + i = tm->solo_layer; + if (i >= 0) { + if (tm->solo_layer < 0) { + // check that we're allowed to write to it + if (tm->layerinfo[i].hidden) return; + if (tm->layerinfo[i].locked == STBTE__locked) return; + // if protected, dest has to be empty + if (tm->layerinfo[i].locked == STBTE__protected && dest[i] != STBTE__BG(tm,i)) return; + // if dragging w/o copy, we will try to erase stuff, which protection disallows + if (dragging && tm->layerinfo[i].locked == STBTE__protected) + return; + } + result[i] = dest[i]; + if (src[i] != STBTE__BG(tm,i)) + result[i] = src[i]; + return; + } + + for (i=0; i < tm->num_layers; ++i) { + result[i] = dest[i]; + if (src[i] != STBTE__NO_TILE) + if (!tm->layerinfo[i].hidden && tm->layerinfo[i].locked != STBTE__locked) + if (tm->layerinfo[i].locked == STBTE__unlocked || (!dragging && dest[i] == STBTE__BG(tm,i))) + result[i] = src[i]; + } +} + +// compute the result of dragging away from a tile +static void stbte__clear_stack(stbte_tilemap *tm, short result[]) +{ + int i; + // special case single-layer + i = tm->cur_layer; + if (tm->solo_layer >= 0) + i = tm->solo_layer; + if (i >= 0) + result[i] = STBTE__BG(tm,i); + else + for (i=0; i < tm->num_layers; ++i) + if (!tm->layerinfo[i].hidden && tm->layerinfo[i].locked == STBTE__unlocked) + result[i] = STBTE__BG(tm,i); +} + +// check if some map square is active +#define STBTE__IS_MAP_ACTIVE() ((stbte__ui.active_id & 127) == STBTE__map) +#define STBTE__IS_MAP_HOT() ((stbte__ui.hot_id & 127) == STBTE__map) + +static void stbte__fillrect(stbte_tilemap *tm, int x0, int y0, int x1, int y1, int fill) +{ + int i,j; + + stbte__begin_undo(tm); + if (x0 > x1) i=x0,x0=x1,x1=i; + if (y0 > y1) j=y0,y0=y1,y1=j; + for (j=y0; j <= y1; ++j) + for (i=x0; i <= x1; ++i) + if (fill) + stbte__brush(tm, i,j); + else + stbte__erase(tm, i,j,STBTE__erase_any); + stbte__end_undo(tm); + // suppress warning from brush + stbte__ui.alert_msg = 0; +} + +static void stbte__select_rect(stbte_tilemap *tm, int x0, int y0, int x1, int y1) +{ + stbte__ui.has_selection = 1; + stbte__ui.select_x0 = (x0 < x1 ? x0 : x1); + stbte__ui.select_x1 = (x0 < x1 ? x1 : x0); + stbte__ui.select_y0 = (y0 < y1 ? y0 : y1); + stbte__ui.select_y1 = (y0 < y1 ? y1 : y0); +} + +static void stbte__copy_properties(float *dest, float *src) +{ + int i; + for (i=0; i < STBTE_MAX_PROPERTIES; ++i) + dest[i] = src[i]; +} + +static void stbte__copy_cut(stbte_tilemap *tm, int cut) +{ + int i,j,n,w,h,p=0; + int copy_props = stbte__should_copy_properties(tm); + if (!stbte__ui.has_selection) + return; + w = stbte__ui.select_x1 - stbte__ui.select_x0 + 1; + h = stbte__ui.select_y1 - stbte__ui.select_y0 + 1; + if (STBTE_MAX_COPY / w < h) { + stbte__alert("Selection too large for copy buffer, increase STBTE_MAX_COPY"); + return; + } + + for (i=0; i < w*h; ++i) + for (n=0; n < tm->num_layers; ++n) + stbte__ui.copybuffer[i][n] = STBTE__NO_TILE; + + if (cut) + stbte__begin_undo(tm); + for (j=stbte__ui.select_y0; j <= stbte__ui.select_y1; ++j) { + for (i=stbte__ui.select_x0; i <= stbte__ui.select_x1; ++i) { + for (n=0; n < tm->num_layers; ++n) { + if (tm->solo_layer >= 0) { + if (tm->solo_layer != n) + continue; + } else { + if (tm->cur_layer >= 0) + if (tm->cur_layer != n) + continue; + if (tm->layerinfo[n].hidden) + continue; + if (cut && tm->layerinfo[n].locked) + continue; + } + stbte__ui.copybuffer[p][n] = tm->data[j][i][n]; + if (cut) { + stbte__undo_record(tm,i,j,n, tm->data[j][i][n]); + tm->data[j][i][n] = (n==0 ? tm->background_tile : -1); + } + } + if (copy_props) { + stbte__copy_properties(stbte__ui.copyprops[p], tm->props[j][i]); +#ifdef STBTE_ALLOW_LINK + stbte__ui.copylinks[p] = tm->link[j][i]; + if (cut) + stbte__set_link(tm, i,j,-1,-1, STBTE__undo_record); +#endif + } + ++p; + } + } + if (cut) + stbte__end_undo(tm); + stbte__ui.copy_width = w; + stbte__ui.copy_height = h; + stbte__ui.has_copy = 1; + //stbte__ui.has_selection = 0; + stbte__ui.copy_has_props = copy_props; + stbte__ui.copy_src = tm; // used to give better semantics when copying links + stbte__ui.copy_src_x = stbte__ui.select_x0; + stbte__ui.copy_src_y = stbte__ui.select_y0; +} + +static int stbte__in_rect(int x, int y, int x0, int y0, int w, int h) +{ + return x >= x0 && x < x0+w && y >= y0 && y < y0+h; +} + +#ifdef STBTE_ALLOW_LINK +static int stbte__in_src_rect(int x, int y) +{ + return stbte__in_rect(x,y, stbte__ui.copy_src_x, stbte__ui.copy_src_y, stbte__ui.copy_width, stbte__ui.copy_height); +} + +static int stbte__in_dest_rect(int x, int y, int destx, int desty) +{ + return stbte__in_rect(x,y, destx, desty, stbte__ui.copy_width, stbte__ui.copy_height); +} +#endif + +static void stbte__paste(stbte_tilemap *tm, int mapx, int mapy) +{ + int w = stbte__ui.copy_width; + int h = stbte__ui.copy_height; + int i,j,k,p; + int x = mapx - (w>>1); + int y = mapy - (h>>1); + int copy_props = stbte__should_copy_properties(tm) && stbte__ui.copy_has_props; + if (stbte__ui.has_copy == 0) + return; + stbte__begin_undo(tm); + p = 0; + for (j=0; j < h; ++j) { + for (i=0; i < w; ++i) { + if (y+j >= 0 && y+j < tm->max_y && x+i >= 0 && x+i < tm->max_x) { + // compute the new stack + short tilestack[STBTE_MAX_LAYERS]; + for (k=0; k < tm->num_layers; ++k) + tilestack[k] = tm->data[y+j][x+i][k]; + stbte__paste_stack(tm, tilestack, tilestack, stbte__ui.copybuffer[p], 0); + // update anything that changed + for (k=0; k < tm->num_layers; ++k) { + if (tilestack[k] != tm->data[y+j][x+i][k]) { + stbte__undo_record(tm, x+i,y+j,k, tm->data[y+j][x+i][k]); + tm->data[y+j][x+i][k] = tilestack[k]; + } + } + } + if (copy_props) { +#ifdef STBTE_ALLOW_LINK + // need to decide how to paste a link, so there's a few cases + int destx = -1, desty = -1; + stbte__link *link = &stbte__ui.copylinks[p]; + + // check if link is within-rect + if (stbte__in_src_rect(link->x, link->y)) { + // new link should point to copy (but only if copy is within map) + destx = x + (link->x - stbte__ui.copy_src_x); + desty = y + (link->y - stbte__ui.copy_src_y); + } else if (tm == stbte__ui.copy_src) { + // if same map, then preserve link unless target is overwritten + if (!stbte__in_dest_rect(link->x,link->y,x,y)) { + destx = link->x; + desty = link->y; + } + } + // this is necessary for offset-copy, but also in case max_x/max_y has changed + if (destx < 0 || destx >= tm->max_x || desty < 0 || desty >= tm->max_y) + destx = -1, desty = -1; + stbte__set_link(tm, x+i, y+j, destx, desty, STBTE__undo_record); +#endif + for (k=0; k < STBTE_MAX_PROPERTIES; ++k) { + if (tm->props[y+j][x+i][k] != stbte__ui.copyprops[p][k]) + stbte__undo_record_prop_float(tm, x+i, y+j, k, tm->props[y+j][x+i][k]); + } + stbte__copy_properties(tm->props[y+j][x+i], stbte__ui.copyprops[p]); + } + ++p; + } + } + stbte__end_undo(tm); +} + +static void stbte__drag_update(stbte_tilemap *tm, int mapx, int mapy, int copy_props) +{ + int w = stbte__ui.drag_w, h = stbte__ui.drag_h; + int ox,oy,i,deleted=0,written=0; + short temp[STBTE_MAX_LAYERS]; + short *data = NULL; + + STBTE__NOTUSED(deleted); + STBTE__NOTUSED(written); + + if (!stbte__ui.shift) { + ox = mapx - stbte__ui.drag_x; + oy = mapy - stbte__ui.drag_y; + if (ox >= 0 && ox < w && oy >= 0 && oy < h) { + deleted=1; + for (i=0; i < tm->num_layers; ++i) + temp[i] = tm->data[mapy][mapx][i]; + data = temp; + stbte__clear_stack(tm, data); + } + } + ox = mapx - stbte__ui.drag_dest_x; + oy = mapy - stbte__ui.drag_dest_y; + // if this map square is in the target drag region + if (ox >= 0 && ox < w && oy >= 0 && oy < h) { + // and the src map square is on the map + if (stbte__in_rect(stbte__ui.drag_x+ox, stbte__ui.drag_y+oy, 0, 0, tm->max_x, tm->max_y)) { + written = 1; + if (data == NULL) { + for (i=0; i < tm->num_layers; ++i) + temp[i] = tm->data[mapy][mapx][i]; + data = temp; + } + stbte__paste_stack(tm, data, data, tm->data[stbte__ui.drag_y+oy][stbte__ui.drag_x+ox], !stbte__ui.shift); + if (copy_props) { + for (i=0; i < STBTE_MAX_PROPERTIES; ++i) { + if (tm->props[mapy][mapx][i] != tm->props[stbte__ui.drag_y+oy][stbte__ui.drag_x+ox][i]) { + stbte__undo_record_prop_float(tm, mapx, mapy, i, tm->props[mapy][mapx][i]); + tm->props[mapy][mapx][i] = tm->props[stbte__ui.drag_y+oy][stbte__ui.drag_x+ox][i]; + } + } + } + } + } + if (data) { + for (i=0; i < tm->num_layers; ++i) { + if (tm->data[mapy][mapx][i] != data[i]) { + stbte__undo_record(tm, mapx, mapy, i, tm->data[mapy][mapx][i]); + tm->data[mapy][mapx][i] = data[i]; + } + } + } + #ifdef STBTE_ALLOW_LINK + if (copy_props) { + int overwritten=0, moved=0, copied=0; + // since this function is called on EVERY tile, we can fix up even tiles not + // involved in the move + + stbte__link *k; + // first, determine what src link ends up here + k = &tm->link[mapy][mapx]; // by default, it's the one currently here + if (deleted) // if dragged away, it's erased + k = NULL; + if (written) // if dragged into, it gets that link + k = &tm->link[stbte__ui.drag_y+oy][stbte__ui.drag_x+ox]; + + // now check whether the *target* gets moved or overwritten + if (k && k->x >= 0) { + overwritten = stbte__in_rect(k->x, k->y, stbte__ui.drag_dest_x, stbte__ui.drag_dest_y, w, h); + if (!stbte__ui.shift) + moved = stbte__in_rect(k->x, k->y, stbte__ui.drag_x , stbte__ui.drag_y , w, h); + else + copied = stbte__in_rect(k->x, k->y, stbte__ui.drag_x , stbte__ui.drag_y , w, h); + } + + if (deleted || written || overwritten || moved || copied) { + // choose the final link value based on the above + if (k == NULL || k->x < 0) + stbte__set_link(tm, mapx, mapy, -1, -1, STBTE__undo_record); + else if (moved || (copied && written)) { + // if we move the target, we update to point to the new target; + // or, if we copy the target and the source is part of the copy, then update to new target + int x = k->x + (stbte__ui.drag_dest_x - stbte__ui.drag_x); + int y = k->y + (stbte__ui.drag_dest_y - stbte__ui.drag_y); + if (!(x >= 0 && y >= 0 && x < tm->max_x && y < tm->max_y)) + x = -1, y = -1; + stbte__set_link(tm, mapx, mapy, x, y, STBTE__undo_record); + } else if (overwritten) { + stbte__set_link(tm, mapx, mapy, -1, -1, STBTE__undo_record); + } else + stbte__set_link(tm, mapx, mapy, k->x, k->y, STBTE__undo_record); + } + } + #endif +} + +static void stbte__drag_place(stbte_tilemap *tm, int mapx, int mapy) +{ + int i,j; + int copy_props = stbte__should_copy_properties(tm); + int move_x = (stbte__ui.drag_dest_x - stbte__ui.drag_x); + int move_y = (stbte__ui.drag_dest_y - stbte__ui.drag_y); + if (move_x == 0 && move_y == 0) + return; + + stbte__begin_undo(tm); + // we now need a 2D memmove-style mover that doesn't + // overwrite any data as it goes. this requires being + // direction sensitive in the same way as memmove + if (move_y > 0 || (move_y == 0 && move_x > 0)) { + for (j=tm->max_y-1; j >= 0; --j) + for (i=tm->max_x-1; i >= 0; --i) + stbte__drag_update(tm,i,j,copy_props); + } else { + for (j=0; j < tm->max_y; ++j) + for (i=0; i < tm->max_x; ++i) + stbte__drag_update(tm,i,j,copy_props); + } + stbte__end_undo(tm); + + stbte__ui.has_selection = 1; + stbte__ui.select_x0 = stbte__ui.drag_dest_x; + stbte__ui.select_y0 = stbte__ui.drag_dest_y; + stbte__ui.select_x1 = stbte__ui.select_x0 + stbte__ui.drag_w - 1; + stbte__ui.select_y1 = stbte__ui.select_y0 + stbte__ui.drag_h - 1; +} + +static void stbte__tile_paint(stbte_tilemap *tm, int sx, int sy, int mapx, int mapy, int layer) +{ + int i; + int id = STBTE__IDMAP(mapx,mapy); + int x0=sx, y0=sy; + int x1=sx+tm->spacing_x, y1=sy+tm->spacing_y; + stbte__hittest(x0,y0,x1,y1, id); + short *data = tm->data[mapy][mapx]; + short temp[STBTE_MAX_LAYERS]; + + if (STBTE__IS_MAP_HOT()) { + if (stbte__ui.pasting) { + int ox = mapx - stbte__ui.paste_x; + int oy = mapy - stbte__ui.paste_y; + if (ox >= 0 && ox < stbte__ui.copy_width && oy >= 0 && oy < stbte__ui.copy_height) { + stbte__paste_stack(tm, temp, tm->data[mapy][mapx], stbte__ui.copybuffer[oy*stbte__ui.copy_width+ox], 0); + data = temp; + } + } else if (stbte__ui.dragging) { + int ox,oy; + for (i=0; i < tm->num_layers; ++i) + temp[i] = tm->data[mapy][mapx][i]; + data = temp; + + // if it's in the source area, remove things unless shift-dragging + ox = mapx - stbte__ui.drag_x; + oy = mapy - stbte__ui.drag_y; + if (!stbte__ui.shift && ox >= 0 && ox < stbte__ui.drag_w && oy >= 0 && oy < stbte__ui.drag_h) { + stbte__clear_stack(tm, temp); + } + + ox = mapx - stbte__ui.drag_dest_x; + oy = mapy - stbte__ui.drag_dest_y; + if (ox >= 0 && ox < stbte__ui.drag_w && oy >= 0 && oy < stbte__ui.drag_h) { + stbte__paste_stack(tm, temp, temp, tm->data[stbte__ui.drag_y+oy][stbte__ui.drag_x+ox], !stbte__ui.shift); + } + } else if (STBTE__IS_MAP_ACTIVE()) { + if (stbte__ui.tool == STBTE__tool_rect) { + if ((stbte__ui.ms_time & 511) < 380) { + int ex = ((stbte__ui.hot_id >> 19) & 4095); + int ey = ((stbte__ui.hot_id >> 7) & 4095); + int sx = stbte__ui.sx; + int sy = stbte__ui.sy; + + if ( ((mapx >= sx && mapx < ex+1) || (mapx >= ex && mapx < sx+1)) + && ((mapy >= sy && mapy < ey+1) || (mapy >= ey && mapy < sy+1))) { + int i; + for (i=0; i < tm->num_layers; ++i) + temp[i] = tm->data[mapy][mapx][i]; + data = temp; + if (stbte__ui.active_event == STBTE__leftdown) + stbte__brush_predict(tm, temp); + else + stbte__erase_predict(tm, temp, STBTE__erase_any); + } + } + } + } + } + + if (STBTE__IS_HOT(id) && STBTE__INACTIVE() && !stbte__ui.pasting) { + if (stbte__ui.tool == STBTE__tool_brush) { + if ((stbte__ui.ms_time & 511) < 300) { + data = temp; + for (i=0; i < tm->num_layers; ++i) + temp[i] = tm->data[mapy][mapx][i]; + stbte__brush_predict(tm, temp); + } + } + } + + { + i = layer; + if (i == tm->solo_layer || (!tm->layerinfo[i].hidden && tm->solo_layer < 0)) + if (data[i] >= 0) + STBTE_DRAW_TILE(sx,sy, (unsigned short) data[i], 0, tm->props[mapy][mapx]); + } +} + +static void stbte__tile(stbte_tilemap *tm, int sx, int sy, int mapx, int mapy) +{ + int tool = stbte__ui.tool; + int x0=sx, y0=sy; + int x1=sx+tm->spacing_x, y1=sy+tm->spacing_y; + int id = STBTE__IDMAP(mapx,mapy); + int over = stbte__hittest(x0,y0,x1,y1, id); + switch (stbte__ui.event) { + case STBTE__paint: { + if (stbte__ui.pasting || stbte__ui.dragging || stbte__ui.scrolling) + break; + if (stbte__ui.scrollkey && !STBTE__IS_MAP_ACTIVE()) + break; + if (STBTE__IS_HOT(id) && STBTE__IS_MAP_ACTIVE() && (tool == STBTE__tool_rect || tool == STBTE__tool_select)) { + int rx0,ry0,rx1,ry1,t; + // compute the center of each rect + rx0 = x0 + tm->spacing_x/2; + ry0 = y0 + tm->spacing_y/2; + rx1 = rx0 + (stbte__ui.sx - mapx) * tm->spacing_x; + ry1 = ry0 + (stbte__ui.sy - mapy) * tm->spacing_y; + if (rx0 > rx1) t=rx0,rx0=rx1,rx1=t; + if (ry0 > ry1) t=ry0,ry0=ry1,ry1=t; + rx0 -= tm->spacing_x/2; + ry0 -= tm->spacing_y/2; + rx1 += tm->spacing_x/2; + ry1 += tm->spacing_y/2; + stbte__draw_frame(rx0-1,ry0-1,rx1+1,ry1+1, STBTE_COLOR_TILEMAP_HIGHLIGHT); + break; + } + if (STBTE__IS_HOT(id) && STBTE__INACTIVE()) { + stbte__draw_frame(x0-1,y0-1,x1+1,y1+1, STBTE_COLOR_TILEMAP_HIGHLIGHT); + } +#ifdef STBTE_ALLOW_LINK + if (stbte__ui.show_links && tm->link[mapy][mapx].x >= 0) { + int tx = tm->link[mapy][mapx].x; + int ty = tm->link[mapy][mapx].y; + int lx0,ly0,lx1,ly1; + if (STBTE_ALLOW_LINK(tm->data[mapy][mapx], tm->props[mapy][mapx], + tm->data[ty ][tx ], tm->props[ty ][tx ])) + { + lx0 = x0 + (tm->spacing_x >> 1) - 1; + ly0 = y0 + (tm->spacing_y >> 1) - 1; + lx1 = lx0 + (tx - mapx) * tm->spacing_x + 2; + ly1 = ly0 + (ty - mapy) * tm->spacing_y + 2; + stbte__draw_link(lx0,ly0,lx1,ly1, + STBTE_LINK_COLOR(tm->data[mapy][mapx], tm->props[mapy][mapx], + tm->data[ty ][tx ], tm->props[ty ][tx])); + } + } +#endif + break; + } + } + + if (stbte__ui.pasting) { + switch (stbte__ui.event) { + case STBTE__leftdown: + if (STBTE__IS_HOT(id)) { + stbte__ui.pasting = 0; + stbte__paste(tm, mapx, mapy); + stbte__activate(0); + } + break; + case STBTE__leftup: + // just clear it no matter what, since they might click away to clear it + stbte__activate(0); + break; + case STBTE__rightdown: + if (STBTE__IS_HOT(id)) { + stbte__activate(0); + stbte__ui.pasting = 0; + } + break; + } + return; + } + + if (stbte__ui.scrolling) { + if (stbte__ui.event == STBTE__leftup) { + stbte__activate(0); + stbte__ui.scrolling = 0; + } + if (stbte__ui.event == STBTE__mousemove) { + tm->scroll_x += (stbte__ui.start_x - stbte__ui.mx); + tm->scroll_y += (stbte__ui.start_y - stbte__ui.my); + stbte__ui.start_x = stbte__ui.mx; + stbte__ui.start_y = stbte__ui.my; + } + return; + } + + // regardless of tool, leftdown is a scrolldrag + if (STBTE__IS_HOT(id) && stbte__ui.scrollkey && stbte__ui.event == STBTE__leftdown) { + stbte__ui.scrolling = 1; + stbte__ui.start_x = stbte__ui.mx; + stbte__ui.start_y = stbte__ui.my; + return; + } + + switch (tool) { + case STBTE__tool_brush: + switch (stbte__ui.event) { + case STBTE__mousemove: + if (STBTE__IS_MAP_ACTIVE() && over) { + // don't brush/erase same tile multiple times unless they move away and back @TODO should just be only once, but that needs another data structure + if (!STBTE__IS_ACTIVE(id)) { + if (stbte__ui.active_event == STBTE__leftdown) + stbte__brush(tm, mapx, mapy); + else + stbte__erase(tm, mapx, mapy, stbte__ui.brush_state); + stbte__ui.active_id = id; // switch to this map square so we don't rebrush IT multiple times + } + } + break; + case STBTE__leftdown: + if (STBTE__IS_HOT(id) && STBTE__INACTIVE()) { + stbte__activate(id); + stbte__begin_undo(tm); + stbte__brush(tm, mapx, mapy); + } + break; + case STBTE__rightdown: + if (STBTE__IS_HOT(id) && STBTE__INACTIVE()) { + stbte__activate(id); + stbte__begin_undo(tm); + if (stbte__erase(tm, mapx, mapy, STBTE__erase_any) == STBTE__erase_brushonly) + stbte__ui.brush_state = STBTE__erase_brushonly; + else + stbte__ui.brush_state = STBTE__erase_any; + } + break; + case STBTE__leftup: + case STBTE__rightup: + if (STBTE__IS_MAP_ACTIVE()) { + stbte__end_undo(tm); + stbte__activate(0); + } + break; + } + break; + +#ifdef STBTE_ALLOW_LINK + case STBTE__tool_link: + switch (stbte__ui.event) { + case STBTE__leftdown: + if (STBTE__IS_HOT(id) && STBTE__INACTIVE()) { + stbte__activate(id); + stbte__ui.linking = 1; + stbte__ui.sx = mapx; + stbte__ui.sy = mapy; + // @TODO: undo + } + break; + case STBTE__leftup: + if (STBTE__IS_HOT(id) && STBTE__IS_MAP_ACTIVE()) { + if ((mapx != stbte__ui.sx || mapy != stbte__ui.sy) && + STBTE_ALLOW_LINK(tm->data[stbte__ui.sy][stbte__ui.sx], tm->props[stbte__ui.sy][stbte__ui.sx], + tm->data[mapy][mapx], tm->props[mapy][mapx])) + stbte__set_link(tm, stbte__ui.sx, stbte__ui.sy, mapx, mapy, STBTE__undo_block); + else + stbte__set_link(tm, stbte__ui.sx, stbte__ui.sy, -1,-1, STBTE__undo_block); + stbte__ui.linking = 0; + stbte__activate(0); + } + break; + + case STBTE__rightdown: + if (STBTE__IS_ACTIVE(id)) { + stbte__activate(0); + stbte__ui.linking = 0; + } + break; + } + break; +#endif + + case STBTE__tool_erase: + switch (stbte__ui.event) { + case STBTE__mousemove: + if (STBTE__IS_MAP_ACTIVE() && over) + stbte__erase(tm, mapx, mapy, STBTE__erase_all); + break; + case STBTE__leftdown: + if (STBTE__IS_HOT(id) && STBTE__INACTIVE()) { + stbte__activate(id); + stbte__begin_undo(tm); + stbte__erase(tm, mapx, mapy, STBTE__erase_all); + } + break; + case STBTE__leftup: + if (STBTE__IS_MAP_ACTIVE()) { + stbte__end_undo(tm); + stbte__activate(0); + } + break; + } + break; + + case STBTE__tool_select: + if (STBTE__IS_HOT(id)) { + switch (stbte__ui.event) { + case STBTE__leftdown: + if (STBTE__INACTIVE()) { + // if we're clicking in an existing selection... + if (stbte__ui.has_selection) { + if ( mapx >= stbte__ui.select_x0 && mapx <= stbte__ui.select_x1 + && mapy >= stbte__ui.select_y0 && mapy <= stbte__ui.select_y1) + { + stbte__ui.dragging = 1; + stbte__ui.drag_x = stbte__ui.select_x0; + stbte__ui.drag_y = stbte__ui.select_y0; + stbte__ui.drag_w = stbte__ui.select_x1 - stbte__ui.select_x0 + 1; + stbte__ui.drag_h = stbte__ui.select_y1 - stbte__ui.select_y0 + 1; + stbte__ui.drag_offx = mapx - stbte__ui.select_x0; + stbte__ui.drag_offy = mapy - stbte__ui.select_y0; + } + } + stbte__ui.has_selection = 0; // no selection until it completes + stbte__activate_map(mapx,mapy); + } + break; + case STBTE__leftup: + if (STBTE__IS_MAP_ACTIVE()) { + if (stbte__ui.dragging) { + stbte__drag_place(tm, mapx,mapy); + stbte__ui.dragging = 0; + stbte__activate(0); + } else { + stbte__select_rect(tm, stbte__ui.sx, stbte__ui.sy, mapx, mapy); + stbte__activate(0); + } + } + break; + case STBTE__rightdown: + stbte__ui.has_selection = 0; + break; + } + } + break; + + case STBTE__tool_rect: + if (STBTE__IS_HOT(id)) { + switch (stbte__ui.event) { + case STBTE__leftdown: + if (STBTE__INACTIVE()) + stbte__activate_map(mapx,mapy); + break; + case STBTE__leftup: + if (STBTE__IS_MAP_ACTIVE()) { + stbte__fillrect(tm, stbte__ui.sx, stbte__ui.sy, mapx, mapy, 1); + stbte__activate(0); + } + break; + case STBTE__rightdown: + if (STBTE__INACTIVE()) + stbte__activate_map(mapx,mapy); + break; + case STBTE__rightup: + if (STBTE__IS_MAP_ACTIVE()) { + stbte__fillrect(tm, stbte__ui.sx, stbte__ui.sy, mapx, mapy, 0); + stbte__activate(0); + } + break; + } + } + break; + + + case STBTE__tool_eyedrop: + switch (stbte__ui.event) { + case STBTE__leftdown: + if (STBTE__IS_HOT(id) && STBTE__INACTIVE()) + stbte__eyedrop(tm,mapx,mapy); + break; + } + break; + } +} + +static void stbte__start_paste(stbte_tilemap *tm) +{ + if (stbte__ui.has_copy) { + stbte__ui.pasting = 1; + stbte__activate(STBTE__ID(STBTE__toolbarB,3)); + } +} + +static void stbte__toolbar(stbte_tilemap *tm, int x0, int y0, int w, int h) +{ + int i; + int estimated_width = 13 * STBTE__num_tool + 8+8+ 120+4 - 30; + int x = x0 + w/2 - estimated_width/2; + int y = y0+1; + + for (i=0; i < STBTE__num_tool; ++i) { + int highlight=0, disable=0; + highlight = (stbte__ui.tool == i); + if (i == STBTE__tool_undo || i == STBTE__tool_showgrid) + x += 8; + if (i == STBTE__tool_showgrid && stbte__ui.show_grid) + highlight = 1; + if (i == STBTE__tool_showlinks && stbte__ui.show_links) + highlight = 1; + if (i == STBTE__tool_fill) + continue; + #ifndef STBTE_ALLOW_LINK + if (i == STBTE__tool_link || i == STBTE__tool_showlinks) + disable = 1; + #endif + if (i == STBTE__tool_undo && !stbte__undo_available(tm)) + disable = 1; + if (i == STBTE__tool_redo && !stbte__redo_available(tm)) + disable = 1; + if (stbte__button_icon(STBTE__ctoolbar_button, toolchar[i], x, y, 13, STBTE__ID(STBTE__toolbarA, i), highlight, disable)) { + switch (i) { + case STBTE__tool_eyedrop: + stbte__ui.eyedrop_last_layer = tm->num_layers; // flush eyedropper state + // fallthrough + default: + stbte__ui.tool = i; + stbte__ui.has_selection = 0; + break; + case STBTE__tool_showlinks: + stbte__ui.show_links = !stbte__ui.show_links; + break; + case STBTE__tool_showgrid: + stbte__ui.show_grid = (stbte__ui.show_grid+1)%3; + break; + case STBTE__tool_undo: + stbte__undo(tm); + break; + case STBTE__tool_redo: + stbte__redo(tm); + break; + } + } + x += 13; + } + + x += 8; + if (stbte__button(STBTE__ctoolbar_button, "cut" , x, y,10, 40, STBTE__ID(STBTE__toolbarB,0), 0, !stbte__ui.has_selection)) + stbte__copy_cut(tm, 1); + x += 42; + if (stbte__button(STBTE__ctoolbar_button, "copy" , x, y, 5, 40, STBTE__ID(STBTE__toolbarB,1), 0, !stbte__ui.has_selection)) + stbte__copy_cut(tm, 0); + x += 42; + if (stbte__button(STBTE__ctoolbar_button, "paste", x, y, 0, 40, STBTE__ID(STBTE__toolbarB,2), stbte__ui.pasting, !stbte__ui.has_copy)) + stbte__start_paste(tm); +} + +#define STBTE__TEXTCOLOR(n) stbte__color_table[n][STBTE__text][STBTE__idle] + +static int stbte__info_value(const char *label, int x, int y, int val, int digits, int id) +{ + if (stbte__ui.event == STBTE__paint) { + int off = 9-stbte__get_char_width(label[0]); + char text[16]; + stbte__sprintf(text stbte__sizeof(text), label, digits, val); + stbte__draw_text_core(x+off,y, text, 999, STBTE__TEXTCOLOR(STBTE__cpanel),1); + } + if (id) { + x += 9+7*digits+4; + if (stbte__minibutton(STBTE__cmapsize, x,y, '+', STBTE__ID2(id,1,0))) + val += (stbte__ui.shift ? 10 : 1); + x += 9; + if (stbte__minibutton(STBTE__cmapsize, x,y, '-', STBTE__ID2(id,2,0))) + val -= (stbte__ui.shift ? 10 : 1); + if (val < 1) val = 1; else if (val > 4096) val = 4096; + } + return val; +} + +static void stbte__info(stbte_tilemap *tm, int x0, int y0, int w, int h) +{ + int mode = stbte__ui.panel[STBTE__panel_info].mode; + int s = 11+7*tm->digits+4+15; + int x,y; + int in_region; + + x = x0+2; + y = y0+2; + tm->max_x = stbte__info_value("w:%*d",x,y, tm->max_x, tm->digits, STBTE__ID(STBTE__info,0)); + if (mode) + x += s; + else + y += 11; + tm->max_y = stbte__info_value("h:%*d",x,y, tm->max_y, tm->digits, STBTE__ID(STBTE__info,1)); + x = x0+2; + y += 11; + in_region = (stbte__ui.hot_id & 127) == STBTE__map; + stbte__info_value(in_region ? "x:%*d" : "x:",x,y, (stbte__ui.hot_id>>19)&4095, tm->digits, 0); + if (mode) + x += s; + else + y += 11; + stbte__info_value(in_region ? "y:%*d" : "y:",x,y, (stbte__ui.hot_id>> 7)&4095, tm->digits, 0); + y += 15; + x = x0+2; + stbte__draw_text(x,y,"brush:",40,STBTE__TEXTCOLOR(STBTE__cpanel)); + if (tm->cur_tile >= 0) + STBTE_DRAW_TILE(x+43,y-3,tm->tiles[tm->cur_tile].id,1,0); +} + +static void stbte__layers(stbte_tilemap *tm, int x0, int y0, int w, int h) +{ + static const char *propmodes[3] = { + "default", "always", "never" + }; + int num_rows; + int i, y, n; + int x1 = x0+w; + int y1 = y0+h; + int xoff = 20; + + if (tm->has_layer_names) { + int side = stbte__ui.panel[STBTE__panel_layers].side; + xoff = stbte__region[side].width - 42; + xoff = (xoff < tm->layername_width + 10 ? xoff : tm->layername_width + 10); + } + + x0 += 2; + y0 += 5; + if (!tm->has_layer_names) { + if (stbte__ui.event == STBTE__paint) { + stbte__draw_text(x0,y0, "Layers", w-4, STBTE__TEXTCOLOR(STBTE__cpanel)); + } + y0 += 11; + } + num_rows = (y1-y0)/15; +#ifndef STBTE_NO_PROPS + --num_rows; +#endif + y = y0; + for (i=0; i < tm->num_layers; ++i) { + char text[3], *str = (char *) tm->layerinfo[i].name; + static char lockedchar[3] = { 'U', 'P', 'L' }; + int locked = tm->layerinfo[i].locked; + int disabled = (tm->solo_layer >= 0 && tm->solo_layer != i); + if (i-tm->layer_scroll >= 0 && i-tm->layer_scroll < num_rows) { + if (str == NULL) + stbte__sprintf(str=text stbte__sizeof(text), "%2d", i+1); + if (stbte__button(STBTE__clayer_button, str, x0,y,(i+1<10)*2,xoff-2, STBTE__ID(STBTE__layer,i), tm->cur_layer==i,0)) + tm->cur_layer = (tm->cur_layer == i ? -1 : i); + if (stbte__layerbutton(x0+xoff + 0,y+1,'H',STBTE__ID(STBTE__hide,i), tm->layerinfo[i].hidden,disabled,STBTE__clayer_hide)) + tm->layerinfo[i].hidden = !tm->layerinfo[i].hidden; + if (stbte__layerbutton(x0+xoff + 12,y+1,lockedchar[locked],STBTE__ID(STBTE__lock,i), locked!=0,disabled,STBTE__clayer_lock)) + tm->layerinfo[i].locked = (locked+1)%3; + if (stbte__layerbutton(x0+xoff + 24,y+1,'S',STBTE__ID(STBTE__solo,i), tm->solo_layer==i,0,STBTE__clayer_solo)) + tm->solo_layer = (tm->solo_layer == i ? -1 : i); + y += 15; + } + } + stbte__scrollbar(x1-4, y0,y-2, &tm->layer_scroll, 0, tm->num_layers, num_rows, STBTE__ID(STBTE__scrollbar_id, STBTE__layer)); +#ifndef STBTE_NO_PROPS + n = stbte__text_width("prop:")+2; + stbte__draw_text(x0,y+2, "prop:", w, STBTE__TEXTCOLOR(STBTE__cpanel)); + i = w - n - 4; + if (i > 50) i = 50; + if (stbte__button(STBTE__clayer_button, propmodes[tm->propmode], x0+n,y,0,i, STBTE__ID(STBTE__layer,256), 0,0)) + tm->propmode = (tm->propmode+1)%3; +#endif +} + +static void stbte__categories(stbte_tilemap *tm, int x0, int y0, int w, int h) +{ + int s=11, x,y, i; + int num_rows = h / s; + + w -= 4; + x = x0+2; + y = y0+4; + if (tm->category_scroll == 0) { + if (stbte__category_button("*ALL*", x,y, w, STBTE__ID(STBTE__categories, 65535), tm->cur_category == -1)) { + stbte__choose_category(tm, -1); + } + y += s; + } + + for (i=0; i < tm->num_categories; ++i) { + if (i+1 - tm->category_scroll >= 0 && i+1 - tm->category_scroll < num_rows) { + if (y + 10 > y0+h) + return; + if (stbte__category_button(tm->categories[i], x,y,w, STBTE__ID(STBTE__categories,i), tm->cur_category == i)) + stbte__choose_category(tm, i); + y += s; + } + } + stbte__scrollbar(x0+w, y0+4, y0+h-4, &tm->category_scroll, 0, tm->num_categories+1, num_rows, STBTE__ID(STBTE__scrollbar_id, STBTE__categories)); +} + +static void stbte__tile_in_palette(stbte_tilemap *tm, int x, int y, int slot) +{ + stbte__tileinfo *t = &tm->tiles[slot]; + int x0=x, y0=y, x1 = x+tm->palette_spacing_x - 1, y1 = y+tm->palette_spacing_y; + int id = STBTE__ID(STBTE__palette, slot); + stbte__hittest(x0,y0,x1,y1, id); + switch (stbte__ui.event) { + case STBTE__paint: + stbte__draw_rect(x,y,x+tm->palette_spacing_x-1,y+tm->palette_spacing_x-1, STBTE_COLOR_TILEPALETTE_BACKGROUND); + STBTE_DRAW_TILE(x,y,id, slot == tm->cur_tile,0); + if (slot == tm->cur_tile) + stbte__draw_frame_delayed(x-1,y-1,x+tm->palette_spacing_x,y+tm->palette_spacing_y, STBTE_COLOR_TILEPALETTE_OUTLINE); + break; + default: + if (stbte__button_core(id)) + tm->cur_tile = slot; + break; + } +} + +static void stbte__palette_of_tiles(stbte_tilemap *tm, int x0, int y0, int w, int h) +{ + int i,x,y; + int num_vis_rows = (h-6) / tm->palette_spacing_y; + int num_columns = (w-2-6) / tm->palette_spacing_x; + int num_total_rows; + int column,row; + int x1 = x0+w, y1=y0+h; + x = x0+2; + y = y0+6; + + if (num_columns == 0) + return; + + num_total_rows = (tm->cur_palette_count + num_columns-1) / num_columns; // ceil() + + column = 0; + row = -tm->palette_scroll; + for (i=0; i < tm->num_tiles; ++i) { + stbte__tileinfo *t = &tm->tiles[i]; + + // filter based on category + if (tm->cur_category >= 0 && t->category_id != tm->cur_category) + continue; + + // display it + if (row >= 0 && row < num_vis_rows) { + x = x0 + 2 + tm->palette_spacing_x * column; + y = y0 + 6 + tm->palette_spacing_y * row; + stbte__tile_in_palette(tm,x,y,i); + } + + ++column; + if (column == num_columns) { + column = 0; + ++row; + } + } + stbte__flush_delay(); + stbte__scrollbar(x1-4, y0+6, y1-2, &tm->palette_scroll, 0, num_total_rows, num_vis_rows, STBTE__ID(STBTE__scrollbar_id, STBTE__palette)); +} + +static float stbte__saved; +static void stbte__props_panel(stbte_tilemap *tm, int x0, int y0, int w, int h) +{ + int x1 = x0+w; + int i; + int y = y0 + 5, x = x0+2; + int slider_width = 60; + int mx,my; + float *p; + short *data; + if (!stbte__is_single_selection()) + return; + mx = stbte__ui.select_x0; + my = stbte__ui.select_y0; + p = tm->props[my][mx]; + data = tm->data[my][mx]; + STBTE__NOTUSED(data); + for (i=0; i < STBTE_MAX_PROPERTIES; ++i) { + unsigned int n = STBTE_PROP_TYPE(i, data, p); + if (n) { + char *s = (char*) STBTE_PROP_NAME(i, data, p); + if (s == NULL) s = (char*) ""; + switch (n & 3) { + case STBTE_PROP_bool: { + int flag = (int) p[i]; + if (stbte__layerbutton(x,y, flag ? 'x' : ' ', STBTE__ID(STBTE__prop_flag,i), flag, 0, 2)) { + stbte__begin_undo(tm); + stbte__undo_record_prop_float(tm,mx,my,i,(float) flag); + p[i] = (float) !flag; + stbte__end_undo(tm); + } + stbte__draw_text(x+13,y+1,s,x1-(x+13)-2,STBTE__TEXTCOLOR(STBTE__cpanel)); + y += 13; + break; + } + case STBTE_PROP_int: { + int a = (int) STBTE_PROP_MIN(i,data,p); + int b = (int) STBTE_PROP_MAX(i,data,p); + int v = (int) p[i] - a; + if (a+v != p[i] || v < 0 || v > b-a) { + if (v < 0) v = 0; + if (v > b-a) v = b-a; + p[i] = (float) (a+v); // @TODO undo + } + switch (stbte__slider(x, slider_width, y+7, b-a, &v, STBTE__ID(STBTE__prop_int,i))) + { + case STBTE__begin: + stbte__saved = p[i]; + // fallthrough + case STBTE__change: + p[i] = (float) (a+v); // @TODO undo + break; + case STBTE__end: + if (p[i] != stbte__saved) { + stbte__begin_undo(tm); + stbte__undo_record_prop_float(tm,mx,my,i,stbte__saved); + stbte__end_undo(tm); + } + break; + } + stbte__draw_text(x+slider_width+2,y+2, s, x1-1-(x+slider_width+2), STBTE__TEXTCOLOR(STBTE__cpanel)); + y += 12; + break; + } + case STBTE_PROP_float: { + float a = (float) STBTE_PROP_MIN(i, data,p); + float b = (float) STBTE_PROP_MAX(i, data,p); + float c = STBTE_PROP_FLOAT_SCALE(i, data, p); + float old; + if (p[i] < a || p[i] > b) { + // @TODO undo + if (p[i] < a) p[i] = a; + if (p[i] > b) p[i] = b; + } + old = p[i]; + switch (stbte__float_control(x, y, 50, a, b, c, "%8.4f", &p[i], STBTE__layer,STBTE__ID(STBTE__prop_float,i))) { + case STBTE__begin: + stbte__saved = old; + break; + case STBTE__end: + if (stbte__saved != p[i]) { + stbte__begin_undo(tm); + stbte__undo_record_prop_float(tm,mx,my,i, stbte__saved); + stbte__end_undo(tm); + } + break; + } + stbte__draw_text(x+53,y+1, s, x1-1-(x+53), STBTE__TEXTCOLOR(STBTE__cpanel)); + y += 12; + break; + } + } + } + } +} + +static int stbte__cp_mode, stbte__cp_aspect, stbte__save, stbte__cp_altered; +#ifdef STBTE__COLORPICKER +static int stbte__cp_state, stbte__cp_index, stbte__color_copy; +static void stbte__dump_colorstate(void) +{ + int i,j,k; + printf("static int stbte__color_table[STBTE__num_color_modes][STBTE__num_color_aspects][STBTE__num_color_states] =\n"); + printf("{\n"); + printf(" {\n"); + for (k=0; k < STBTE__num_color_modes; ++k) { + for (j=0; j < STBTE__num_color_aspects; ++j) { + printf(" { "); + for (i=0; i < STBTE__num_color_states; ++i) { + printf("0x%06x, ", stbte__color_table[k][j][i]); + } + printf("},\n"); + } + if (k+1 < STBTE__num_color_modes) + printf(" }, {\n"); + else + printf(" },\n"); + } + printf("};\n"); +} + +static void stbte__colorpicker(int x0, int y0, int w, int h) +{ + int x1 = x0+w, y1 = y0+h, x,y, i; + + x = x0+2; y = y0+6; + + y += 5; + x += 8; + + + { + int color = stbte__color_table[stbte__cp_mode][stbte__cp_aspect][stbte__cp_index]; + int rgb[3]; + if (stbte__cp_altered && stbte__cp_index == STBTE__idle) + color = stbte__save; + + if (stbte__minibutton(STBTE__cmapsize, x1-20,y+ 5, 'C', STBTE__ID2(STBTE__colorpick_id,4,0))) + stbte__color_copy = color; + if (stbte__minibutton(STBTE__cmapsize, x1-20,y+15, 'P', STBTE__ID2(STBTE__colorpick_id,4,1))) + color = stbte__color_copy; + + rgb[0] = color >> 16; rgb[1] = (color>>8)&255; rgb[2] = color & 255; + for (i=0; i < 3; ++i) { + if (stbte__slider(x+8,64, y, 255, rgb+i, STBTE__ID2(STBTE__colorpick_id,3,i)) > 0) + stbte__dump_colorstate(); + y += 15; + } + if (stbte__ui.event != STBTE__paint && stbte__ui.event != STBTE__tick) + stbte__color_table[stbte__cp_mode][stbte__cp_aspect][stbte__cp_index] = (rgb[0]<<16)|(rgb[1]<<8)|(rgb[2]); + } + + y += 5; + + // states + x = x0+2+35; + if (stbte__ui.event == STBTE__paint) { + static char *states[] = { "idle", "over", "down", "down&over", "selected", "selected&over", "disabled" }; + stbte__draw_text(x, y+1, states[stbte__cp_index], x1-x-1, 0xffffff); + } + + x = x0+24; y += 12; + + for (i=3; i >= 0; --i) { + int state = 0 != (stbte__cp_state & (1 << i)); + if (stbte__layerbutton(x,y, "OASD"[i], STBTE__ID2(STBTE__colorpick_id, 0,i), state,0, STBTE__clayer_button)) { + stbte__cp_state ^= (1 << i); + stbte__cp_index = stbte__state_to_index[0][0][0][stbte__cp_state]; + } + x += 16; + } + x = x0+2; y += 18; + + for (i=0; i < 3; ++i) { + static char *labels[] = { "Base", "Edge", "Text" }; + if (stbte__button(STBTE__ctoolbar_button, labels[i], x,y,0,36, STBTE__ID2(STBTE__colorpick_id,1,i), stbte__cp_aspect==i,0)) + stbte__cp_aspect = i; + x += 40; + } + + y += 18; + x = x0+2; + + for (i=0; i < STBTE__num_color_modes; ++i) { + if (stbte__button(STBTE__ctoolbar_button, stbte__color_names[i], x, y, 0,80, STBTE__ID2(STBTE__colorpick_id,2,i), stbte__cp_mode == i,0)) + stbte__cp_mode = i; + y += 12; + } + + // make the currently selected aspect flash, unless we're actively dragging color slider etc + if (stbte__ui.event == STBTE__tick) { + stbte__save = stbte__color_table[stbte__cp_mode][stbte__cp_aspect][STBTE__idle]; + if ((stbte__ui.active_id & 127) != STBTE__colorpick_id) { + if ((stbte__ui.ms_time & 2047) < 200) { + stbte__color_table[stbte__cp_mode][stbte__cp_aspect][STBTE__idle] ^= 0x1f1f1f; + stbte__cp_altered = 1; + } + } + } +} +#endif + +static void stbte__editor_traverse(stbte_tilemap *tm) +{ + int i,j,i0,j0,i1,j1,n; + + if (tm == NULL) + return; + if (stbte__ui.x0 == stbte__ui.x1 || stbte__ui.y0 == stbte__ui.y1) + return; + + stbte__prepare_tileinfo(tm); + + stbte__compute_panel_locations(tm); // @OPTIMIZE: we don't need to recompute this every time + + if (stbte__ui.event == STBTE__paint) { + // fill screen with border + stbte__draw_rect(stbte__ui.x0, stbte__ui.y0, stbte__ui.x1, stbte__ui.y1, STBTE_COLOR_TILEMAP_BORDER); + // fill tilemap with tilemap background + stbte__draw_rect(stbte__ui.x0 - tm->scroll_x, stbte__ui.y0 - tm->scroll_y, + stbte__ui.x0 - tm->scroll_x + tm->spacing_x * tm->max_x, + stbte__ui.y0 - tm->scroll_y + tm->spacing_y * tm->max_y, STBTE_COLOR_TILEMAP_BACKGROUND); + } + + // step 1: traverse all the tilemap data... + + i0 = (tm->scroll_x - tm->spacing_x) / tm->spacing_x; + j0 = (tm->scroll_y - tm->spacing_y) / tm->spacing_y; + i1 = (tm->scroll_x + stbte__ui.x1 - stbte__ui.x0) / tm->spacing_x + 1; + j1 = (tm->scroll_y + stbte__ui.y1 - stbte__ui.y0) / tm->spacing_y + 1; + + if (i0 < 0) i0 = 0; + if (j0 < 0) j0 = 0; + if (i1 > tm->max_x) i1 = tm->max_x; + if (j1 > tm->max_y) j1 = tm->max_y; + + if (stbte__ui.event == STBTE__paint) { + // draw all of layer 0, then all of layer 1, etc, instead of old + // way which drew entire stack of each tile at once + for (n=0; n < tm->num_layers; ++n) { + for (j=j0; j < j1; ++j) { + for (i=i0; i < i1; ++i) { + int x = stbte__ui.x0 + i * tm->spacing_x - tm->scroll_x; + int y = stbte__ui.y0 + j * tm->spacing_y - tm->scroll_y; + stbte__tile_paint(tm, x, y, i, j, n); + } + } + if (n == 0 && stbte__ui.show_grid == 1) { + int x = stbte__ui.x0 + i0 * tm->spacing_x - tm->scroll_x; + int y = stbte__ui.y0 + j0 * tm->spacing_y - tm->scroll_y; + for (i=0; x < stbte__ui.x1 && i <= i1; ++i, x += tm->spacing_x) + stbte__draw_rect(x, stbte__ui.y0, x+1, stbte__ui.y1, STBTE_COLOR_GRID); + for (j=0; y < stbte__ui.y1 && j <= j1; ++j, y += tm->spacing_y) + stbte__draw_rect(stbte__ui.x0, y, stbte__ui.x1, y+1, STBTE_COLOR_GRID); + } + } + } + + if (stbte__ui.event == STBTE__paint) { + // draw grid on top of everything except UI + if (stbte__ui.show_grid == 2) { + int x = stbte__ui.x0 + i0 * tm->spacing_x - tm->scroll_x; + int y = stbte__ui.y0 + j0 * tm->spacing_y - tm->scroll_y; + for (i=0; x < stbte__ui.x1 && i <= i1; ++i, x += tm->spacing_x) + stbte__draw_rect(x, stbte__ui.y0, x+1, stbte__ui.y1, STBTE_COLOR_GRID); + for (j=0; y < stbte__ui.y1 && j <= j1; ++j, y += tm->spacing_y) + stbte__draw_rect(stbte__ui.x0, y, stbte__ui.x1, y+1, STBTE_COLOR_GRID); + } + } + + for (j=j0; j < j1; ++j) { + for (i=i0; i < i1; ++i) { + int x = stbte__ui.x0 + i * tm->spacing_x - tm->scroll_x; + int y = stbte__ui.y0 + j * tm->spacing_y - tm->scroll_y; + stbte__tile(tm, x, y, i, j); + } + } + + if (stbte__ui.event == STBTE__paint) { + // draw the selection border + if (stbte__ui.has_selection) { + int x0,y0,x1,y1; + x0 = stbte__ui.x0 + (stbte__ui.select_x0 ) * tm->spacing_x - tm->scroll_x; + y0 = stbte__ui.y0 + (stbte__ui.select_y0 ) * tm->spacing_y - tm->scroll_y; + x1 = stbte__ui.x0 + (stbte__ui.select_x1 + 1) * tm->spacing_x - tm->scroll_x + 1; + y1 = stbte__ui.y0 + (stbte__ui.select_y1 + 1) * tm->spacing_y - tm->scroll_y + 1; + stbte__draw_frame(x0,y0,x1,y1, (stbte__ui.ms_time & 256 ? STBTE_COLOR_SELECTION_OUTLINE1 : STBTE_COLOR_SELECTION_OUTLINE2)); + } + + stbte__flush_delay(); // draw a dynamic link on top of the queued links + + #ifdef STBTE_ALLOW_LINK + if (stbte__ui.linking && STBTE__IS_MAP_HOT()) { + int x0,y0,x1,y1; + int color; + int ex = ((stbte__ui.hot_id >> 19) & 4095); + int ey = ((stbte__ui.hot_id >> 7) & 4095); + x0 = stbte__ui.x0 + (stbte__ui.sx ) * tm->spacing_x - tm->scroll_x + (tm->spacing_x>>1)+1; + y0 = stbte__ui.y0 + (stbte__ui.sy ) * tm->spacing_y - tm->scroll_y + (tm->spacing_y>>1)+1; + x1 = stbte__ui.x0 + (ex ) * tm->spacing_x - tm->scroll_x + (tm->spacing_x>>1)-1; + y1 = stbte__ui.y0 + (ey ) * tm->spacing_y - tm->scroll_y + (tm->spacing_y>>1)-1; + if (STBTE_ALLOW_LINK(tm->data[stbte__ui.sy][stbte__ui.sx], tm->props[stbte__ui.sy][stbte__ui.sx], tm->data[ey][ex], tm->props[ey][ex])) + color = STBTE_LINK_COLOR_DRAWING; + else + color = STBTE_LINK_COLOR_DISALLOWED; + stbte__draw_link(x0,y0,x1,y1, color); + } + #endif + } + stbte__flush_delay(); + + // step 2: traverse the panels + for (i=0; i < STBTE__num_panel; ++i) { + stbte__panel *p = &stbte__ui.panel[i]; + if (stbte__ui.event == STBTE__paint) { + stbte__draw_box(p->x0,p->y0,p->x0+p->width,p->y0+p->height, STBTE__cpanel, STBTE__idle); + } + // obscure tilemap data underneath panel + stbte__hittest(p->x0,p->y0,p->x0+p->width,p->y0+p->height, STBTE__ID2(STBTE__panel, i, 0)); + switch (i) { + case STBTE__panel_toolbar: + if (stbte__ui.event == STBTE__paint) + stbte__draw_rect(p->x0,p->y0,p->x0+p->width,p->y0+p->height, stbte__color_table[STBTE__ctoolbar][STBTE__base][STBTE__idle]); + stbte__toolbar(tm,p->x0,p->y0,p->width,p->height); + break; + case STBTE__panel_info: + stbte__info(tm,p->x0,p->y0,p->width,p->height); + break; + case STBTE__panel_layers: + stbte__layers(tm,p->x0,p->y0,p->width,p->height); + break; + case STBTE__panel_categories: + stbte__categories(tm,p->x0,p->y0,p->width,p->height); + break; + case STBTE__panel_colorpick: +#ifdef STBTE__COLORPICKER + stbte__colorpicker(p->x0,p->y0,p->width,p->height); +#endif + break; + case STBTE__panel_tiles: + // erase boundary between categories and tiles if they're on same side + if (stbte__ui.event == STBTE__paint && p->side == stbte__ui.panel[STBTE__panel_categories].side) + stbte__draw_rect(p->x0+1,p->y0-1,p->x0+p->width-1,p->y0+1, stbte__color_table[STBTE__cpanel][STBTE__base][STBTE__idle]); + stbte__palette_of_tiles(tm,p->x0,p->y0,p->width,p->height); + break; + case STBTE__panel_props: + stbte__props_panel(tm,p->x0,p->y0,p->width,p->height); + break; + } + // draw the panel side selectors + for (j=0; j < 2; ++j) { + int result; + if (i == STBTE__panel_toolbar) continue; + result = stbte__microbutton(p->x0+p->width - 1 - 2*4 + 4*j,p->y0+2,3, STBTE__ID2(STBTE__panel, i, j+1), STBTE__cpanel_sider+j); + if (result) { + switch (j) { + case 0: p->side = result > 0 ? STBTE__side_left : STBTE__side_right; break; + case 1: p->delta_height += result; break; + } + } + } + } + + if (stbte__ui.panel[STBTE__panel_categories].delta_height < -5) stbte__ui.panel[STBTE__panel_categories].delta_height = -5; + if (stbte__ui.panel[STBTE__panel_layers ].delta_height < -5) stbte__ui.panel[STBTE__panel_layers ].delta_height = -5; + + + // step 3: traverse the regions to place expander controls on them + for (i=0; i < 2; ++i) { + if (stbte__region[i].active) { + int x = stbte__region[i].x; + int width; + if (i == STBTE__side_left) + width = stbte__ui.left_width , x += stbte__region[i].width + 1; + else + width = -stbte__ui.right_width, x -= 6; + if (stbte__microbutton_dragger(x, stbte__region[i].y+2, 5, STBTE__ID(STBTE__region,i), &width)) { + // if non-0, it is expanding, so retract it + if (stbte__region[i].retracted == 0.0) + stbte__region[i].retracted = 0.01f; + else + stbte__region[i].retracted = 0.0; + } + if (i == STBTE__side_left) + stbte__ui.left_width = width; + else + stbte__ui.right_width = -width; + if (stbte__ui.event == STBTE__tick) { + if (stbte__region[i].retracted && stbte__region[i].retracted < 1.0f) { + stbte__region[i].retracted += stbte__ui.dt*4; + if (stbte__region[i].retracted > 1) + stbte__region[i].retracted = 1; + } + } + } + } + + if (stbte__ui.event == STBTE__paint && stbte__ui.alert_msg) { + int w = stbte__text_width(stbte__ui.alert_msg); + int x = (stbte__ui.x0+stbte__ui.x1)/2; + int y = (stbte__ui.y0+stbte__ui.y1)*5/6; + stbte__draw_rect (x-w/2-4,y-8, x+w/2+4,y+8, 0x604020); + stbte__draw_frame(x-w/2-4,y-8, x+w/2+4,y+8, 0x906030); + stbte__draw_text (x-w/2,y-4, stbte__ui.alert_msg, w+1, 0xff8040); + } + +#ifdef STBTE_SHOW_CURSOR + if (stbte__ui.event == STBTE__paint) + stbte__draw_bitmap(stbte__ui.mx, stbte__ui.my, stbte__get_char_width(26), stbte__get_char_bitmap(26), 0xe0e0e0); +#endif + + if (stbte__ui.event == STBTE__tick && stbte__ui.alert_msg) { + stbte__ui.alert_timer -= stbte__ui.dt; + if (stbte__ui.alert_timer < 0) { + stbte__ui.alert_timer = 0; + stbte__ui.alert_msg = 0; + } + } + + if (stbte__ui.event == STBTE__paint) { + stbte__color_table[stbte__cp_mode][stbte__cp_aspect][STBTE__idle] = stbte__save; + stbte__cp_altered = 0; + } +} + +static void stbte__do_event(stbte_tilemap *tm) +{ + stbte__ui.next_hot_id = 0; + stbte__editor_traverse(tm); + stbte__ui.hot_id = stbte__ui.next_hot_id; + + // automatically cancel on mouse-up in case the object that triggered it + // doesn't exist anymore + if (stbte__ui.active_id) { + if (stbte__ui.event == STBTE__leftup || stbte__ui.event == STBTE__rightup) { + if (!stbte__ui.pasting) { + stbte__activate(0); + if (stbte__ui.undoing) + stbte__end_undo(tm); + stbte__ui.scrolling = 0; + stbte__ui.dragging = 0; + stbte__ui.linking = 0; + } + } + } + + // we could do this stuff in the widgets directly, but it would keep recomputing + // the same thing on every tile, which seems dumb. + + if (stbte__ui.pasting) { + if (STBTE__IS_MAP_HOT()) { + // compute pasting location based on last hot + stbte__ui.paste_x = ((stbte__ui.hot_id >> 19) & 4095) - (stbte__ui.copy_width >> 1); + stbte__ui.paste_y = ((stbte__ui.hot_id >> 7) & 4095) - (stbte__ui.copy_height >> 1); + } + } + if (stbte__ui.dragging) { + if (STBTE__IS_MAP_HOT()) { + stbte__ui.drag_dest_x = ((stbte__ui.hot_id >> 19) & 4095) - stbte__ui.drag_offx; + stbte__ui.drag_dest_y = ((stbte__ui.hot_id >> 7) & 4095) - stbte__ui.drag_offy; + } + } +} + +static void stbte__set_event(int event, int x, int y) +{ + stbte__ui.event = event; + stbte__ui.mx = x; + stbte__ui.my = y; + stbte__ui.dx = x - stbte__ui.last_mouse_x; + stbte__ui.dy = y - stbte__ui.last_mouse_y; + stbte__ui.last_mouse_x = x; + stbte__ui.last_mouse_y = y; + stbte__ui.accum_x += stbte__ui.dx; + stbte__ui.accum_y += stbte__ui.dy; +} + +void stbte_draw(stbte_tilemap *tm) +{ + stbte__ui.event = STBTE__paint; + stbte__editor_traverse(tm); +} + +void stbte_mouse_move(stbte_tilemap *tm, int x, int y, int shifted, int scrollkey) +{ + stbte__set_event(STBTE__mousemove, x,y); + stbte__ui.shift = shifted; + stbte__ui.scrollkey = scrollkey; + stbte__do_event(tm); +} + +void stbte_mouse_button(stbte_tilemap *tm, int x, int y, int right, int down, int shifted, int scrollkey) +{ + static int events[2][2] = { { STBTE__leftup , STBTE__leftdown }, + { STBTE__rightup, STBTE__rightdown } }; + stbte__set_event(events[right][down], x,y); + stbte__ui.shift = shifted; + stbte__ui.scrollkey = scrollkey; + + stbte__do_event(tm); +} + +void stbte_mouse_wheel(stbte_tilemap *tm, int x, int y, int vscroll) +{ + // not implemented yet -- need different way of hittesting +} + +void stbte_action(stbte_tilemap *tm, enum stbte_action act) +{ + switch (act) { + case STBTE_tool_select: stbte__ui.tool = STBTE__tool_select; break; + case STBTE_tool_brush: stbte__ui.tool = STBTE__tool_brush; break; + case STBTE_tool_erase: stbte__ui.tool = STBTE__tool_erase; break; + case STBTE_tool_rectangle: stbte__ui.tool = STBTE__tool_rect; break; + case STBTE_tool_eyedropper: stbte__ui.tool = STBTE__tool_eyedrop; break; + case STBTE_tool_link: stbte__ui.tool = STBTE__tool_link; break; + case STBTE_act_toggle_grid: stbte__ui.show_grid = (stbte__ui.show_grid+1) % 3; break; + case STBTE_act_toggle_links: stbte__ui.show_links ^= 1; break; + case STBTE_act_undo: stbte__undo(tm); break; + case STBTE_act_redo: stbte__redo(tm); break; + case STBTE_act_cut: stbte__copy_cut(tm, 1); break; + case STBTE_act_copy: stbte__copy_cut(tm, 0); break; + case STBTE_act_paste: stbte__start_paste(tm); break; + case STBTE_scroll_left: tm->scroll_x -= tm->spacing_x; break; + case STBTE_scroll_right: tm->scroll_x += tm->spacing_x; break; + case STBTE_scroll_up: tm->scroll_y -= tm->spacing_y; break; + case STBTE_scroll_down: tm->scroll_y += tm->spacing_y; break; + } +} + +void stbte_tick(stbte_tilemap *tm, float dt) +{ + stbte__ui.event = STBTE__tick; + stbte__ui.dt = dt; + stbte__do_event(tm); + stbte__ui.ms_time += (int) (dt * 1024) + 1; // make sure if time is superfast it always updates a little +} + +void stbte_mouse_sdl(stbte_tilemap *tm, const void *sdl_event, float xs, float ys, int xo, int yo) +{ +#ifdef _SDL_H + SDL_Event *event = (SDL_Event *) sdl_event; + SDL_Keymod km = SDL_GetModState(); + int shift = (km & KMOD_LCTRL) || (km & KMOD_RCTRL); + int scrollkey = 0 != SDL_GetKeyboardState(NULL)[SDL_SCANCODE_SPACE]; + switch (event->type) { + case SDL_MOUSEMOTION: + stbte_mouse_move(tm, (int) (xs*event->motion.x+xo), (int) (ys*event->motion.y+yo), shift, scrollkey); + break; + case SDL_MOUSEBUTTONUP: + stbte_mouse_button(tm, (int) (xs*event->button.x+xo), (int) (ys*event->button.y+yo), event->button.button != SDL_BUTTON_LEFT, 0, shift, scrollkey); + break; + case SDL_MOUSEBUTTONDOWN: + stbte_mouse_button(tm, (int) (xs*event->button.x+xo), (int) (ys*event->button.y+yo), event->button.button != SDL_BUTTON_LEFT, 1, shift, scrollkey); + break; + case SDL_MOUSEWHEEL: + stbte_mouse_wheel(tm, stbte__ui.mx, stbte__ui.my, event->wheel.y); + break; + } +#else + STBTE__NOTUSED(tm); + STBTE__NOTUSED(sdl_event); + STBTE__NOTUSED(xs); + STBTE__NOTUSED(ys); + STBTE__NOTUSED(xo); + STBTE__NOTUSED(yo); +#endif +} + +#endif // STB_TILEMAP_EDITOR_IMPLEMENTATION + +/* +------------------------------------------------------------------------------ +This software is available under 2 licenses -- choose whichever you prefer. +------------------------------------------------------------------------------ +ALTERNATIVE A - MIT License +Copyright (c) 2017 Sean Barrett +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is furnished to do +so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +------------------------------------------------------------------------------ +ALTERNATIVE B - Public Domain (www.unlicense.org) +This is free and unencumbered software released into the public domain. +Anyone is free to copy, modify, publish, use, compile, sell, or distribute this +software, either in source code form or as a compiled binary, for any purpose, +commercial or non-commercial, and by any means. +In jurisdictions that recognize copyright laws, the author or authors of this +software dedicate any and all copyright interest in the software to the public +domain. We make this dedication for the benefit of the public at large and to +the detriment of our heirs and successors. We intend this dedication to be an +overt act of relinquishment in perpetuity of all present and future rights to +this software under copyright law. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN +ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +------------------------------------------------------------------------------ +*/ diff --git a/tests/data/c/stb/stb_truetype.h b/tests/data/c/stb/stb_truetype.h new file mode 100644 index 000000000..90a5c2e2b --- /dev/null +++ b/tests/data/c/stb/stb_truetype.h @@ -0,0 +1,5079 @@ +// stb_truetype.h - v1.26 - public domain +// authored from 2009-2021 by Sean Barrett / RAD Game Tools +// +// ======================================================================= +// +// NO SECURITY GUARANTEE -- DO NOT USE THIS ON UNTRUSTED FONT FILES +// +// This library does no range checking of the offsets found in the file, +// meaning an attacker can use it to read arbitrary memory. +// +// ======================================================================= +// +// This library processes TrueType files: +// parse files +// extract glyph metrics +// extract glyph shapes +// render glyphs to one-channel bitmaps with antialiasing (box filter) +// render glyphs to one-channel SDF bitmaps (signed-distance field/function) +// +// Todo: +// non-MS cmaps +// crashproof on bad data +// hinting? (no longer patented) +// cleartype-style AA? +// optimize: use simple memory allocator for intermediates +// optimize: build edge-list directly from curves +// optimize: rasterize directly from curves? +// +// ADDITIONAL CONTRIBUTORS +// +// Mikko Mononen: compound shape support, more cmap formats +// Tor Andersson: kerning, subpixel rendering +// Dougall Johnson: OpenType / Type 2 font handling +// Daniel Ribeiro Maciel: basic GPOS-based kerning +// +// Misc other: +// Ryan Gordon +// Simon Glass +// github:IntellectualKitty +// Imanol Celaya +// Daniel Ribeiro Maciel +// +// Bug/warning reports/fixes: +// "Zer" on mollyrocket Fabian "ryg" Giesen github:NiLuJe +// Cass Everitt Martins Mozeiko github:aloucks +// stoiko (Haemimont Games) Cap Petschulat github:oyvindjam +// Brian Hook Omar Cornut github:vassvik +// Walter van Niftrik Ryan Griege +// David Gow Peter LaValle +// David Given Sergey Popov +// Ivan-Assen Ivanov Giumo X. Clanjor +// Anthony Pesch Higor Euripedes +// Johan Duparc Thomas Fields +// Hou Qiming Derek Vinyard +// Rob Loach Cort Stratton +// Kenney Phillis Jr. Brian Costabile +// Ken Voskuil (kaesve) Yakov Galka +// +// VERSION HISTORY +// +// 1.26 (2021-08-28) fix broken rasterizer +// 1.25 (2021-07-11) many fixes +// 1.24 (2020-02-05) fix warning +// 1.23 (2020-02-02) query SVG data for glyphs; query whole kerning table (but only kern not GPOS) +// 1.22 (2019-08-11) minimize missing-glyph duplication; fix kerning if both 'GPOS' and 'kern' are defined +// 1.21 (2019-02-25) fix warning +// 1.20 (2019-02-07) PackFontRange skips missing codepoints; GetScaleFontVMetrics() +// 1.19 (2018-02-11) GPOS kerning, STBTT_fmod +// 1.18 (2018-01-29) add missing function +// 1.17 (2017-07-23) make more arguments const; doc fix +// 1.16 (2017-07-12) SDF support +// 1.15 (2017-03-03) make more arguments const +// 1.14 (2017-01-16) num-fonts-in-TTC function +// 1.13 (2017-01-02) support OpenType fonts, certain Apple fonts +// 1.12 (2016-10-25) suppress warnings about casting away const with -Wcast-qual +// 1.11 (2016-04-02) fix unused-variable warning +// 1.10 (2016-04-02) user-defined fabs(); rare memory leak; remove duplicate typedef +// 1.09 (2016-01-16) warning fix; avoid crash on outofmem; use allocation userdata properly +// 1.08 (2015-09-13) document stbtt_Rasterize(); fixes for vertical & horizontal edges +// 1.07 (2015-08-01) allow PackFontRanges to accept arrays of sparse codepoints; +// variant PackFontRanges to pack and render in separate phases; +// fix stbtt_GetFontOFfsetForIndex (never worked for non-0 input?); +// fixed an assert() bug in the new rasterizer +// replace assert() with STBTT_assert() in new rasterizer +// +// Full history can be found at the end of this file. +// +// LICENSE +// +// See end of file for license information. +// +// USAGE +// +// Include this file in whatever places need to refer to it. In ONE C/C++ +// file, write: +// #define STB_TRUETYPE_IMPLEMENTATION +// before the #include of this file. This expands out the actual +// implementation into that C/C++ file. +// +// To make the implementation private to the file that generates the implementation, +// #define STBTT_STATIC +// +// Simple 3D API (don't ship this, but it's fine for tools and quick start) +// stbtt_BakeFontBitmap() -- bake a font to a bitmap for use as texture +// stbtt_GetBakedQuad() -- compute quad to draw for a given char +// +// Improved 3D API (more shippable): +// #include "stb_rect_pack.h" -- optional, but you really want it +// stbtt_PackBegin() +// stbtt_PackSetOversampling() -- for improved quality on small fonts +// stbtt_PackFontRanges() -- pack and renders +// stbtt_PackEnd() +// stbtt_GetPackedQuad() +// +// "Load" a font file from a memory buffer (you have to keep the buffer loaded) +// stbtt_InitFont() +// stbtt_GetFontOffsetForIndex() -- indexing for TTC font collections +// stbtt_GetNumberOfFonts() -- number of fonts for TTC font collections +// +// Render a unicode codepoint to a bitmap +// stbtt_GetCodepointBitmap() -- allocates and returns a bitmap +// stbtt_MakeCodepointBitmap() -- renders into bitmap you provide +// stbtt_GetCodepointBitmapBox() -- how big the bitmap must be +// +// Character advance/positioning +// stbtt_GetCodepointHMetrics() +// stbtt_GetFontVMetrics() +// stbtt_GetFontVMetricsOS2() +// stbtt_GetCodepointKernAdvance() +// +// Starting with version 1.06, the rasterizer was replaced with a new, +// faster and generally-more-precise rasterizer. The new rasterizer more +// accurately measures pixel coverage for anti-aliasing, except in the case +// where multiple shapes overlap, in which case it overestimates the AA pixel +// coverage. Thus, anti-aliasing of intersecting shapes may look wrong. If +// this turns out to be a problem, you can re-enable the old rasterizer with +// #define STBTT_RASTERIZER_VERSION 1 +// which will incur about a 15% speed hit. +// +// ADDITIONAL DOCUMENTATION +// +// Immediately after this block comment are a series of sample programs. +// +// After the sample programs is the "header file" section. This section +// includes documentation for each API function. +// +// Some important concepts to understand to use this library: +// +// Codepoint +// Characters are defined by unicode codepoints, e.g. 65 is +// uppercase A, 231 is lowercase c with a cedilla, 0x7e30 is +// the hiragana for "ma". +// +// Glyph +// A visual character shape (every codepoint is rendered as +// some glyph) +// +// Glyph index +// A font-specific integer ID representing a glyph +// +// Baseline +// Glyph shapes are defined relative to a baseline, which is the +// bottom of uppercase characters. Characters extend both above +// and below the baseline. +// +// Current Point +// As you draw text to the screen, you keep track of a "current point" +// which is the origin of each character. The current point's vertical +// position is the baseline. Even "baked fonts" use this model. +// +// Vertical Font Metrics +// The vertical qualities of the font, used to vertically position +// and space the characters. See docs for stbtt_GetFontVMetrics. +// +// Font Size in Pixels or Points +// The preferred interface for specifying font sizes in stb_truetype +// is to specify how tall the font's vertical extent should be in pixels. +// If that sounds good enough, skip the next paragraph. +// +// Most font APIs instead use "points", which are a common typographic +// measurement for describing font size, defined as 72 points per inch. +// stb_truetype provides a point API for compatibility. However, true +// "per inch" conventions don't make much sense on computer displays +// since different monitors have different number of pixels per +// inch. For example, Windows traditionally uses a convention that +// there are 96 pixels per inch, thus making 'inch' measurements have +// nothing to do with inches, and thus effectively defining a point to +// be 1.333 pixels. Additionally, the TrueType font data provides +// an explicit scale factor to scale a given font's glyphs to points, +// but the author has observed that this scale factor is often wrong +// for non-commercial fonts, thus making fonts scaled in points +// according to the TrueType spec incoherently sized in practice. +// +// DETAILED USAGE: +// +// Scale: +// Select how high you want the font to be, in points or pixels. +// Call ScaleForPixelHeight or ScaleForMappingEmToPixels to compute +// a scale factor SF that will be used by all other functions. +// +// Baseline: +// You need to select a y-coordinate that is the baseline of where +// your text will appear. Call GetFontBoundingBox to get the baseline-relative +// bounding box for all characters. SF*-y0 will be the distance in pixels +// that the worst-case character could extend above the baseline, so if +// you want the top edge of characters to appear at the top of the +// screen where y=0, then you would set the baseline to SF*-y0. +// +// Current point: +// Set the current point where the first character will appear. The +// first character could extend left of the current point; this is font +// dependent. You can either choose a current point that is the leftmost +// point and hope, or add some padding, or check the bounding box or +// left-side-bearing of the first character to be displayed and set +// the current point based on that. +// +// Displaying a character: +// Compute the bounding box of the character. It will contain signed values +// relative to . I.e. if it returns x0,y0,x1,y1, +// then the character should be displayed in the rectangle from +// to = 32 && *text < 128) { + stbtt_aligned_quad q; + stbtt_GetBakedQuad(cdata, 512,512, *text-32, &x,&y,&q,1);//1=opengl & d3d10+,0=d3d9 + glTexCoord2f(q.s0,q.t0); glVertex2f(q.x0,q.y0); + glTexCoord2f(q.s1,q.t0); glVertex2f(q.x1,q.y0); + glTexCoord2f(q.s1,q.t1); glVertex2f(q.x1,q.y1); + glTexCoord2f(q.s0,q.t1); glVertex2f(q.x0,q.y1); + } + ++text; + } + glEnd(); +} +#endif +// +// +////////////////////////////////////////////////////////////////////////////// +// +// Complete program (this compiles): get a single bitmap, print as ASCII art +// +#if 0 +#include +#define STB_TRUETYPE_IMPLEMENTATION // force following include to generate implementation +#include "stb_truetype.h" + +char ttf_buffer[1<<25]; + +int main(int argc, char **argv) +{ + stbtt_fontinfo font; + unsigned char *bitmap; + int w,h,i,j,c = (argc > 1 ? atoi(argv[1]) : 'a'), s = (argc > 2 ? atoi(argv[2]) : 20); + + fread(ttf_buffer, 1, 1<<25, fopen(argc > 3 ? argv[3] : "c:/windows/fonts/arialbd.ttf", "rb")); + + stbtt_InitFont(&font, ttf_buffer, stbtt_GetFontOffsetForIndex(ttf_buffer,0)); + bitmap = stbtt_GetCodepointBitmap(&font, 0,stbtt_ScaleForPixelHeight(&font, s), c, &w, &h, 0,0); + + for (j=0; j < h; ++j) { + for (i=0; i < w; ++i) + putchar(" .:ioVM@"[bitmap[j*w+i]>>5]); + putchar('\n'); + } + return 0; +} +#endif +// +// Output: +// +// .ii. +// @@@@@@. +// V@Mio@@o +// :i. V@V +// :oM@@M +// :@@@MM@M +// @@o o@M +// :@@. M@M +// @@@o@@@@ +// :M@@V:@@. +// +////////////////////////////////////////////////////////////////////////////// +// +// Complete program: print "Hello World!" banner, with bugs +// +#if 0 +char buffer[24<<20]; +unsigned char screen[20][79]; + +int main(int arg, char **argv) +{ + stbtt_fontinfo font; + int i,j,ascent,baseline,ch=0; + float scale, xpos=2; // leave a little padding in case the character extends left + char *text = "Heljo World!"; // intentionally misspelled to show 'lj' brokenness + + fread(buffer, 1, 1000000, fopen("c:/windows/fonts/arialbd.ttf", "rb")); + stbtt_InitFont(&font, buffer, 0); + + scale = stbtt_ScaleForPixelHeight(&font, 15); + stbtt_GetFontVMetrics(&font, &ascent,0,0); + baseline = (int) (ascent*scale); + + while (text[ch]) { + int advance,lsb,x0,y0,x1,y1; + float x_shift = xpos - (float) floor(xpos); + stbtt_GetCodepointHMetrics(&font, text[ch], &advance, &lsb); + stbtt_GetCodepointBitmapBoxSubpixel(&font, text[ch], scale,scale,x_shift,0, &x0,&y0,&x1,&y1); + stbtt_MakeCodepointBitmapSubpixel(&font, &screen[baseline + y0][(int) xpos + x0], x1-x0,y1-y0, 79, scale,scale,x_shift,0, text[ch]); + // note that this stomps the old data, so where character boxes overlap (e.g. 'lj') it's wrong + // because this API is really for baking character bitmaps into textures. if you want to render + // a sequence of characters, you really need to render each bitmap to a temp buffer, then + // "alpha blend" that into the working buffer + xpos += (advance * scale); + if (text[ch+1]) + xpos += scale*stbtt_GetCodepointKernAdvance(&font, text[ch],text[ch+1]); + ++ch; + } + + for (j=0; j < 20; ++j) { + for (i=0; i < 78; ++i) + putchar(" .:ioVM@"[screen[j][i]>>5]); + putchar('\n'); + } + + return 0; +} +#endif + + +////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////// +//// +//// INTEGRATION WITH YOUR CODEBASE +//// +//// The following sections allow you to supply alternate definitions +//// of C library functions used by stb_truetype, e.g. if you don't +//// link with the C runtime library. + +#ifdef STB_TRUETYPE_IMPLEMENTATION + // #define your own (u)stbtt_int8/16/32 before including to override this + #ifndef stbtt_uint8 + typedef unsigned char stbtt_uint8; + typedef signed char stbtt_int8; + typedef unsigned short stbtt_uint16; + typedef signed short stbtt_int16; + typedef unsigned int stbtt_uint32; + typedef signed int stbtt_int32; + #endif + + typedef char stbtt__check_size32[sizeof(stbtt_int32)==4 ? 1 : -1]; + typedef char stbtt__check_size16[sizeof(stbtt_int16)==2 ? 1 : -1]; + + // e.g. #define your own STBTT_ifloor/STBTT_iceil() to avoid math.h + #ifndef STBTT_ifloor + #include + #define STBTT_ifloor(x) ((int) floor(x)) + #define STBTT_iceil(x) ((int) ceil(x)) + #endif + + #ifndef STBTT_sqrt + #include + #define STBTT_sqrt(x) sqrt(x) + #define STBTT_pow(x,y) pow(x,y) + #endif + + #ifndef STBTT_fmod + #include + #define STBTT_fmod(x,y) fmod(x,y) + #endif + + #ifndef STBTT_cos + #include + #define STBTT_cos(x) cos(x) + #define STBTT_acos(x) acos(x) + #endif + + #ifndef STBTT_fabs + #include + #define STBTT_fabs(x) fabs(x) + #endif + + // #define your own functions "STBTT_malloc" / "STBTT_free" to avoid malloc.h + #ifndef STBTT_malloc + #include + #define STBTT_malloc(x,u) ((void)(u),malloc(x)) + #define STBTT_free(x,u) ((void)(u),free(x)) + #endif + + #ifndef STBTT_assert + #include + #define STBTT_assert(x) assert(x) + #endif + + #ifndef STBTT_strlen + #include + #define STBTT_strlen(x) strlen(x) + #endif + + #ifndef STBTT_memcpy + #include + #define STBTT_memcpy memcpy + #define STBTT_memset memset + #endif +#endif + +/////////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////////// +//// +//// INTERFACE +//// +//// + +#ifndef __STB_INCLUDE_STB_TRUETYPE_H__ +#define __STB_INCLUDE_STB_TRUETYPE_H__ + +#ifdef STBTT_STATIC +#define STBTT_DEF static +#else +#define STBTT_DEF extern +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +// private structure +typedef struct +{ + unsigned char *data; + int cursor; + int size; +} stbtt__buf; + +////////////////////////////////////////////////////////////////////////////// +// +// TEXTURE BAKING API +// +// If you use this API, you only have to call two functions ever. +// + +typedef struct +{ + unsigned short x0,y0,x1,y1; // coordinates of bbox in bitmap + float xoff,yoff,xadvance; +} stbtt_bakedchar; + +STBTT_DEF int stbtt_BakeFontBitmap(const unsigned char *data, int offset, // font location (use offset=0 for plain .ttf) + float pixel_height, // height of font in pixels + unsigned char *pixels, int pw, int ph, // bitmap to be filled in + int first_char, int num_chars, // characters to bake + stbtt_bakedchar *chardata); // you allocate this, it's num_chars long +// if return is positive, the first unused row of the bitmap +// if return is negative, returns the negative of the number of characters that fit +// if return is 0, no characters fit and no rows were used +// This uses a very crappy packing. + +typedef struct +{ + float x0,y0,s0,t0; // top-left + float x1,y1,s1,t1; // bottom-right +} stbtt_aligned_quad; + +STBTT_DEF void stbtt_GetBakedQuad(const stbtt_bakedchar *chardata, int pw, int ph, // same data as above + int char_index, // character to display + float *xpos, float *ypos, // pointers to current position in screen pixel space + stbtt_aligned_quad *q, // output: quad to draw + int opengl_fillrule); // true if opengl fill rule; false if DX9 or earlier +// Call GetBakedQuad with char_index = 'character - first_char', and it +// creates the quad you need to draw and advances the current position. +// +// The coordinate system used assumes y increases downwards. +// +// Characters will extend both above and below the current position; +// see discussion of "BASELINE" above. +// +// It's inefficient; you might want to c&p it and optimize it. + +STBTT_DEF void stbtt_GetScaledFontVMetrics(const unsigned char *fontdata, int index, float size, float *ascent, float *descent, float *lineGap); +// Query the font vertical metrics without having to create a font first. + + +////////////////////////////////////////////////////////////////////////////// +// +// NEW TEXTURE BAKING API +// +// This provides options for packing multiple fonts into one atlas, not +// perfectly but better than nothing. + +typedef struct +{ + unsigned short x0,y0,x1,y1; // coordinates of bbox in bitmap + float xoff,yoff,xadvance; + float xoff2,yoff2; +} stbtt_packedchar; + +typedef struct stbtt_pack_context stbtt_pack_context; +typedef struct stbtt_fontinfo stbtt_fontinfo; +#ifndef STB_RECT_PACK_VERSION +typedef struct stbrp_rect stbrp_rect; +#endif + +STBTT_DEF int stbtt_PackBegin(stbtt_pack_context *spc, unsigned char *pixels, int width, int height, int stride_in_bytes, int padding, void *alloc_context); +// Initializes a packing context stored in the passed-in stbtt_pack_context. +// Future calls using this context will pack characters into the bitmap passed +// in here: a 1-channel bitmap that is width * height. stride_in_bytes is +// the distance from one row to the next (or 0 to mean they are packed tightly +// together). "padding" is the amount of padding to leave between each +// character (normally you want '1' for bitmaps you'll use as textures with +// bilinear filtering). +// +// Returns 0 on failure, 1 on success. + +STBTT_DEF void stbtt_PackEnd (stbtt_pack_context *spc); +// Cleans up the packing context and frees all memory. + +#define STBTT_POINT_SIZE(x) (-(x)) + +STBTT_DEF int stbtt_PackFontRange(stbtt_pack_context *spc, const unsigned char *fontdata, int font_index, float font_size, + int first_unicode_char_in_range, int num_chars_in_range, stbtt_packedchar *chardata_for_range); +// Creates character bitmaps from the font_index'th font found in fontdata (use +// font_index=0 if you don't know what that is). It creates num_chars_in_range +// bitmaps for characters with unicode values starting at first_unicode_char_in_range +// and increasing. Data for how to render them is stored in chardata_for_range; +// pass these to stbtt_GetPackedQuad to get back renderable quads. +// +// font_size is the full height of the character from ascender to descender, +// as computed by stbtt_ScaleForPixelHeight. To use a point size as computed +// by stbtt_ScaleForMappingEmToPixels, wrap the point size in STBTT_POINT_SIZE() +// and pass that result as 'font_size': +// ..., 20 , ... // font max minus min y is 20 pixels tall +// ..., STBTT_POINT_SIZE(20), ... // 'M' is 20 pixels tall + +typedef struct +{ + float font_size; + int first_unicode_codepoint_in_range; // if non-zero, then the chars are continuous, and this is the first codepoint + int *array_of_unicode_codepoints; // if non-zero, then this is an array of unicode codepoints + int num_chars; + stbtt_packedchar *chardata_for_range; // output + unsigned char h_oversample, v_oversample; // don't set these, they're used internally +} stbtt_pack_range; + +STBTT_DEF int stbtt_PackFontRanges(stbtt_pack_context *spc, const unsigned char *fontdata, int font_index, stbtt_pack_range *ranges, int num_ranges); +// Creates character bitmaps from multiple ranges of characters stored in +// ranges. This will usually create a better-packed bitmap than multiple +// calls to stbtt_PackFontRange. Note that you can call this multiple +// times within a single PackBegin/PackEnd. + +STBTT_DEF void stbtt_PackSetOversampling(stbtt_pack_context *spc, unsigned int h_oversample, unsigned int v_oversample); +// Oversampling a font increases the quality by allowing higher-quality subpixel +// positioning, and is especially valuable at smaller text sizes. +// +// This function sets the amount of oversampling for all following calls to +// stbtt_PackFontRange(s) or stbtt_PackFontRangesGatherRects for a given +// pack context. The default (no oversampling) is achieved by h_oversample=1 +// and v_oversample=1. The total number of pixels required is +// h_oversample*v_oversample larger than the default; for example, 2x2 +// oversampling requires 4x the storage of 1x1. For best results, render +// oversampled textures with bilinear filtering. Look at the readme in +// stb/tests/oversample for information about oversampled fonts +// +// To use with PackFontRangesGather etc., you must set it before calls +// call to PackFontRangesGatherRects. + +STBTT_DEF void stbtt_PackSetSkipMissingCodepoints(stbtt_pack_context *spc, int skip); +// If skip != 0, this tells stb_truetype to skip any codepoints for which +// there is no corresponding glyph. If skip=0, which is the default, then +// codepoints without a glyph recived the font's "missing character" glyph, +// typically an empty box by convention. + +STBTT_DEF void stbtt_GetPackedQuad(const stbtt_packedchar *chardata, int pw, int ph, // same data as above + int char_index, // character to display + float *xpos, float *ypos, // pointers to current position in screen pixel space + stbtt_aligned_quad *q, // output: quad to draw + int align_to_integer); + +STBTT_DEF int stbtt_PackFontRangesGatherRects(stbtt_pack_context *spc, const stbtt_fontinfo *info, stbtt_pack_range *ranges, int num_ranges, stbrp_rect *rects); +STBTT_DEF void stbtt_PackFontRangesPackRects(stbtt_pack_context *spc, stbrp_rect *rects, int num_rects); +STBTT_DEF int stbtt_PackFontRangesRenderIntoRects(stbtt_pack_context *spc, const stbtt_fontinfo *info, stbtt_pack_range *ranges, int num_ranges, stbrp_rect *rects); +// Calling these functions in sequence is roughly equivalent to calling +// stbtt_PackFontRanges(). If you more control over the packing of multiple +// fonts, or if you want to pack custom data into a font texture, take a look +// at the source to of stbtt_PackFontRanges() and create a custom version +// using these functions, e.g. call GatherRects multiple times, +// building up a single array of rects, then call PackRects once, +// then call RenderIntoRects repeatedly. This may result in a +// better packing than calling PackFontRanges multiple times +// (or it may not). + +// this is an opaque structure that you shouldn't mess with which holds +// all the context needed from PackBegin to PackEnd. +struct stbtt_pack_context { + void *user_allocator_context; + void *pack_info; + int width; + int height; + int stride_in_bytes; + int padding; + int skip_missing; + unsigned int h_oversample, v_oversample; + unsigned char *pixels; + void *nodes; +}; + +////////////////////////////////////////////////////////////////////////////// +// +// FONT LOADING +// +// + +STBTT_DEF int stbtt_GetNumberOfFonts(const unsigned char *data); +// This function will determine the number of fonts in a font file. TrueType +// collection (.ttc) files may contain multiple fonts, while TrueType font +// (.ttf) files only contain one font. The number of fonts can be used for +// indexing with the previous function where the index is between zero and one +// less than the total fonts. If an error occurs, -1 is returned. + +STBTT_DEF int stbtt_GetFontOffsetForIndex(const unsigned char *data, int index); +// Each .ttf/.ttc file may have more than one font. Each font has a sequential +// index number starting from 0. Call this function to get the font offset for +// a given index; it returns -1 if the index is out of range. A regular .ttf +// file will only define one font and it always be at offset 0, so it will +// return '0' for index 0, and -1 for all other indices. + +// The following structure is defined publicly so you can declare one on +// the stack or as a global or etc, but you should treat it as opaque. +struct stbtt_fontinfo +{ + void * userdata; + unsigned char * data; // pointer to .ttf file + int fontstart; // offset of start of font + + int numGlyphs; // number of glyphs, needed for range checking + + int loca,head,glyf,hhea,hmtx,kern,gpos,svg; // table locations as offset from start of .ttf + int index_map; // a cmap mapping for our chosen character encoding + int indexToLocFormat; // format needed to map from glyph index to glyph + + stbtt__buf cff; // cff font data + stbtt__buf charstrings; // the charstring index + stbtt__buf gsubrs; // global charstring subroutines index + stbtt__buf subrs; // private charstring subroutines index + stbtt__buf fontdicts; // array of font dicts + stbtt__buf fdselect; // map from glyph to fontdict +}; + +STBTT_DEF int stbtt_InitFont(stbtt_fontinfo *info, const unsigned char *data, int offset); +// Given an offset into the file that defines a font, this function builds +// the necessary cached info for the rest of the system. You must allocate +// the stbtt_fontinfo yourself, and stbtt_InitFont will fill it out. You don't +// need to do anything special to free it, because the contents are pure +// value data with no additional data structures. Returns 0 on failure. + + +////////////////////////////////////////////////////////////////////////////// +// +// CHARACTER TO GLYPH-INDEX CONVERSIOn + +STBTT_DEF int stbtt_FindGlyphIndex(const stbtt_fontinfo *info, int unicode_codepoint); +// If you're going to perform multiple operations on the same character +// and you want a speed-up, call this function with the character you're +// going to process, then use glyph-based functions instead of the +// codepoint-based functions. +// Returns 0 if the character codepoint is not defined in the font. + + +////////////////////////////////////////////////////////////////////////////// +// +// CHARACTER PROPERTIES +// + +STBTT_DEF float stbtt_ScaleForPixelHeight(const stbtt_fontinfo *info, float pixels); +// computes a scale factor to produce a font whose "height" is 'pixels' tall. +// Height is measured as the distance from the highest ascender to the lowest +// descender; in other words, it's equivalent to calling stbtt_GetFontVMetrics +// and computing: +// scale = pixels / (ascent - descent) +// so if you prefer to measure height by the ascent only, use a similar calculation. + +STBTT_DEF float stbtt_ScaleForMappingEmToPixels(const stbtt_fontinfo *info, float pixels); +// computes a scale factor to produce a font whose EM size is mapped to +// 'pixels' tall. This is probably what traditional APIs compute, but +// I'm not positive. + +STBTT_DEF void stbtt_GetFontVMetrics(const stbtt_fontinfo *info, int *ascent, int *descent, int *lineGap); +// ascent is the coordinate above the baseline the font extends; descent +// is the coordinate below the baseline the font extends (i.e. it is typically negative) +// lineGap is the spacing between one row's descent and the next row's ascent... +// so you should advance the vertical position by "*ascent - *descent + *lineGap" +// these are expressed in unscaled coordinates, so you must multiply by +// the scale factor for a given size + +STBTT_DEF int stbtt_GetFontVMetricsOS2(const stbtt_fontinfo *info, int *typoAscent, int *typoDescent, int *typoLineGap); +// analogous to GetFontVMetrics, but returns the "typographic" values from the OS/2 +// table (specific to MS/Windows TTF files). +// +// Returns 1 on success (table present), 0 on failure. + +STBTT_DEF void stbtt_GetFontBoundingBox(const stbtt_fontinfo *info, int *x0, int *y0, int *x1, int *y1); +// the bounding box around all possible characters + +STBTT_DEF void stbtt_GetCodepointHMetrics(const stbtt_fontinfo *info, int codepoint, int *advanceWidth, int *leftSideBearing); +// leftSideBearing is the offset from the current horizontal position to the left edge of the character +// advanceWidth is the offset from the current horizontal position to the next horizontal position +// these are expressed in unscaled coordinates + +STBTT_DEF int stbtt_GetCodepointKernAdvance(const stbtt_fontinfo *info, int ch1, int ch2); +// an additional amount to add to the 'advance' value between ch1 and ch2 + +STBTT_DEF int stbtt_GetCodepointBox(const stbtt_fontinfo *info, int codepoint, int *x0, int *y0, int *x1, int *y1); +// Gets the bounding box of the visible part of the glyph, in unscaled coordinates + +STBTT_DEF void stbtt_GetGlyphHMetrics(const stbtt_fontinfo *info, int glyph_index, int *advanceWidth, int *leftSideBearing); +STBTT_DEF int stbtt_GetGlyphKernAdvance(const stbtt_fontinfo *info, int glyph1, int glyph2); +STBTT_DEF int stbtt_GetGlyphBox(const stbtt_fontinfo *info, int glyph_index, int *x0, int *y0, int *x1, int *y1); +// as above, but takes one or more glyph indices for greater efficiency + +typedef struct stbtt_kerningentry +{ + int glyph1; // use stbtt_FindGlyphIndex + int glyph2; + int advance; +} stbtt_kerningentry; + +STBTT_DEF int stbtt_GetKerningTableLength(const stbtt_fontinfo *info); +STBTT_DEF int stbtt_GetKerningTable(const stbtt_fontinfo *info, stbtt_kerningentry* table, int table_length); +// Retrieves a complete list of all of the kerning pairs provided by the font +// stbtt_GetKerningTable never writes more than table_length entries and returns how many entries it did write. +// The table will be sorted by (a.glyph1 == b.glyph1)?(a.glyph2 < b.glyph2):(a.glyph1 < b.glyph1) + +////////////////////////////////////////////////////////////////////////////// +// +// GLYPH SHAPES (you probably don't need these, but they have to go before +// the bitmaps for C declaration-order reasons) +// + +#ifndef STBTT_vmove // you can predefine these to use different values (but why?) + enum { + STBTT_vmove=1, + STBTT_vline, + STBTT_vcurve, + STBTT_vcubic + }; +#endif + +#ifndef stbtt_vertex // you can predefine this to use different values + // (we share this with other code at RAD) + #define stbtt_vertex_type short // can't use stbtt_int16 because that's not visible in the header file + typedef struct + { + stbtt_vertex_type x,y,cx,cy,cx1,cy1; + unsigned char type,padding; + } stbtt_vertex; +#endif + +STBTT_DEF int stbtt_IsGlyphEmpty(const stbtt_fontinfo *info, int glyph_index); +// returns non-zero if nothing is drawn for this glyph + +STBTT_DEF int stbtt_GetCodepointShape(const stbtt_fontinfo *info, int unicode_codepoint, stbtt_vertex **vertices); +STBTT_DEF int stbtt_GetGlyphShape(const stbtt_fontinfo *info, int glyph_index, stbtt_vertex **vertices); +// returns # of vertices and fills *vertices with the pointer to them +// these are expressed in "unscaled" coordinates +// +// The shape is a series of contours. Each one starts with +// a STBTT_moveto, then consists of a series of mixed +// STBTT_lineto and STBTT_curveto segments. A lineto +// draws a line from previous endpoint to its x,y; a curveto +// draws a quadratic bezier from previous endpoint to +// its x,y, using cx,cy as the bezier control point. + +STBTT_DEF void stbtt_FreeShape(const stbtt_fontinfo *info, stbtt_vertex *vertices); +// frees the data allocated above + +STBTT_DEF unsigned char *stbtt_FindSVGDoc(const stbtt_fontinfo *info, int gl); +STBTT_DEF int stbtt_GetCodepointSVG(const stbtt_fontinfo *info, int unicode_codepoint, const char **svg); +STBTT_DEF int stbtt_GetGlyphSVG(const stbtt_fontinfo *info, int gl, const char **svg); +// fills svg with the character's SVG data. +// returns data size or 0 if SVG not found. + +////////////////////////////////////////////////////////////////////////////// +// +// BITMAP RENDERING +// + +STBTT_DEF void stbtt_FreeBitmap(unsigned char *bitmap, void *userdata); +// frees the bitmap allocated below + +STBTT_DEF unsigned char *stbtt_GetCodepointBitmap(const stbtt_fontinfo *info, float scale_x, float scale_y, int codepoint, int *width, int *height, int *xoff, int *yoff); +// allocates a large-enough single-channel 8bpp bitmap and renders the +// specified character/glyph at the specified scale into it, with +// antialiasing. 0 is no coverage (transparent), 255 is fully covered (opaque). +// *width & *height are filled out with the width & height of the bitmap, +// which is stored left-to-right, top-to-bottom. +// +// xoff/yoff are the offset it pixel space from the glyph origin to the top-left of the bitmap + +STBTT_DEF unsigned char *stbtt_GetCodepointBitmapSubpixel(const stbtt_fontinfo *info, float scale_x, float scale_y, float shift_x, float shift_y, int codepoint, int *width, int *height, int *xoff, int *yoff); +// the same as stbtt_GetCodepoitnBitmap, but you can specify a subpixel +// shift for the character + +STBTT_DEF void stbtt_MakeCodepointBitmap(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, int codepoint); +// the same as stbtt_GetCodepointBitmap, but you pass in storage for the bitmap +// in the form of 'output', with row spacing of 'out_stride' bytes. the bitmap +// is clipped to out_w/out_h bytes. Call stbtt_GetCodepointBitmapBox to get the +// width and height and positioning info for it first. + +STBTT_DEF void stbtt_MakeCodepointBitmapSubpixel(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int codepoint); +// same as stbtt_MakeCodepointBitmap, but you can specify a subpixel +// shift for the character + +STBTT_DEF void stbtt_MakeCodepointBitmapSubpixelPrefilter(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int oversample_x, int oversample_y, float *sub_x, float *sub_y, int codepoint); +// same as stbtt_MakeCodepointBitmapSubpixel, but prefiltering +// is performed (see stbtt_PackSetOversampling) + +STBTT_DEF void stbtt_GetCodepointBitmapBox(const stbtt_fontinfo *font, int codepoint, float scale_x, float scale_y, int *ix0, int *iy0, int *ix1, int *iy1); +// get the bbox of the bitmap centered around the glyph origin; so the +// bitmap width is ix1-ix0, height is iy1-iy0, and location to place +// the bitmap top left is (leftSideBearing*scale,iy0). +// (Note that the bitmap uses y-increases-down, but the shape uses +// y-increases-up, so CodepointBitmapBox and CodepointBox are inverted.) + +STBTT_DEF void stbtt_GetCodepointBitmapBoxSubpixel(const stbtt_fontinfo *font, int codepoint, float scale_x, float scale_y, float shift_x, float shift_y, int *ix0, int *iy0, int *ix1, int *iy1); +// same as stbtt_GetCodepointBitmapBox, but you can specify a subpixel +// shift for the character + +// the following functions are equivalent to the above functions, but operate +// on glyph indices instead of Unicode codepoints (for efficiency) +STBTT_DEF unsigned char *stbtt_GetGlyphBitmap(const stbtt_fontinfo *info, float scale_x, float scale_y, int glyph, int *width, int *height, int *xoff, int *yoff); +STBTT_DEF unsigned char *stbtt_GetGlyphBitmapSubpixel(const stbtt_fontinfo *info, float scale_x, float scale_y, float shift_x, float shift_y, int glyph, int *width, int *height, int *xoff, int *yoff); +STBTT_DEF void stbtt_MakeGlyphBitmap(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, int glyph); +STBTT_DEF void stbtt_MakeGlyphBitmapSubpixel(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int glyph); +STBTT_DEF void stbtt_MakeGlyphBitmapSubpixelPrefilter(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int oversample_x, int oversample_y, float *sub_x, float *sub_y, int glyph); +STBTT_DEF void stbtt_GetGlyphBitmapBox(const stbtt_fontinfo *font, int glyph, float scale_x, float scale_y, int *ix0, int *iy0, int *ix1, int *iy1); +STBTT_DEF void stbtt_GetGlyphBitmapBoxSubpixel(const stbtt_fontinfo *font, int glyph, float scale_x, float scale_y,float shift_x, float shift_y, int *ix0, int *iy0, int *ix1, int *iy1); + + +// @TODO: don't expose this structure +typedef struct +{ + int w,h,stride; + unsigned char *pixels; +} stbtt__bitmap; + +// rasterize a shape with quadratic beziers into a bitmap +STBTT_DEF void stbtt_Rasterize(stbtt__bitmap *result, // 1-channel bitmap to draw into + float flatness_in_pixels, // allowable error of curve in pixels + stbtt_vertex *vertices, // array of vertices defining shape + int num_verts, // number of vertices in above array + float scale_x, float scale_y, // scale applied to input vertices + float shift_x, float shift_y, // translation applied to input vertices + int x_off, int y_off, // another translation applied to input + int invert, // if non-zero, vertically flip shape + void *userdata); // context for to STBTT_MALLOC + +////////////////////////////////////////////////////////////////////////////// +// +// Signed Distance Function (or Field) rendering + +STBTT_DEF void stbtt_FreeSDF(unsigned char *bitmap, void *userdata); +// frees the SDF bitmap allocated below + +STBTT_DEF unsigned char * stbtt_GetGlyphSDF(const stbtt_fontinfo *info, float scale, int glyph, int padding, unsigned char onedge_value, float pixel_dist_scale, int *width, int *height, int *xoff, int *yoff); +STBTT_DEF unsigned char * stbtt_GetCodepointSDF(const stbtt_fontinfo *info, float scale, int codepoint, int padding, unsigned char onedge_value, float pixel_dist_scale, int *width, int *height, int *xoff, int *yoff); +// These functions compute a discretized SDF field for a single character, suitable for storing +// in a single-channel texture, sampling with bilinear filtering, and testing against +// larger than some threshold to produce scalable fonts. +// info -- the font +// scale -- controls the size of the resulting SDF bitmap, same as it would be creating a regular bitmap +// glyph/codepoint -- the character to generate the SDF for +// padding -- extra "pixels" around the character which are filled with the distance to the character (not 0), +// which allows effects like bit outlines +// onedge_value -- value 0-255 to test the SDF against to reconstruct the character (i.e. the isocontour of the character) +// pixel_dist_scale -- what value the SDF should increase by when moving one SDF "pixel" away from the edge (on the 0..255 scale) +// if positive, > onedge_value is inside; if negative, < onedge_value is inside +// width,height -- output height & width of the SDF bitmap (including padding) +// xoff,yoff -- output origin of the character +// return value -- a 2D array of bytes 0..255, width*height in size +// +// pixel_dist_scale & onedge_value are a scale & bias that allows you to make +// optimal use of the limited 0..255 for your application, trading off precision +// and special effects. SDF values outside the range 0..255 are clamped to 0..255. +// +// Example: +// scale = stbtt_ScaleForPixelHeight(22) +// padding = 5 +// onedge_value = 180 +// pixel_dist_scale = 180/5.0 = 36.0 +// +// This will create an SDF bitmap in which the character is about 22 pixels +// high but the whole bitmap is about 22+5+5=32 pixels high. To produce a filled +// shape, sample the SDF at each pixel and fill the pixel if the SDF value +// is greater than or equal to 180/255. (You'll actually want to antialias, +// which is beyond the scope of this example.) Additionally, you can compute +// offset outlines (e.g. to stroke the character border inside & outside, +// or only outside). For example, to fill outside the character up to 3 SDF +// pixels, you would compare against (180-36.0*3)/255 = 72/255. The above +// choice of variables maps a range from 5 pixels outside the shape to +// 2 pixels inside the shape to 0..255; this is intended primarily for apply +// outside effects only (the interior range is needed to allow proper +// antialiasing of the font at *smaller* sizes) +// +// The function computes the SDF analytically at each SDF pixel, not by e.g. +// building a higher-res bitmap and approximating it. In theory the quality +// should be as high as possible for an SDF of this size & representation, but +// unclear if this is true in practice (perhaps building a higher-res bitmap +// and computing from that can allow drop-out prevention). +// +// The algorithm has not been optimized at all, so expect it to be slow +// if computing lots of characters or very large sizes. + + + +////////////////////////////////////////////////////////////////////////////// +// +// Finding the right font... +// +// You should really just solve this offline, keep your own tables +// of what font is what, and don't try to get it out of the .ttf file. +// That's because getting it out of the .ttf file is really hard, because +// the names in the file can appear in many possible encodings, in many +// possible languages, and e.g. if you need a case-insensitive comparison, +// the details of that depend on the encoding & language in a complex way +// (actually underspecified in truetype, but also gigantic). +// +// But you can use the provided functions in two possible ways: +// stbtt_FindMatchingFont() will use *case-sensitive* comparisons on +// unicode-encoded names to try to find the font you want; +// you can run this before calling stbtt_InitFont() +// +// stbtt_GetFontNameString() lets you get any of the various strings +// from the file yourself and do your own comparisons on them. +// You have to have called stbtt_InitFont() first. + + +STBTT_DEF int stbtt_FindMatchingFont(const unsigned char *fontdata, const char *name, int flags); +// returns the offset (not index) of the font that matches, or -1 if none +// if you use STBTT_MACSTYLE_DONTCARE, use a font name like "Arial Bold". +// if you use any other flag, use a font name like "Arial"; this checks +// the 'macStyle' header field; i don't know if fonts set this consistently +#define STBTT_MACSTYLE_DONTCARE 0 +#define STBTT_MACSTYLE_BOLD 1 +#define STBTT_MACSTYLE_ITALIC 2 +#define STBTT_MACSTYLE_UNDERSCORE 4 +#define STBTT_MACSTYLE_NONE 8 // <= not same as 0, this makes us check the bitfield is 0 + +STBTT_DEF int stbtt_CompareUTF8toUTF16_bigendian(const char *s1, int len1, const char *s2, int len2); +// returns 1/0 whether the first string interpreted as utf8 is identical to +// the second string interpreted as big-endian utf16... useful for strings from next func + +STBTT_DEF const char *stbtt_GetFontNameString(const stbtt_fontinfo *font, int *length, int platformID, int encodingID, int languageID, int nameID); +// returns the string (which may be big-endian double byte, e.g. for unicode) +// and puts the length in bytes in *length. +// +// some of the values for the IDs are below; for more see the truetype spec: +// http://developer.apple.com/textfonts/TTRefMan/RM06/Chap6name.html +// http://www.microsoft.com/typography/otspec/name.htm + +enum { // platformID + STBTT_PLATFORM_ID_UNICODE =0, + STBTT_PLATFORM_ID_MAC =1, + STBTT_PLATFORM_ID_ISO =2, + STBTT_PLATFORM_ID_MICROSOFT =3 +}; + +enum { // encodingID for STBTT_PLATFORM_ID_UNICODE + STBTT_UNICODE_EID_UNICODE_1_0 =0, + STBTT_UNICODE_EID_UNICODE_1_1 =1, + STBTT_UNICODE_EID_ISO_10646 =2, + STBTT_UNICODE_EID_UNICODE_2_0_BMP=3, + STBTT_UNICODE_EID_UNICODE_2_0_FULL=4 +}; + +enum { // encodingID for STBTT_PLATFORM_ID_MICROSOFT + STBTT_MS_EID_SYMBOL =0, + STBTT_MS_EID_UNICODE_BMP =1, + STBTT_MS_EID_SHIFTJIS =2, + STBTT_MS_EID_UNICODE_FULL =10 +}; + +enum { // encodingID for STBTT_PLATFORM_ID_MAC; same as Script Manager codes + STBTT_MAC_EID_ROMAN =0, STBTT_MAC_EID_ARABIC =4, + STBTT_MAC_EID_JAPANESE =1, STBTT_MAC_EID_HEBREW =5, + STBTT_MAC_EID_CHINESE_TRAD =2, STBTT_MAC_EID_GREEK =6, + STBTT_MAC_EID_KOREAN =3, STBTT_MAC_EID_RUSSIAN =7 +}; + +enum { // languageID for STBTT_PLATFORM_ID_MICROSOFT; same as LCID... + // problematic because there are e.g. 16 english LCIDs and 16 arabic LCIDs + STBTT_MS_LANG_ENGLISH =0x0409, STBTT_MS_LANG_ITALIAN =0x0410, + STBTT_MS_LANG_CHINESE =0x0804, STBTT_MS_LANG_JAPANESE =0x0411, + STBTT_MS_LANG_DUTCH =0x0413, STBTT_MS_LANG_KOREAN =0x0412, + STBTT_MS_LANG_FRENCH =0x040c, STBTT_MS_LANG_RUSSIAN =0x0419, + STBTT_MS_LANG_GERMAN =0x0407, STBTT_MS_LANG_SPANISH =0x0409, + STBTT_MS_LANG_HEBREW =0x040d, STBTT_MS_LANG_SWEDISH =0x041D +}; + +enum { // languageID for STBTT_PLATFORM_ID_MAC + STBTT_MAC_LANG_ENGLISH =0 , STBTT_MAC_LANG_JAPANESE =11, + STBTT_MAC_LANG_ARABIC =12, STBTT_MAC_LANG_KOREAN =23, + STBTT_MAC_LANG_DUTCH =4 , STBTT_MAC_LANG_RUSSIAN =32, + STBTT_MAC_LANG_FRENCH =1 , STBTT_MAC_LANG_SPANISH =6 , + STBTT_MAC_LANG_GERMAN =2 , STBTT_MAC_LANG_SWEDISH =5 , + STBTT_MAC_LANG_HEBREW =10, STBTT_MAC_LANG_CHINESE_SIMPLIFIED =33, + STBTT_MAC_LANG_ITALIAN =3 , STBTT_MAC_LANG_CHINESE_TRAD =19 +}; + +#ifdef __cplusplus +} +#endif + +#endif // __STB_INCLUDE_STB_TRUETYPE_H__ + +/////////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////////// +//// +//// IMPLEMENTATION +//// +//// + +#ifdef STB_TRUETYPE_IMPLEMENTATION + +#ifndef STBTT_MAX_OVERSAMPLE +#define STBTT_MAX_OVERSAMPLE 8 +#endif + +#if STBTT_MAX_OVERSAMPLE > 255 +#error "STBTT_MAX_OVERSAMPLE cannot be > 255" +#endif + +typedef int stbtt__test_oversample_pow2[(STBTT_MAX_OVERSAMPLE & (STBTT_MAX_OVERSAMPLE-1)) == 0 ? 1 : -1]; + +#ifndef STBTT_RASTERIZER_VERSION +#define STBTT_RASTERIZER_VERSION 2 +#endif + +#ifdef _MSC_VER +#define STBTT__NOTUSED(v) (void)(v) +#else +#define STBTT__NOTUSED(v) (void)sizeof(v) +#endif + +////////////////////////////////////////////////////////////////////////// +// +// stbtt__buf helpers to parse data from file +// + +static stbtt_uint8 stbtt__buf_get8(stbtt__buf *b) +{ + if (b->cursor >= b->size) + return 0; + return b->data[b->cursor++]; +} + +static stbtt_uint8 stbtt__buf_peek8(stbtt__buf *b) +{ + if (b->cursor >= b->size) + return 0; + return b->data[b->cursor]; +} + +static void stbtt__buf_seek(stbtt__buf *b, int o) +{ + STBTT_assert(!(o > b->size || o < 0)); + b->cursor = (o > b->size || o < 0) ? b->size : o; +} + +static void stbtt__buf_skip(stbtt__buf *b, int o) +{ + stbtt__buf_seek(b, b->cursor + o); +} + +static stbtt_uint32 stbtt__buf_get(stbtt__buf *b, int n) +{ + stbtt_uint32 v = 0; + int i; + STBTT_assert(n >= 1 && n <= 4); + for (i = 0; i < n; i++) + v = (v << 8) | stbtt__buf_get8(b); + return v; +} + +static stbtt__buf stbtt__new_buf(const void *p, size_t size) +{ + stbtt__buf r; + STBTT_assert(size < 0x40000000); + r.data = (stbtt_uint8*) p; + r.size = (int) size; + r.cursor = 0; + return r; +} + +#define stbtt__buf_get16(b) stbtt__buf_get((b), 2) +#define stbtt__buf_get32(b) stbtt__buf_get((b), 4) + +static stbtt__buf stbtt__buf_range(const stbtt__buf *b, int o, int s) +{ + stbtt__buf r = stbtt__new_buf(NULL, 0); + if (o < 0 || s < 0 || o > b->size || s > b->size - o) return r; + r.data = b->data + o; + r.size = s; + return r; +} + +static stbtt__buf stbtt__cff_get_index(stbtt__buf *b) +{ + int count, start, offsize; + start = b->cursor; + count = stbtt__buf_get16(b); + if (count) { + offsize = stbtt__buf_get8(b); + STBTT_assert(offsize >= 1 && offsize <= 4); + stbtt__buf_skip(b, offsize * count); + stbtt__buf_skip(b, stbtt__buf_get(b, offsize) - 1); + } + return stbtt__buf_range(b, start, b->cursor - start); +} + +static stbtt_uint32 stbtt__cff_int(stbtt__buf *b) +{ + int b0 = stbtt__buf_get8(b); + if (b0 >= 32 && b0 <= 246) return b0 - 139; + else if (b0 >= 247 && b0 <= 250) return (b0 - 247)*256 + stbtt__buf_get8(b) + 108; + else if (b0 >= 251 && b0 <= 254) return -(b0 - 251)*256 - stbtt__buf_get8(b) - 108; + else if (b0 == 28) return stbtt__buf_get16(b); + else if (b0 == 29) return stbtt__buf_get32(b); + STBTT_assert(0); + return 0; +} + +static void stbtt__cff_skip_operand(stbtt__buf *b) { + int v, b0 = stbtt__buf_peek8(b); + STBTT_assert(b0 >= 28); + if (b0 == 30) { + stbtt__buf_skip(b, 1); + while (b->cursor < b->size) { + v = stbtt__buf_get8(b); + if ((v & 0xF) == 0xF || (v >> 4) == 0xF) + break; + } + } else { + stbtt__cff_int(b); + } +} + +static stbtt__buf stbtt__dict_get(stbtt__buf *b, int key) +{ + stbtt__buf_seek(b, 0); + while (b->cursor < b->size) { + int start = b->cursor, end, op; + while (stbtt__buf_peek8(b) >= 28) + stbtt__cff_skip_operand(b); + end = b->cursor; + op = stbtt__buf_get8(b); + if (op == 12) op = stbtt__buf_get8(b) | 0x100; + if (op == key) return stbtt__buf_range(b, start, end-start); + } + return stbtt__buf_range(b, 0, 0); +} + +static void stbtt__dict_get_ints(stbtt__buf *b, int key, int outcount, stbtt_uint32 *out) +{ + int i; + stbtt__buf operands = stbtt__dict_get(b, key); + for (i = 0; i < outcount && operands.cursor < operands.size; i++) + out[i] = stbtt__cff_int(&operands); +} + +static int stbtt__cff_index_count(stbtt__buf *b) +{ + stbtt__buf_seek(b, 0); + return stbtt__buf_get16(b); +} + +static stbtt__buf stbtt__cff_index_get(stbtt__buf b, int i) +{ + int count, offsize, start, end; + stbtt__buf_seek(&b, 0); + count = stbtt__buf_get16(&b); + offsize = stbtt__buf_get8(&b); + STBTT_assert(i >= 0 && i < count); + STBTT_assert(offsize >= 1 && offsize <= 4); + stbtt__buf_skip(&b, i*offsize); + start = stbtt__buf_get(&b, offsize); + end = stbtt__buf_get(&b, offsize); + return stbtt__buf_range(&b, 2+(count+1)*offsize+start, end - start); +} + +////////////////////////////////////////////////////////////////////////// +// +// accessors to parse data from file +// + +// on platforms that don't allow misaligned reads, if we want to allow +// truetype fonts that aren't padded to alignment, define ALLOW_UNALIGNED_TRUETYPE + +#define ttBYTE(p) (* (stbtt_uint8 *) (p)) +#define ttCHAR(p) (* (stbtt_int8 *) (p)) +#define ttFixed(p) ttLONG(p) + +static stbtt_uint16 ttUSHORT(stbtt_uint8 *p) { return p[0]*256 + p[1]; } +static stbtt_int16 ttSHORT(stbtt_uint8 *p) { return p[0]*256 + p[1]; } +static stbtt_uint32 ttULONG(stbtt_uint8 *p) { return (p[0]<<24) + (p[1]<<16) + (p[2]<<8) + p[3]; } +static stbtt_int32 ttLONG(stbtt_uint8 *p) { return (p[0]<<24) + (p[1]<<16) + (p[2]<<8) + p[3]; } + +#define stbtt_tag4(p,c0,c1,c2,c3) ((p)[0] == (c0) && (p)[1] == (c1) && (p)[2] == (c2) && (p)[3] == (c3)) +#define stbtt_tag(p,str) stbtt_tag4(p,str[0],str[1],str[2],str[3]) + +static int stbtt__isfont(stbtt_uint8 *font) +{ + // check the version number + if (stbtt_tag4(font, '1',0,0,0)) return 1; // TrueType 1 + if (stbtt_tag(font, "typ1")) return 1; // TrueType with type 1 font -- we don't support this! + if (stbtt_tag(font, "OTTO")) return 1; // OpenType with CFF + if (stbtt_tag4(font, 0,1,0,0)) return 1; // OpenType 1.0 + if (stbtt_tag(font, "true")) return 1; // Apple specification for TrueType fonts + return 0; +} + +// @OPTIMIZE: binary search +static stbtt_uint32 stbtt__find_table(stbtt_uint8 *data, stbtt_uint32 fontstart, const char *tag) +{ + stbtt_int32 num_tables = ttUSHORT(data+fontstart+4); + stbtt_uint32 tabledir = fontstart + 12; + stbtt_int32 i; + for (i=0; i < num_tables; ++i) { + stbtt_uint32 loc = tabledir + 16*i; + if (stbtt_tag(data+loc+0, tag)) + return ttULONG(data+loc+8); + } + return 0; +} + +static int stbtt_GetFontOffsetForIndex_internal(unsigned char *font_collection, int index) +{ + // if it's just a font, there's only one valid index + if (stbtt__isfont(font_collection)) + return index == 0 ? 0 : -1; + + // check if it's a TTC + if (stbtt_tag(font_collection, "ttcf")) { + // version 1? + if (ttULONG(font_collection+4) == 0x00010000 || ttULONG(font_collection+4) == 0x00020000) { + stbtt_int32 n = ttLONG(font_collection+8); + if (index >= n) + return -1; + return ttULONG(font_collection+12+index*4); + } + } + return -1; +} + +static int stbtt_GetNumberOfFonts_internal(unsigned char *font_collection) +{ + // if it's just a font, there's only one valid font + if (stbtt__isfont(font_collection)) + return 1; + + // check if it's a TTC + if (stbtt_tag(font_collection, "ttcf")) { + // version 1? + if (ttULONG(font_collection+4) == 0x00010000 || ttULONG(font_collection+4) == 0x00020000) { + return ttLONG(font_collection+8); + } + } + return 0; +} + +static stbtt__buf stbtt__get_subrs(stbtt__buf cff, stbtt__buf fontdict) +{ + stbtt_uint32 subrsoff = 0, private_loc[2] = { 0, 0 }; + stbtt__buf pdict; + stbtt__dict_get_ints(&fontdict, 18, 2, private_loc); + if (!private_loc[1] || !private_loc[0]) return stbtt__new_buf(NULL, 0); + pdict = stbtt__buf_range(&cff, private_loc[1], private_loc[0]); + stbtt__dict_get_ints(&pdict, 19, 1, &subrsoff); + if (!subrsoff) return stbtt__new_buf(NULL, 0); + stbtt__buf_seek(&cff, private_loc[1]+subrsoff); + return stbtt__cff_get_index(&cff); +} + +// since most people won't use this, find this table the first time it's needed +static int stbtt__get_svg(stbtt_fontinfo *info) +{ + stbtt_uint32 t; + if (info->svg < 0) { + t = stbtt__find_table(info->data, info->fontstart, "SVG "); + if (t) { + stbtt_uint32 offset = ttULONG(info->data + t + 2); + info->svg = t + offset; + } else { + info->svg = 0; + } + } + return info->svg; +} + +static int stbtt_InitFont_internal(stbtt_fontinfo *info, unsigned char *data, int fontstart) +{ + stbtt_uint32 cmap, t; + stbtt_int32 i,numTables; + + info->data = data; + info->fontstart = fontstart; + info->cff = stbtt__new_buf(NULL, 0); + + cmap = stbtt__find_table(data, fontstart, "cmap"); // required + info->loca = stbtt__find_table(data, fontstart, "loca"); // required + info->head = stbtt__find_table(data, fontstart, "head"); // required + info->glyf = stbtt__find_table(data, fontstart, "glyf"); // required + info->hhea = stbtt__find_table(data, fontstart, "hhea"); // required + info->hmtx = stbtt__find_table(data, fontstart, "hmtx"); // required + info->kern = stbtt__find_table(data, fontstart, "kern"); // not required + info->gpos = stbtt__find_table(data, fontstart, "GPOS"); // not required + + if (!cmap || !info->head || !info->hhea || !info->hmtx) + return 0; + if (info->glyf) { + // required for truetype + if (!info->loca) return 0; + } else { + // initialization for CFF / Type2 fonts (OTF) + stbtt__buf b, topdict, topdictidx; + stbtt_uint32 cstype = 2, charstrings = 0, fdarrayoff = 0, fdselectoff = 0; + stbtt_uint32 cff; + + cff = stbtt__find_table(data, fontstart, "CFF "); + if (!cff) return 0; + + info->fontdicts = stbtt__new_buf(NULL, 0); + info->fdselect = stbtt__new_buf(NULL, 0); + + // @TODO this should use size from table (not 512MB) + info->cff = stbtt__new_buf(data+cff, 512*1024*1024); + b = info->cff; + + // read the header + stbtt__buf_skip(&b, 2); + stbtt__buf_seek(&b, stbtt__buf_get8(&b)); // hdrsize + + // @TODO the name INDEX could list multiple fonts, + // but we just use the first one. + stbtt__cff_get_index(&b); // name INDEX + topdictidx = stbtt__cff_get_index(&b); + topdict = stbtt__cff_index_get(topdictidx, 0); + stbtt__cff_get_index(&b); // string INDEX + info->gsubrs = stbtt__cff_get_index(&b); + + stbtt__dict_get_ints(&topdict, 17, 1, &charstrings); + stbtt__dict_get_ints(&topdict, 0x100 | 6, 1, &cstype); + stbtt__dict_get_ints(&topdict, 0x100 | 36, 1, &fdarrayoff); + stbtt__dict_get_ints(&topdict, 0x100 | 37, 1, &fdselectoff); + info->subrs = stbtt__get_subrs(b, topdict); + + // we only support Type 2 charstrings + if (cstype != 2) return 0; + if (charstrings == 0) return 0; + + if (fdarrayoff) { + // looks like a CID font + if (!fdselectoff) return 0; + stbtt__buf_seek(&b, fdarrayoff); + info->fontdicts = stbtt__cff_get_index(&b); + info->fdselect = stbtt__buf_range(&b, fdselectoff, b.size-fdselectoff); + } + + stbtt__buf_seek(&b, charstrings); + info->charstrings = stbtt__cff_get_index(&b); + } + + t = stbtt__find_table(data, fontstart, "maxp"); + if (t) + info->numGlyphs = ttUSHORT(data+t+4); + else + info->numGlyphs = 0xffff; + + info->svg = -1; + + // find a cmap encoding table we understand *now* to avoid searching + // later. (todo: could make this installable) + // the same regardless of glyph. + numTables = ttUSHORT(data + cmap + 2); + info->index_map = 0; + for (i=0; i < numTables; ++i) { + stbtt_uint32 encoding_record = cmap + 4 + 8 * i; + // find an encoding we understand: + switch(ttUSHORT(data+encoding_record)) { + case STBTT_PLATFORM_ID_MICROSOFT: + switch (ttUSHORT(data+encoding_record+2)) { + case STBTT_MS_EID_UNICODE_BMP: + case STBTT_MS_EID_UNICODE_FULL: + // MS/Unicode + info->index_map = cmap + ttULONG(data+encoding_record+4); + break; + } + break; + case STBTT_PLATFORM_ID_UNICODE: + // Mac/iOS has these + // all the encodingIDs are unicode, so we don't bother to check it + info->index_map = cmap + ttULONG(data+encoding_record+4); + break; + } + } + if (info->index_map == 0) + return 0; + + info->indexToLocFormat = ttUSHORT(data+info->head + 50); + return 1; +} + +STBTT_DEF int stbtt_FindGlyphIndex(const stbtt_fontinfo *info, int unicode_codepoint) +{ + stbtt_uint8 *data = info->data; + stbtt_uint32 index_map = info->index_map; + + stbtt_uint16 format = ttUSHORT(data + index_map + 0); + if (format == 0) { // apple byte encoding + stbtt_int32 bytes = ttUSHORT(data + index_map + 2); + if (unicode_codepoint < bytes-6) + return ttBYTE(data + index_map + 6 + unicode_codepoint); + return 0; + } else if (format == 6) { + stbtt_uint32 first = ttUSHORT(data + index_map + 6); + stbtt_uint32 count = ttUSHORT(data + index_map + 8); + if ((stbtt_uint32) unicode_codepoint >= first && (stbtt_uint32) unicode_codepoint < first+count) + return ttUSHORT(data + index_map + 10 + (unicode_codepoint - first)*2); + return 0; + } else if (format == 2) { + STBTT_assert(0); // @TODO: high-byte mapping for japanese/chinese/korean + return 0; + } else if (format == 4) { // standard mapping for windows fonts: binary search collection of ranges + stbtt_uint16 segcount = ttUSHORT(data+index_map+6) >> 1; + stbtt_uint16 searchRange = ttUSHORT(data+index_map+8) >> 1; + stbtt_uint16 entrySelector = ttUSHORT(data+index_map+10); + stbtt_uint16 rangeShift = ttUSHORT(data+index_map+12) >> 1; + + // do a binary search of the segments + stbtt_uint32 endCount = index_map + 14; + stbtt_uint32 search = endCount; + + if (unicode_codepoint > 0xffff) + return 0; + + // they lie from endCount .. endCount + segCount + // but searchRange is the nearest power of two, so... + if (unicode_codepoint >= ttUSHORT(data + search + rangeShift*2)) + search += rangeShift*2; + + // now decrement to bias correctly to find smallest + search -= 2; + while (entrySelector) { + stbtt_uint16 end; + searchRange >>= 1; + end = ttUSHORT(data + search + searchRange*2); + if (unicode_codepoint > end) + search += searchRange*2; + --entrySelector; + } + search += 2; + + { + stbtt_uint16 offset, start, last; + stbtt_uint16 item = (stbtt_uint16) ((search - endCount) >> 1); + + start = ttUSHORT(data + index_map + 14 + segcount*2 + 2 + 2*item); + last = ttUSHORT(data + endCount + 2*item); + if (unicode_codepoint < start || unicode_codepoint > last) + return 0; + + offset = ttUSHORT(data + index_map + 14 + segcount*6 + 2 + 2*item); + if (offset == 0) + return (stbtt_uint16) (unicode_codepoint + ttSHORT(data + index_map + 14 + segcount*4 + 2 + 2*item)); + + return ttUSHORT(data + offset + (unicode_codepoint-start)*2 + index_map + 14 + segcount*6 + 2 + 2*item); + } + } else if (format == 12 || format == 13) { + stbtt_uint32 ngroups = ttULONG(data+index_map+12); + stbtt_int32 low,high; + low = 0; high = (stbtt_int32)ngroups; + // Binary search the right group. + while (low < high) { + stbtt_int32 mid = low + ((high-low) >> 1); // rounds down, so low <= mid < high + stbtt_uint32 start_char = ttULONG(data+index_map+16+mid*12); + stbtt_uint32 end_char = ttULONG(data+index_map+16+mid*12+4); + if ((stbtt_uint32) unicode_codepoint < start_char) + high = mid; + else if ((stbtt_uint32) unicode_codepoint > end_char) + low = mid+1; + else { + stbtt_uint32 start_glyph = ttULONG(data+index_map+16+mid*12+8); + if (format == 12) + return start_glyph + unicode_codepoint-start_char; + else // format == 13 + return start_glyph; + } + } + return 0; // not found + } + // @TODO + STBTT_assert(0); + return 0; +} + +STBTT_DEF int stbtt_GetCodepointShape(const stbtt_fontinfo *info, int unicode_codepoint, stbtt_vertex **vertices) +{ + return stbtt_GetGlyphShape(info, stbtt_FindGlyphIndex(info, unicode_codepoint), vertices); +} + +static void stbtt_setvertex(stbtt_vertex *v, stbtt_uint8 type, stbtt_int32 x, stbtt_int32 y, stbtt_int32 cx, stbtt_int32 cy) +{ + v->type = type; + v->x = (stbtt_int16) x; + v->y = (stbtt_int16) y; + v->cx = (stbtt_int16) cx; + v->cy = (stbtt_int16) cy; +} + +static int stbtt__GetGlyfOffset(const stbtt_fontinfo *info, int glyph_index) +{ + int g1,g2; + + STBTT_assert(!info->cff.size); + + if (glyph_index >= info->numGlyphs) return -1; // glyph index out of range + if (info->indexToLocFormat >= 2) return -1; // unknown index->glyph map format + + if (info->indexToLocFormat == 0) { + g1 = info->glyf + ttUSHORT(info->data + info->loca + glyph_index * 2) * 2; + g2 = info->glyf + ttUSHORT(info->data + info->loca + glyph_index * 2 + 2) * 2; + } else { + g1 = info->glyf + ttULONG (info->data + info->loca + glyph_index * 4); + g2 = info->glyf + ttULONG (info->data + info->loca + glyph_index * 4 + 4); + } + + return g1==g2 ? -1 : g1; // if length is 0, return -1 +} + +static int stbtt__GetGlyphInfoT2(const stbtt_fontinfo *info, int glyph_index, int *x0, int *y0, int *x1, int *y1); + +STBTT_DEF int stbtt_GetGlyphBox(const stbtt_fontinfo *info, int glyph_index, int *x0, int *y0, int *x1, int *y1) +{ + if (info->cff.size) { + stbtt__GetGlyphInfoT2(info, glyph_index, x0, y0, x1, y1); + } else { + int g = stbtt__GetGlyfOffset(info, glyph_index); + if (g < 0) return 0; + + if (x0) *x0 = ttSHORT(info->data + g + 2); + if (y0) *y0 = ttSHORT(info->data + g + 4); + if (x1) *x1 = ttSHORT(info->data + g + 6); + if (y1) *y1 = ttSHORT(info->data + g + 8); + } + return 1; +} + +STBTT_DEF int stbtt_GetCodepointBox(const stbtt_fontinfo *info, int codepoint, int *x0, int *y0, int *x1, int *y1) +{ + return stbtt_GetGlyphBox(info, stbtt_FindGlyphIndex(info,codepoint), x0,y0,x1,y1); +} + +STBTT_DEF int stbtt_IsGlyphEmpty(const stbtt_fontinfo *info, int glyph_index) +{ + stbtt_int16 numberOfContours; + int g; + if (info->cff.size) + return stbtt__GetGlyphInfoT2(info, glyph_index, NULL, NULL, NULL, NULL) == 0; + g = stbtt__GetGlyfOffset(info, glyph_index); + if (g < 0) return 1; + numberOfContours = ttSHORT(info->data + g); + return numberOfContours == 0; +} + +static int stbtt__close_shape(stbtt_vertex *vertices, int num_vertices, int was_off, int start_off, + stbtt_int32 sx, stbtt_int32 sy, stbtt_int32 scx, stbtt_int32 scy, stbtt_int32 cx, stbtt_int32 cy) +{ + if (start_off) { + if (was_off) + stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve, (cx+scx)>>1, (cy+scy)>>1, cx,cy); + stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve, sx,sy,scx,scy); + } else { + if (was_off) + stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve,sx,sy,cx,cy); + else + stbtt_setvertex(&vertices[num_vertices++], STBTT_vline,sx,sy,0,0); + } + return num_vertices; +} + +static int stbtt__GetGlyphShapeTT(const stbtt_fontinfo *info, int glyph_index, stbtt_vertex **pvertices) +{ + stbtt_int16 numberOfContours; + stbtt_uint8 *endPtsOfContours; + stbtt_uint8 *data = info->data; + stbtt_vertex *vertices=0; + int num_vertices=0; + int g = stbtt__GetGlyfOffset(info, glyph_index); + + *pvertices = NULL; + + if (g < 0) return 0; + + numberOfContours = ttSHORT(data + g); + + if (numberOfContours > 0) { + stbtt_uint8 flags=0,flagcount; + stbtt_int32 ins, i,j=0,m,n, next_move, was_off=0, off, start_off=0; + stbtt_int32 x,y,cx,cy,sx,sy, scx,scy; + stbtt_uint8 *points; + endPtsOfContours = (data + g + 10); + ins = ttUSHORT(data + g + 10 + numberOfContours * 2); + points = data + g + 10 + numberOfContours * 2 + 2 + ins; + + n = 1+ttUSHORT(endPtsOfContours + numberOfContours*2-2); + + m = n + 2*numberOfContours; // a loose bound on how many vertices we might need + vertices = (stbtt_vertex *) STBTT_malloc(m * sizeof(vertices[0]), info->userdata); + if (vertices == 0) + return 0; + + next_move = 0; + flagcount=0; + + // in first pass, we load uninterpreted data into the allocated array + // above, shifted to the end of the array so we won't overwrite it when + // we create our final data starting from the front + + off = m - n; // starting offset for uninterpreted data, regardless of how m ends up being calculated + + // first load flags + + for (i=0; i < n; ++i) { + if (flagcount == 0) { + flags = *points++; + if (flags & 8) + flagcount = *points++; + } else + --flagcount; + vertices[off+i].type = flags; + } + + // now load x coordinates + x=0; + for (i=0; i < n; ++i) { + flags = vertices[off+i].type; + if (flags & 2) { + stbtt_int16 dx = *points++; + x += (flags & 16) ? dx : -dx; // ??? + } else { + if (!(flags & 16)) { + x = x + (stbtt_int16) (points[0]*256 + points[1]); + points += 2; + } + } + vertices[off+i].x = (stbtt_int16) x; + } + + // now load y coordinates + y=0; + for (i=0; i < n; ++i) { + flags = vertices[off+i].type; + if (flags & 4) { + stbtt_int16 dy = *points++; + y += (flags & 32) ? dy : -dy; // ??? + } else { + if (!(flags & 32)) { + y = y + (stbtt_int16) (points[0]*256 + points[1]); + points += 2; + } + } + vertices[off+i].y = (stbtt_int16) y; + } + + // now convert them to our format + num_vertices=0; + sx = sy = cx = cy = scx = scy = 0; + for (i=0; i < n; ++i) { + flags = vertices[off+i].type; + x = (stbtt_int16) vertices[off+i].x; + y = (stbtt_int16) vertices[off+i].y; + + if (next_move == i) { + if (i != 0) + num_vertices = stbtt__close_shape(vertices, num_vertices, was_off, start_off, sx,sy,scx,scy,cx,cy); + + // now start the new one + start_off = !(flags & 1); + if (start_off) { + // if we start off with an off-curve point, then when we need to find a point on the curve + // where we can start, and we need to save some state for when we wraparound. + scx = x; + scy = y; + if (!(vertices[off+i+1].type & 1)) { + // next point is also a curve point, so interpolate an on-point curve + sx = (x + (stbtt_int32) vertices[off+i+1].x) >> 1; + sy = (y + (stbtt_int32) vertices[off+i+1].y) >> 1; + } else { + // otherwise just use the next point as our start point + sx = (stbtt_int32) vertices[off+i+1].x; + sy = (stbtt_int32) vertices[off+i+1].y; + ++i; // we're using point i+1 as the starting point, so skip it + } + } else { + sx = x; + sy = y; + } + stbtt_setvertex(&vertices[num_vertices++], STBTT_vmove,sx,sy,0,0); + was_off = 0; + next_move = 1 + ttUSHORT(endPtsOfContours+j*2); + ++j; + } else { + if (!(flags & 1)) { // if it's a curve + if (was_off) // two off-curve control points in a row means interpolate an on-curve midpoint + stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve, (cx+x)>>1, (cy+y)>>1, cx, cy); + cx = x; + cy = y; + was_off = 1; + } else { + if (was_off) + stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve, x,y, cx, cy); + else + stbtt_setvertex(&vertices[num_vertices++], STBTT_vline, x,y,0,0); + was_off = 0; + } + } + } + num_vertices = stbtt__close_shape(vertices, num_vertices, was_off, start_off, sx,sy,scx,scy,cx,cy); + } else if (numberOfContours < 0) { + // Compound shapes. + int more = 1; + stbtt_uint8 *comp = data + g + 10; + num_vertices = 0; + vertices = 0; + while (more) { + stbtt_uint16 flags, gidx; + int comp_num_verts = 0, i; + stbtt_vertex *comp_verts = 0, *tmp = 0; + float mtx[6] = {1,0,0,1,0,0}, m, n; + + flags = ttSHORT(comp); comp+=2; + gidx = ttSHORT(comp); comp+=2; + + if (flags & 2) { // XY values + if (flags & 1) { // shorts + mtx[4] = ttSHORT(comp); comp+=2; + mtx[5] = ttSHORT(comp); comp+=2; + } else { + mtx[4] = ttCHAR(comp); comp+=1; + mtx[5] = ttCHAR(comp); comp+=1; + } + } + else { + // @TODO handle matching point + STBTT_assert(0); + } + if (flags & (1<<3)) { // WE_HAVE_A_SCALE + mtx[0] = mtx[3] = ttSHORT(comp)/16384.0f; comp+=2; + mtx[1] = mtx[2] = 0; + } else if (flags & (1<<6)) { // WE_HAVE_AN_X_AND_YSCALE + mtx[0] = ttSHORT(comp)/16384.0f; comp+=2; + mtx[1] = mtx[2] = 0; + mtx[3] = ttSHORT(comp)/16384.0f; comp+=2; + } else if (flags & (1<<7)) { // WE_HAVE_A_TWO_BY_TWO + mtx[0] = ttSHORT(comp)/16384.0f; comp+=2; + mtx[1] = ttSHORT(comp)/16384.0f; comp+=2; + mtx[2] = ttSHORT(comp)/16384.0f; comp+=2; + mtx[3] = ttSHORT(comp)/16384.0f; comp+=2; + } + + // Find transformation scales. + m = (float) STBTT_sqrt(mtx[0]*mtx[0] + mtx[1]*mtx[1]); + n = (float) STBTT_sqrt(mtx[2]*mtx[2] + mtx[3]*mtx[3]); + + // Get indexed glyph. + comp_num_verts = stbtt_GetGlyphShape(info, gidx, &comp_verts); + if (comp_num_verts > 0) { + // Transform vertices. + for (i = 0; i < comp_num_verts; ++i) { + stbtt_vertex* v = &comp_verts[i]; + stbtt_vertex_type x,y; + x=v->x; y=v->y; + v->x = (stbtt_vertex_type)(m * (mtx[0]*x + mtx[2]*y + mtx[4])); + v->y = (stbtt_vertex_type)(n * (mtx[1]*x + mtx[3]*y + mtx[5])); + x=v->cx; y=v->cy; + v->cx = (stbtt_vertex_type)(m * (mtx[0]*x + mtx[2]*y + mtx[4])); + v->cy = (stbtt_vertex_type)(n * (mtx[1]*x + mtx[3]*y + mtx[5])); + } + // Append vertices. + tmp = (stbtt_vertex*)STBTT_malloc((num_vertices+comp_num_verts)*sizeof(stbtt_vertex), info->userdata); + if (!tmp) { + if (vertices) STBTT_free(vertices, info->userdata); + if (comp_verts) STBTT_free(comp_verts, info->userdata); + return 0; + } + if (num_vertices > 0 && vertices) STBTT_memcpy(tmp, vertices, num_vertices*sizeof(stbtt_vertex)); + STBTT_memcpy(tmp+num_vertices, comp_verts, comp_num_verts*sizeof(stbtt_vertex)); + if (vertices) STBTT_free(vertices, info->userdata); + vertices = tmp; + STBTT_free(comp_verts, info->userdata); + num_vertices += comp_num_verts; + } + // More components ? + more = flags & (1<<5); + } + } else { + // numberOfCounters == 0, do nothing + } + + *pvertices = vertices; + return num_vertices; +} + +typedef struct +{ + int bounds; + int started; + float first_x, first_y; + float x, y; + stbtt_int32 min_x, max_x, min_y, max_y; + + stbtt_vertex *pvertices; + int num_vertices; +} stbtt__csctx; + +#define STBTT__CSCTX_INIT(bounds) {bounds,0, 0,0, 0,0, 0,0,0,0, NULL, 0} + +static void stbtt__track_vertex(stbtt__csctx *c, stbtt_int32 x, stbtt_int32 y) +{ + if (x > c->max_x || !c->started) c->max_x = x; + if (y > c->max_y || !c->started) c->max_y = y; + if (x < c->min_x || !c->started) c->min_x = x; + if (y < c->min_y || !c->started) c->min_y = y; + c->started = 1; +} + +static void stbtt__csctx_v(stbtt__csctx *c, stbtt_uint8 type, stbtt_int32 x, stbtt_int32 y, stbtt_int32 cx, stbtt_int32 cy, stbtt_int32 cx1, stbtt_int32 cy1) +{ + if (c->bounds) { + stbtt__track_vertex(c, x, y); + if (type == STBTT_vcubic) { + stbtt__track_vertex(c, cx, cy); + stbtt__track_vertex(c, cx1, cy1); + } + } else { + stbtt_setvertex(&c->pvertices[c->num_vertices], type, x, y, cx, cy); + c->pvertices[c->num_vertices].cx1 = (stbtt_int16) cx1; + c->pvertices[c->num_vertices].cy1 = (stbtt_int16) cy1; + } + c->num_vertices++; +} + +static void stbtt__csctx_close_shape(stbtt__csctx *ctx) +{ + if (ctx->first_x != ctx->x || ctx->first_y != ctx->y) + stbtt__csctx_v(ctx, STBTT_vline, (int)ctx->first_x, (int)ctx->first_y, 0, 0, 0, 0); +} + +static void stbtt__csctx_rmove_to(stbtt__csctx *ctx, float dx, float dy) +{ + stbtt__csctx_close_shape(ctx); + ctx->first_x = ctx->x = ctx->x + dx; + ctx->first_y = ctx->y = ctx->y + dy; + stbtt__csctx_v(ctx, STBTT_vmove, (int)ctx->x, (int)ctx->y, 0, 0, 0, 0); +} + +static void stbtt__csctx_rline_to(stbtt__csctx *ctx, float dx, float dy) +{ + ctx->x += dx; + ctx->y += dy; + stbtt__csctx_v(ctx, STBTT_vline, (int)ctx->x, (int)ctx->y, 0, 0, 0, 0); +} + +static void stbtt__csctx_rccurve_to(stbtt__csctx *ctx, float dx1, float dy1, float dx2, float dy2, float dx3, float dy3) +{ + float cx1 = ctx->x + dx1; + float cy1 = ctx->y + dy1; + float cx2 = cx1 + dx2; + float cy2 = cy1 + dy2; + ctx->x = cx2 + dx3; + ctx->y = cy2 + dy3; + stbtt__csctx_v(ctx, STBTT_vcubic, (int)ctx->x, (int)ctx->y, (int)cx1, (int)cy1, (int)cx2, (int)cy2); +} + +static stbtt__buf stbtt__get_subr(stbtt__buf idx, int n) +{ + int count = stbtt__cff_index_count(&idx); + int bias = 107; + if (count >= 33900) + bias = 32768; + else if (count >= 1240) + bias = 1131; + n += bias; + if (n < 0 || n >= count) + return stbtt__new_buf(NULL, 0); + return stbtt__cff_index_get(idx, n); +} + +static stbtt__buf stbtt__cid_get_glyph_subrs(const stbtt_fontinfo *info, int glyph_index) +{ + stbtt__buf fdselect = info->fdselect; + int nranges, start, end, v, fmt, fdselector = -1, i; + + stbtt__buf_seek(&fdselect, 0); + fmt = stbtt__buf_get8(&fdselect); + if (fmt == 0) { + // untested + stbtt__buf_skip(&fdselect, glyph_index); + fdselector = stbtt__buf_get8(&fdselect); + } else if (fmt == 3) { + nranges = stbtt__buf_get16(&fdselect); + start = stbtt__buf_get16(&fdselect); + for (i = 0; i < nranges; i++) { + v = stbtt__buf_get8(&fdselect); + end = stbtt__buf_get16(&fdselect); + if (glyph_index >= start && glyph_index < end) { + fdselector = v; + break; + } + start = end; + } + } + if (fdselector == -1) stbtt__new_buf(NULL, 0); + return stbtt__get_subrs(info->cff, stbtt__cff_index_get(info->fontdicts, fdselector)); +} + +static int stbtt__run_charstring(const stbtt_fontinfo *info, int glyph_index, stbtt__csctx *c) +{ + int in_header = 1, maskbits = 0, subr_stack_height = 0, sp = 0, v, i, b0; + int has_subrs = 0, clear_stack; + float s[48]; + stbtt__buf subr_stack[10], subrs = info->subrs, b; + float f; + +#define STBTT__CSERR(s) (0) + + // this currently ignores the initial width value, which isn't needed if we have hmtx + b = stbtt__cff_index_get(info->charstrings, glyph_index); + while (b.cursor < b.size) { + i = 0; + clear_stack = 1; + b0 = stbtt__buf_get8(&b); + switch (b0) { + // @TODO implement hinting + case 0x13: // hintmask + case 0x14: // cntrmask + if (in_header) + maskbits += (sp / 2); // implicit "vstem" + in_header = 0; + stbtt__buf_skip(&b, (maskbits + 7) / 8); + break; + + case 0x01: // hstem + case 0x03: // vstem + case 0x12: // hstemhm + case 0x17: // vstemhm + maskbits += (sp / 2); + break; + + case 0x15: // rmoveto + in_header = 0; + if (sp < 2) return STBTT__CSERR("rmoveto stack"); + stbtt__csctx_rmove_to(c, s[sp-2], s[sp-1]); + break; + case 0x04: // vmoveto + in_header = 0; + if (sp < 1) return STBTT__CSERR("vmoveto stack"); + stbtt__csctx_rmove_to(c, 0, s[sp-1]); + break; + case 0x16: // hmoveto + in_header = 0; + if (sp < 1) return STBTT__CSERR("hmoveto stack"); + stbtt__csctx_rmove_to(c, s[sp-1], 0); + break; + + case 0x05: // rlineto + if (sp < 2) return STBTT__CSERR("rlineto stack"); + for (; i + 1 < sp; i += 2) + stbtt__csctx_rline_to(c, s[i], s[i+1]); + break; + + // hlineto/vlineto and vhcurveto/hvcurveto alternate horizontal and vertical + // starting from a different place. + + case 0x07: // vlineto + if (sp < 1) return STBTT__CSERR("vlineto stack"); + goto vlineto; + case 0x06: // hlineto + if (sp < 1) return STBTT__CSERR("hlineto stack"); + for (;;) { + if (i >= sp) break; + stbtt__csctx_rline_to(c, s[i], 0); + i++; + vlineto: + if (i >= sp) break; + stbtt__csctx_rline_to(c, 0, s[i]); + i++; + } + break; + + case 0x1F: // hvcurveto + if (sp < 4) return STBTT__CSERR("hvcurveto stack"); + goto hvcurveto; + case 0x1E: // vhcurveto + if (sp < 4) return STBTT__CSERR("vhcurveto stack"); + for (;;) { + if (i + 3 >= sp) break; + stbtt__csctx_rccurve_to(c, 0, s[i], s[i+1], s[i+2], s[i+3], (sp - i == 5) ? s[i + 4] : 0.0f); + i += 4; + hvcurveto: + if (i + 3 >= sp) break; + stbtt__csctx_rccurve_to(c, s[i], 0, s[i+1], s[i+2], (sp - i == 5) ? s[i+4] : 0.0f, s[i+3]); + i += 4; + } + break; + + case 0x08: // rrcurveto + if (sp < 6) return STBTT__CSERR("rcurveline stack"); + for (; i + 5 < sp; i += 6) + stbtt__csctx_rccurve_to(c, s[i], s[i+1], s[i+2], s[i+3], s[i+4], s[i+5]); + break; + + case 0x18: // rcurveline + if (sp < 8) return STBTT__CSERR("rcurveline stack"); + for (; i + 5 < sp - 2; i += 6) + stbtt__csctx_rccurve_to(c, s[i], s[i+1], s[i+2], s[i+3], s[i+4], s[i+5]); + if (i + 1 >= sp) return STBTT__CSERR("rcurveline stack"); + stbtt__csctx_rline_to(c, s[i], s[i+1]); + break; + + case 0x19: // rlinecurve + if (sp < 8) return STBTT__CSERR("rlinecurve stack"); + for (; i + 1 < sp - 6; i += 2) + stbtt__csctx_rline_to(c, s[i], s[i+1]); + if (i + 5 >= sp) return STBTT__CSERR("rlinecurve stack"); + stbtt__csctx_rccurve_to(c, s[i], s[i+1], s[i+2], s[i+3], s[i+4], s[i+5]); + break; + + case 0x1A: // vvcurveto + case 0x1B: // hhcurveto + if (sp < 4) return STBTT__CSERR("(vv|hh)curveto stack"); + f = 0.0; + if (sp & 1) { f = s[i]; i++; } + for (; i + 3 < sp; i += 4) { + if (b0 == 0x1B) + stbtt__csctx_rccurve_to(c, s[i], f, s[i+1], s[i+2], s[i+3], 0.0); + else + stbtt__csctx_rccurve_to(c, f, s[i], s[i+1], s[i+2], 0.0, s[i+3]); + f = 0.0; + } + break; + + case 0x0A: // callsubr + if (!has_subrs) { + if (info->fdselect.size) + subrs = stbtt__cid_get_glyph_subrs(info, glyph_index); + has_subrs = 1; + } + // FALLTHROUGH + case 0x1D: // callgsubr + if (sp < 1) return STBTT__CSERR("call(g|)subr stack"); + v = (int) s[--sp]; + if (subr_stack_height >= 10) return STBTT__CSERR("recursion limit"); + subr_stack[subr_stack_height++] = b; + b = stbtt__get_subr(b0 == 0x0A ? subrs : info->gsubrs, v); + if (b.size == 0) return STBTT__CSERR("subr not found"); + b.cursor = 0; + clear_stack = 0; + break; + + case 0x0B: // return + if (subr_stack_height <= 0) return STBTT__CSERR("return outside subr"); + b = subr_stack[--subr_stack_height]; + clear_stack = 0; + break; + + case 0x0E: // endchar + stbtt__csctx_close_shape(c); + return 1; + + case 0x0C: { // two-byte escape + float dx1, dx2, dx3, dx4, dx5, dx6, dy1, dy2, dy3, dy4, dy5, dy6; + float dx, dy; + int b1 = stbtt__buf_get8(&b); + switch (b1) { + // @TODO These "flex" implementations ignore the flex-depth and resolution, + // and always draw beziers. + case 0x22: // hflex + if (sp < 7) return STBTT__CSERR("hflex stack"); + dx1 = s[0]; + dx2 = s[1]; + dy2 = s[2]; + dx3 = s[3]; + dx4 = s[4]; + dx5 = s[5]; + dx6 = s[6]; + stbtt__csctx_rccurve_to(c, dx1, 0, dx2, dy2, dx3, 0); + stbtt__csctx_rccurve_to(c, dx4, 0, dx5, -dy2, dx6, 0); + break; + + case 0x23: // flex + if (sp < 13) return STBTT__CSERR("flex stack"); + dx1 = s[0]; + dy1 = s[1]; + dx2 = s[2]; + dy2 = s[3]; + dx3 = s[4]; + dy3 = s[5]; + dx4 = s[6]; + dy4 = s[7]; + dx5 = s[8]; + dy5 = s[9]; + dx6 = s[10]; + dy6 = s[11]; + //fd is s[12] + stbtt__csctx_rccurve_to(c, dx1, dy1, dx2, dy2, dx3, dy3); + stbtt__csctx_rccurve_to(c, dx4, dy4, dx5, dy5, dx6, dy6); + break; + + case 0x24: // hflex1 + if (sp < 9) return STBTT__CSERR("hflex1 stack"); + dx1 = s[0]; + dy1 = s[1]; + dx2 = s[2]; + dy2 = s[3]; + dx3 = s[4]; + dx4 = s[5]; + dx5 = s[6]; + dy5 = s[7]; + dx6 = s[8]; + stbtt__csctx_rccurve_to(c, dx1, dy1, dx2, dy2, dx3, 0); + stbtt__csctx_rccurve_to(c, dx4, 0, dx5, dy5, dx6, -(dy1+dy2+dy5)); + break; + + case 0x25: // flex1 + if (sp < 11) return STBTT__CSERR("flex1 stack"); + dx1 = s[0]; + dy1 = s[1]; + dx2 = s[2]; + dy2 = s[3]; + dx3 = s[4]; + dy3 = s[5]; + dx4 = s[6]; + dy4 = s[7]; + dx5 = s[8]; + dy5 = s[9]; + dx6 = dy6 = s[10]; + dx = dx1+dx2+dx3+dx4+dx5; + dy = dy1+dy2+dy3+dy4+dy5; + if (STBTT_fabs(dx) > STBTT_fabs(dy)) + dy6 = -dy; + else + dx6 = -dx; + stbtt__csctx_rccurve_to(c, dx1, dy1, dx2, dy2, dx3, dy3); + stbtt__csctx_rccurve_to(c, dx4, dy4, dx5, dy5, dx6, dy6); + break; + + default: + return STBTT__CSERR("unimplemented"); + } + } break; + + default: + if (b0 != 255 && b0 != 28 && b0 < 32) + return STBTT__CSERR("reserved operator"); + + // push immediate + if (b0 == 255) { + f = (float)(stbtt_int32)stbtt__buf_get32(&b) / 0x10000; + } else { + stbtt__buf_skip(&b, -1); + f = (float)(stbtt_int16)stbtt__cff_int(&b); + } + if (sp >= 48) return STBTT__CSERR("push stack overflow"); + s[sp++] = f; + clear_stack = 0; + break; + } + if (clear_stack) sp = 0; + } + return STBTT__CSERR("no endchar"); + +#undef STBTT__CSERR +} + +static int stbtt__GetGlyphShapeT2(const stbtt_fontinfo *info, int glyph_index, stbtt_vertex **pvertices) +{ + // runs the charstring twice, once to count and once to output (to avoid realloc) + stbtt__csctx count_ctx = STBTT__CSCTX_INIT(1); + stbtt__csctx output_ctx = STBTT__CSCTX_INIT(0); + if (stbtt__run_charstring(info, glyph_index, &count_ctx)) { + *pvertices = (stbtt_vertex*)STBTT_malloc(count_ctx.num_vertices*sizeof(stbtt_vertex), info->userdata); + output_ctx.pvertices = *pvertices; + if (stbtt__run_charstring(info, glyph_index, &output_ctx)) { + STBTT_assert(output_ctx.num_vertices == count_ctx.num_vertices); + return output_ctx.num_vertices; + } + } + *pvertices = NULL; + return 0; +} + +static int stbtt__GetGlyphInfoT2(const stbtt_fontinfo *info, int glyph_index, int *x0, int *y0, int *x1, int *y1) +{ + stbtt__csctx c = STBTT__CSCTX_INIT(1); + int r = stbtt__run_charstring(info, glyph_index, &c); + if (x0) *x0 = r ? c.min_x : 0; + if (y0) *y0 = r ? c.min_y : 0; + if (x1) *x1 = r ? c.max_x : 0; + if (y1) *y1 = r ? c.max_y : 0; + return r ? c.num_vertices : 0; +} + +STBTT_DEF int stbtt_GetGlyphShape(const stbtt_fontinfo *info, int glyph_index, stbtt_vertex **pvertices) +{ + if (!info->cff.size) + return stbtt__GetGlyphShapeTT(info, glyph_index, pvertices); + else + return stbtt__GetGlyphShapeT2(info, glyph_index, pvertices); +} + +STBTT_DEF void stbtt_GetGlyphHMetrics(const stbtt_fontinfo *info, int glyph_index, int *advanceWidth, int *leftSideBearing) +{ + stbtt_uint16 numOfLongHorMetrics = ttUSHORT(info->data+info->hhea + 34); + if (glyph_index < numOfLongHorMetrics) { + if (advanceWidth) *advanceWidth = ttSHORT(info->data + info->hmtx + 4*glyph_index); + if (leftSideBearing) *leftSideBearing = ttSHORT(info->data + info->hmtx + 4*glyph_index + 2); + } else { + if (advanceWidth) *advanceWidth = ttSHORT(info->data + info->hmtx + 4*(numOfLongHorMetrics-1)); + if (leftSideBearing) *leftSideBearing = ttSHORT(info->data + info->hmtx + 4*numOfLongHorMetrics + 2*(glyph_index - numOfLongHorMetrics)); + } +} + +STBTT_DEF int stbtt_GetKerningTableLength(const stbtt_fontinfo *info) +{ + stbtt_uint8 *data = info->data + info->kern; + + // we only look at the first table. it must be 'horizontal' and format 0. + if (!info->kern) + return 0; + if (ttUSHORT(data+2) < 1) // number of tables, need at least 1 + return 0; + if (ttUSHORT(data+8) != 1) // horizontal flag must be set in format + return 0; + + return ttUSHORT(data+10); +} + +STBTT_DEF int stbtt_GetKerningTable(const stbtt_fontinfo *info, stbtt_kerningentry* table, int table_length) +{ + stbtt_uint8 *data = info->data + info->kern; + int k, length; + + // we only look at the first table. it must be 'horizontal' and format 0. + if (!info->kern) + return 0; + if (ttUSHORT(data+2) < 1) // number of tables, need at least 1 + return 0; + if (ttUSHORT(data+8) != 1) // horizontal flag must be set in format + return 0; + + length = ttUSHORT(data+10); + if (table_length < length) + length = table_length; + + for (k = 0; k < length; k++) + { + table[k].glyph1 = ttUSHORT(data+18+(k*6)); + table[k].glyph2 = ttUSHORT(data+20+(k*6)); + table[k].advance = ttSHORT(data+22+(k*6)); + } + + return length; +} + +static int stbtt__GetGlyphKernInfoAdvance(const stbtt_fontinfo *info, int glyph1, int glyph2) +{ + stbtt_uint8 *data = info->data + info->kern; + stbtt_uint32 needle, straw; + int l, r, m; + + // we only look at the first table. it must be 'horizontal' and format 0. + if (!info->kern) + return 0; + if (ttUSHORT(data+2) < 1) // number of tables, need at least 1 + return 0; + if (ttUSHORT(data+8) != 1) // horizontal flag must be set in format + return 0; + + l = 0; + r = ttUSHORT(data+10) - 1; + needle = glyph1 << 16 | glyph2; + while (l <= r) { + m = (l + r) >> 1; + straw = ttULONG(data+18+(m*6)); // note: unaligned read + if (needle < straw) + r = m - 1; + else if (needle > straw) + l = m + 1; + else + return ttSHORT(data+22+(m*6)); + } + return 0; +} + +static stbtt_int32 stbtt__GetCoverageIndex(stbtt_uint8 *coverageTable, int glyph) +{ + stbtt_uint16 coverageFormat = ttUSHORT(coverageTable); + switch (coverageFormat) { + case 1: { + stbtt_uint16 glyphCount = ttUSHORT(coverageTable + 2); + + // Binary search. + stbtt_int32 l=0, r=glyphCount-1, m; + int straw, needle=glyph; + while (l <= r) { + stbtt_uint8 *glyphArray = coverageTable + 4; + stbtt_uint16 glyphID; + m = (l + r) >> 1; + glyphID = ttUSHORT(glyphArray + 2 * m); + straw = glyphID; + if (needle < straw) + r = m - 1; + else if (needle > straw) + l = m + 1; + else { + return m; + } + } + break; + } + + case 2: { + stbtt_uint16 rangeCount = ttUSHORT(coverageTable + 2); + stbtt_uint8 *rangeArray = coverageTable + 4; + + // Binary search. + stbtt_int32 l=0, r=rangeCount-1, m; + int strawStart, strawEnd, needle=glyph; + while (l <= r) { + stbtt_uint8 *rangeRecord; + m = (l + r) >> 1; + rangeRecord = rangeArray + 6 * m; + strawStart = ttUSHORT(rangeRecord); + strawEnd = ttUSHORT(rangeRecord + 2); + if (needle < strawStart) + r = m - 1; + else if (needle > strawEnd) + l = m + 1; + else { + stbtt_uint16 startCoverageIndex = ttUSHORT(rangeRecord + 4); + return startCoverageIndex + glyph - strawStart; + } + } + break; + } + + default: return -1; // unsupported + } + + return -1; +} + +static stbtt_int32 stbtt__GetGlyphClass(stbtt_uint8 *classDefTable, int glyph) +{ + stbtt_uint16 classDefFormat = ttUSHORT(classDefTable); + switch (classDefFormat) + { + case 1: { + stbtt_uint16 startGlyphID = ttUSHORT(classDefTable + 2); + stbtt_uint16 glyphCount = ttUSHORT(classDefTable + 4); + stbtt_uint8 *classDef1ValueArray = classDefTable + 6; + + if (glyph >= startGlyphID && glyph < startGlyphID + glyphCount) + return (stbtt_int32)ttUSHORT(classDef1ValueArray + 2 * (glyph - startGlyphID)); + break; + } + + case 2: { + stbtt_uint16 classRangeCount = ttUSHORT(classDefTable + 2); + stbtt_uint8 *classRangeRecords = classDefTable + 4; + + // Binary search. + stbtt_int32 l=0, r=classRangeCount-1, m; + int strawStart, strawEnd, needle=glyph; + while (l <= r) { + stbtt_uint8 *classRangeRecord; + m = (l + r) >> 1; + classRangeRecord = classRangeRecords + 6 * m; + strawStart = ttUSHORT(classRangeRecord); + strawEnd = ttUSHORT(classRangeRecord + 2); + if (needle < strawStart) + r = m - 1; + else if (needle > strawEnd) + l = m + 1; + else + return (stbtt_int32)ttUSHORT(classRangeRecord + 4); + } + break; + } + + default: + return -1; // Unsupported definition type, return an error. + } + + // "All glyphs not assigned to a class fall into class 0". (OpenType spec) + return 0; +} + +// Define to STBTT_assert(x) if you want to break on unimplemented formats. +#define STBTT_GPOS_TODO_assert(x) + +static stbtt_int32 stbtt__GetGlyphGPOSInfoAdvance(const stbtt_fontinfo *info, int glyph1, int glyph2) +{ + stbtt_uint16 lookupListOffset; + stbtt_uint8 *lookupList; + stbtt_uint16 lookupCount; + stbtt_uint8 *data; + stbtt_int32 i, sti; + + if (!info->gpos) return 0; + + data = info->data + info->gpos; + + if (ttUSHORT(data+0) != 1) return 0; // Major version 1 + if (ttUSHORT(data+2) != 0) return 0; // Minor version 0 + + lookupListOffset = ttUSHORT(data+8); + lookupList = data + lookupListOffset; + lookupCount = ttUSHORT(lookupList); + + for (i=0; i= pairSetCount) return 0; + + needle=glyph2; + r=pairValueCount-1; + l=0; + + // Binary search. + while (l <= r) { + stbtt_uint16 secondGlyph; + stbtt_uint8 *pairValue; + m = (l + r) >> 1; + pairValue = pairValueArray + (2 + valueRecordPairSizeInBytes) * m; + secondGlyph = ttUSHORT(pairValue); + straw = secondGlyph; + if (needle < straw) + r = m - 1; + else if (needle > straw) + l = m + 1; + else { + stbtt_int16 xAdvance = ttSHORT(pairValue + 2); + return xAdvance; + } + } + } else + return 0; + break; + } + + case 2: { + stbtt_uint16 valueFormat1 = ttUSHORT(table + 4); + stbtt_uint16 valueFormat2 = ttUSHORT(table + 6); + if (valueFormat1 == 4 && valueFormat2 == 0) { // Support more formats? + stbtt_uint16 classDef1Offset = ttUSHORT(table + 8); + stbtt_uint16 classDef2Offset = ttUSHORT(table + 10); + int glyph1class = stbtt__GetGlyphClass(table + classDef1Offset, glyph1); + int glyph2class = stbtt__GetGlyphClass(table + classDef2Offset, glyph2); + + stbtt_uint16 class1Count = ttUSHORT(table + 12); + stbtt_uint16 class2Count = ttUSHORT(table + 14); + stbtt_uint8 *class1Records, *class2Records; + stbtt_int16 xAdvance; + + if (glyph1class < 0 || glyph1class >= class1Count) return 0; // malformed + if (glyph2class < 0 || glyph2class >= class2Count) return 0; // malformed + + class1Records = table + 16; + class2Records = class1Records + 2 * (glyph1class * class2Count); + xAdvance = ttSHORT(class2Records + 2 * glyph2class); + return xAdvance; + } else + return 0; + break; + } + + default: + return 0; // Unsupported position format + } + } + } + + return 0; +} + +STBTT_DEF int stbtt_GetGlyphKernAdvance(const stbtt_fontinfo *info, int g1, int g2) +{ + int xAdvance = 0; + + if (info->gpos) + xAdvance += stbtt__GetGlyphGPOSInfoAdvance(info, g1, g2); + else if (info->kern) + xAdvance += stbtt__GetGlyphKernInfoAdvance(info, g1, g2); + + return xAdvance; +} + +STBTT_DEF int stbtt_GetCodepointKernAdvance(const stbtt_fontinfo *info, int ch1, int ch2) +{ + if (!info->kern && !info->gpos) // if no kerning table, don't waste time looking up both codepoint->glyphs + return 0; + return stbtt_GetGlyphKernAdvance(info, stbtt_FindGlyphIndex(info,ch1), stbtt_FindGlyphIndex(info,ch2)); +} + +STBTT_DEF void stbtt_GetCodepointHMetrics(const stbtt_fontinfo *info, int codepoint, int *advanceWidth, int *leftSideBearing) +{ + stbtt_GetGlyphHMetrics(info, stbtt_FindGlyphIndex(info,codepoint), advanceWidth, leftSideBearing); +} + +STBTT_DEF void stbtt_GetFontVMetrics(const stbtt_fontinfo *info, int *ascent, int *descent, int *lineGap) +{ + if (ascent ) *ascent = ttSHORT(info->data+info->hhea + 4); + if (descent) *descent = ttSHORT(info->data+info->hhea + 6); + if (lineGap) *lineGap = ttSHORT(info->data+info->hhea + 8); +} + +STBTT_DEF int stbtt_GetFontVMetricsOS2(const stbtt_fontinfo *info, int *typoAscent, int *typoDescent, int *typoLineGap) +{ + int tab = stbtt__find_table(info->data, info->fontstart, "OS/2"); + if (!tab) + return 0; + if (typoAscent ) *typoAscent = ttSHORT(info->data+tab + 68); + if (typoDescent) *typoDescent = ttSHORT(info->data+tab + 70); + if (typoLineGap) *typoLineGap = ttSHORT(info->data+tab + 72); + return 1; +} + +STBTT_DEF void stbtt_GetFontBoundingBox(const stbtt_fontinfo *info, int *x0, int *y0, int *x1, int *y1) +{ + *x0 = ttSHORT(info->data + info->head + 36); + *y0 = ttSHORT(info->data + info->head + 38); + *x1 = ttSHORT(info->data + info->head + 40); + *y1 = ttSHORT(info->data + info->head + 42); +} + +STBTT_DEF float stbtt_ScaleForPixelHeight(const stbtt_fontinfo *info, float height) +{ + int fheight = ttSHORT(info->data + info->hhea + 4) - ttSHORT(info->data + info->hhea + 6); + return (float) height / fheight; +} + +STBTT_DEF float stbtt_ScaleForMappingEmToPixels(const stbtt_fontinfo *info, float pixels) +{ + int unitsPerEm = ttUSHORT(info->data + info->head + 18); + return pixels / unitsPerEm; +} + +STBTT_DEF void stbtt_FreeShape(const stbtt_fontinfo *info, stbtt_vertex *v) +{ + STBTT_free(v, info->userdata); +} + +STBTT_DEF stbtt_uint8 *stbtt_FindSVGDoc(const stbtt_fontinfo *info, int gl) +{ + int i; + stbtt_uint8 *data = info->data; + stbtt_uint8 *svg_doc_list = data + stbtt__get_svg((stbtt_fontinfo *) info); + + int numEntries = ttUSHORT(svg_doc_list); + stbtt_uint8 *svg_docs = svg_doc_list + 2; + + for(i=0; i= ttUSHORT(svg_doc)) && (gl <= ttUSHORT(svg_doc + 2))) + return svg_doc; + } + return 0; +} + +STBTT_DEF int stbtt_GetGlyphSVG(const stbtt_fontinfo *info, int gl, const char **svg) +{ + stbtt_uint8 *data = info->data; + stbtt_uint8 *svg_doc; + + if (info->svg == 0) + return 0; + + svg_doc = stbtt_FindSVGDoc(info, gl); + if (svg_doc != NULL) { + *svg = (char *) data + info->svg + ttULONG(svg_doc + 4); + return ttULONG(svg_doc + 8); + } else { + return 0; + } +} + +STBTT_DEF int stbtt_GetCodepointSVG(const stbtt_fontinfo *info, int unicode_codepoint, const char **svg) +{ + return stbtt_GetGlyphSVG(info, stbtt_FindGlyphIndex(info, unicode_codepoint), svg); +} + +////////////////////////////////////////////////////////////////////////////// +// +// antialiasing software rasterizer +// + +STBTT_DEF void stbtt_GetGlyphBitmapBoxSubpixel(const stbtt_fontinfo *font, int glyph, float scale_x, float scale_y,float shift_x, float shift_y, int *ix0, int *iy0, int *ix1, int *iy1) +{ + int x0=0,y0=0,x1,y1; // =0 suppresses compiler warning + if (!stbtt_GetGlyphBox(font, glyph, &x0,&y0,&x1,&y1)) { + // e.g. space character + if (ix0) *ix0 = 0; + if (iy0) *iy0 = 0; + if (ix1) *ix1 = 0; + if (iy1) *iy1 = 0; + } else { + // move to integral bboxes (treating pixels as little squares, what pixels get touched)? + if (ix0) *ix0 = STBTT_ifloor( x0 * scale_x + shift_x); + if (iy0) *iy0 = STBTT_ifloor(-y1 * scale_y + shift_y); + if (ix1) *ix1 = STBTT_iceil ( x1 * scale_x + shift_x); + if (iy1) *iy1 = STBTT_iceil (-y0 * scale_y + shift_y); + } +} + +STBTT_DEF void stbtt_GetGlyphBitmapBox(const stbtt_fontinfo *font, int glyph, float scale_x, float scale_y, int *ix0, int *iy0, int *ix1, int *iy1) +{ + stbtt_GetGlyphBitmapBoxSubpixel(font, glyph, scale_x, scale_y,0.0f,0.0f, ix0, iy0, ix1, iy1); +} + +STBTT_DEF void stbtt_GetCodepointBitmapBoxSubpixel(const stbtt_fontinfo *font, int codepoint, float scale_x, float scale_y, float shift_x, float shift_y, int *ix0, int *iy0, int *ix1, int *iy1) +{ + stbtt_GetGlyphBitmapBoxSubpixel(font, stbtt_FindGlyphIndex(font,codepoint), scale_x, scale_y,shift_x,shift_y, ix0,iy0,ix1,iy1); +} + +STBTT_DEF void stbtt_GetCodepointBitmapBox(const stbtt_fontinfo *font, int codepoint, float scale_x, float scale_y, int *ix0, int *iy0, int *ix1, int *iy1) +{ + stbtt_GetCodepointBitmapBoxSubpixel(font, codepoint, scale_x, scale_y,0.0f,0.0f, ix0,iy0,ix1,iy1); +} + +////////////////////////////////////////////////////////////////////////////// +// +// Rasterizer + +typedef struct stbtt__hheap_chunk +{ + struct stbtt__hheap_chunk *next; +} stbtt__hheap_chunk; + +typedef struct stbtt__hheap +{ + struct stbtt__hheap_chunk *head; + void *first_free; + int num_remaining_in_head_chunk; +} stbtt__hheap; + +static void *stbtt__hheap_alloc(stbtt__hheap *hh, size_t size, void *userdata) +{ + if (hh->first_free) { + void *p = hh->first_free; + hh->first_free = * (void **) p; + return p; + } else { + if (hh->num_remaining_in_head_chunk == 0) { + int count = (size < 32 ? 2000 : size < 128 ? 800 : 100); + stbtt__hheap_chunk *c = (stbtt__hheap_chunk *) STBTT_malloc(sizeof(stbtt__hheap_chunk) + size * count, userdata); + if (c == NULL) + return NULL; + c->next = hh->head; + hh->head = c; + hh->num_remaining_in_head_chunk = count; + } + --hh->num_remaining_in_head_chunk; + return (char *) (hh->head) + sizeof(stbtt__hheap_chunk) + size * hh->num_remaining_in_head_chunk; + } +} + +static void stbtt__hheap_free(stbtt__hheap *hh, void *p) +{ + *(void **) p = hh->first_free; + hh->first_free = p; +} + +static void stbtt__hheap_cleanup(stbtt__hheap *hh, void *userdata) +{ + stbtt__hheap_chunk *c = hh->head; + while (c) { + stbtt__hheap_chunk *n = c->next; + STBTT_free(c, userdata); + c = n; + } +} + +typedef struct stbtt__edge { + float x0,y0, x1,y1; + int invert; +} stbtt__edge; + + +typedef struct stbtt__active_edge +{ + struct stbtt__active_edge *next; + #if STBTT_RASTERIZER_VERSION==1 + int x,dx; + float ey; + int direction; + #elif STBTT_RASTERIZER_VERSION==2 + float fx,fdx,fdy; + float direction; + float sy; + float ey; + #else + #error "Unrecognized value of STBTT_RASTERIZER_VERSION" + #endif +} stbtt__active_edge; + +#if STBTT_RASTERIZER_VERSION == 1 +#define STBTT_FIXSHIFT 10 +#define STBTT_FIX (1 << STBTT_FIXSHIFT) +#define STBTT_FIXMASK (STBTT_FIX-1) + +static stbtt__active_edge *stbtt__new_active(stbtt__hheap *hh, stbtt__edge *e, int off_x, float start_point, void *userdata) +{ + stbtt__active_edge *z = (stbtt__active_edge *) stbtt__hheap_alloc(hh, sizeof(*z), userdata); + float dxdy = (e->x1 - e->x0) / (e->y1 - e->y0); + STBTT_assert(z != NULL); + if (!z) return z; + + // round dx down to avoid overshooting + if (dxdy < 0) + z->dx = -STBTT_ifloor(STBTT_FIX * -dxdy); + else + z->dx = STBTT_ifloor(STBTT_FIX * dxdy); + + z->x = STBTT_ifloor(STBTT_FIX * e->x0 + z->dx * (start_point - e->y0)); // use z->dx so when we offset later it's by the same amount + z->x -= off_x * STBTT_FIX; + + z->ey = e->y1; + z->next = 0; + z->direction = e->invert ? 1 : -1; + return z; +} +#elif STBTT_RASTERIZER_VERSION == 2 +static stbtt__active_edge *stbtt__new_active(stbtt__hheap *hh, stbtt__edge *e, int off_x, float start_point, void *userdata) +{ + stbtt__active_edge *z = (stbtt__active_edge *) stbtt__hheap_alloc(hh, sizeof(*z), userdata); + float dxdy = (e->x1 - e->x0) / (e->y1 - e->y0); + STBTT_assert(z != NULL); + //STBTT_assert(e->y0 <= start_point); + if (!z) return z; + z->fdx = dxdy; + z->fdy = dxdy != 0.0f ? (1.0f/dxdy) : 0.0f; + z->fx = e->x0 + dxdy * (start_point - e->y0); + z->fx -= off_x; + z->direction = e->invert ? 1.0f : -1.0f; + z->sy = e->y0; + z->ey = e->y1; + z->next = 0; + return z; +} +#else +#error "Unrecognized value of STBTT_RASTERIZER_VERSION" +#endif + +#if STBTT_RASTERIZER_VERSION == 1 +// note: this routine clips fills that extend off the edges... ideally this +// wouldn't happen, but it could happen if the truetype glyph bounding boxes +// are wrong, or if the user supplies a too-small bitmap +static void stbtt__fill_active_edges(unsigned char *scanline, int len, stbtt__active_edge *e, int max_weight) +{ + // non-zero winding fill + int x0=0, w=0; + + while (e) { + if (w == 0) { + // if we're currently at zero, we need to record the edge start point + x0 = e->x; w += e->direction; + } else { + int x1 = e->x; w += e->direction; + // if we went to zero, we need to draw + if (w == 0) { + int i = x0 >> STBTT_FIXSHIFT; + int j = x1 >> STBTT_FIXSHIFT; + + if (i < len && j >= 0) { + if (i == j) { + // x0,x1 are the same pixel, so compute combined coverage + scanline[i] = scanline[i] + (stbtt_uint8) ((x1 - x0) * max_weight >> STBTT_FIXSHIFT); + } else { + if (i >= 0) // add antialiasing for x0 + scanline[i] = scanline[i] + (stbtt_uint8) (((STBTT_FIX - (x0 & STBTT_FIXMASK)) * max_weight) >> STBTT_FIXSHIFT); + else + i = -1; // clip + + if (j < len) // add antialiasing for x1 + scanline[j] = scanline[j] + (stbtt_uint8) (((x1 & STBTT_FIXMASK) * max_weight) >> STBTT_FIXSHIFT); + else + j = len; // clip + + for (++i; i < j; ++i) // fill pixels between x0 and x1 + scanline[i] = scanline[i] + (stbtt_uint8) max_weight; + } + } + } + } + + e = e->next; + } +} + +static void stbtt__rasterize_sorted_edges(stbtt__bitmap *result, stbtt__edge *e, int n, int vsubsample, int off_x, int off_y, void *userdata) +{ + stbtt__hheap hh = { 0, 0, 0 }; + stbtt__active_edge *active = NULL; + int y,j=0; + int max_weight = (255 / vsubsample); // weight per vertical scanline + int s; // vertical subsample index + unsigned char scanline_data[512], *scanline; + + if (result->w > 512) + scanline = (unsigned char *) STBTT_malloc(result->w, userdata); + else + scanline = scanline_data; + + y = off_y * vsubsample; + e[n].y0 = (off_y + result->h) * (float) vsubsample + 1; + + while (j < result->h) { + STBTT_memset(scanline, 0, result->w); + for (s=0; s < vsubsample; ++s) { + // find center of pixel for this scanline + float scan_y = y + 0.5f; + stbtt__active_edge **step = &active; + + // update all active edges; + // remove all active edges that terminate before the center of this scanline + while (*step) { + stbtt__active_edge * z = *step; + if (z->ey <= scan_y) { + *step = z->next; // delete from list + STBTT_assert(z->direction); + z->direction = 0; + stbtt__hheap_free(&hh, z); + } else { + z->x += z->dx; // advance to position for current scanline + step = &((*step)->next); // advance through list + } + } + + // resort the list if needed + for(;;) { + int changed=0; + step = &active; + while (*step && (*step)->next) { + if ((*step)->x > (*step)->next->x) { + stbtt__active_edge *t = *step; + stbtt__active_edge *q = t->next; + + t->next = q->next; + q->next = t; + *step = q; + changed = 1; + } + step = &(*step)->next; + } + if (!changed) break; + } + + // insert all edges that start before the center of this scanline -- omit ones that also end on this scanline + while (e->y0 <= scan_y) { + if (e->y1 > scan_y) { + stbtt__active_edge *z = stbtt__new_active(&hh, e, off_x, scan_y, userdata); + if (z != NULL) { + // find insertion point + if (active == NULL) + active = z; + else if (z->x < active->x) { + // insert at front + z->next = active; + active = z; + } else { + // find thing to insert AFTER + stbtt__active_edge *p = active; + while (p->next && p->next->x < z->x) + p = p->next; + // at this point, p->next->x is NOT < z->x + z->next = p->next; + p->next = z; + } + } + } + ++e; + } + + // now process all active edges in XOR fashion + if (active) + stbtt__fill_active_edges(scanline, result->w, active, max_weight); + + ++y; + } + STBTT_memcpy(result->pixels + j * result->stride, scanline, result->w); + ++j; + } + + stbtt__hheap_cleanup(&hh, userdata); + + if (scanline != scanline_data) + STBTT_free(scanline, userdata); +} + +#elif STBTT_RASTERIZER_VERSION == 2 + +// the edge passed in here does not cross the vertical line at x or the vertical line at x+1 +// (i.e. it has already been clipped to those) +static void stbtt__handle_clipped_edge(float *scanline, int x, stbtt__active_edge *e, float x0, float y0, float x1, float y1) +{ + if (y0 == y1) return; + STBTT_assert(y0 < y1); + STBTT_assert(e->sy <= e->ey); + if (y0 > e->ey) return; + if (y1 < e->sy) return; + if (y0 < e->sy) { + x0 += (x1-x0) * (e->sy - y0) / (y1-y0); + y0 = e->sy; + } + if (y1 > e->ey) { + x1 += (x1-x0) * (e->ey - y1) / (y1-y0); + y1 = e->ey; + } + + if (x0 == x) + STBTT_assert(x1 <= x+1); + else if (x0 == x+1) + STBTT_assert(x1 >= x); + else if (x0 <= x) + STBTT_assert(x1 <= x); + else if (x0 >= x+1) + STBTT_assert(x1 >= x+1); + else + STBTT_assert(x1 >= x && x1 <= x+1); + + if (x0 <= x && x1 <= x) + scanline[x] += e->direction * (y1-y0); + else if (x0 >= x+1 && x1 >= x+1) + ; + else { + STBTT_assert(x0 >= x && x0 <= x+1 && x1 >= x && x1 <= x+1); + scanline[x] += e->direction * (y1-y0) * (1-((x0-x)+(x1-x))/2); // coverage = 1 - average x position + } +} + +static float stbtt__sized_trapezoid_area(float height, float top_width, float bottom_width) +{ + STBTT_assert(top_width >= 0); + STBTT_assert(bottom_width >= 0); + return (top_width + bottom_width) / 2.0f * height; +} + +static float stbtt__position_trapezoid_area(float height, float tx0, float tx1, float bx0, float bx1) +{ + return stbtt__sized_trapezoid_area(height, tx1 - tx0, bx1 - bx0); +} + +static float stbtt__sized_triangle_area(float height, float width) +{ + return height * width / 2; +} + +static void stbtt__fill_active_edges_new(float *scanline, float *scanline_fill, int len, stbtt__active_edge *e, float y_top) +{ + float y_bottom = y_top+1; + + while (e) { + // brute force every pixel + + // compute intersection points with top & bottom + STBTT_assert(e->ey >= y_top); + + if (e->fdx == 0) { + float x0 = e->fx; + if (x0 < len) { + if (x0 >= 0) { + stbtt__handle_clipped_edge(scanline,(int) x0,e, x0,y_top, x0,y_bottom); + stbtt__handle_clipped_edge(scanline_fill-1,(int) x0+1,e, x0,y_top, x0,y_bottom); + } else { + stbtt__handle_clipped_edge(scanline_fill-1,0,e, x0,y_top, x0,y_bottom); + } + } + } else { + float x0 = e->fx; + float dx = e->fdx; + float xb = x0 + dx; + float x_top, x_bottom; + float sy0,sy1; + float dy = e->fdy; + STBTT_assert(e->sy <= y_bottom && e->ey >= y_top); + + // compute endpoints of line segment clipped to this scanline (if the + // line segment starts on this scanline. x0 is the intersection of the + // line with y_top, but that may be off the line segment. + if (e->sy > y_top) { + x_top = x0 + dx * (e->sy - y_top); + sy0 = e->sy; + } else { + x_top = x0; + sy0 = y_top; + } + if (e->ey < y_bottom) { + x_bottom = x0 + dx * (e->ey - y_top); + sy1 = e->ey; + } else { + x_bottom = xb; + sy1 = y_bottom; + } + + if (x_top >= 0 && x_bottom >= 0 && x_top < len && x_bottom < len) { + // from here on, we don't have to range check x values + + if ((int) x_top == (int) x_bottom) { + float height; + // simple case, only spans one pixel + int x = (int) x_top; + height = (sy1 - sy0) * e->direction; + STBTT_assert(x >= 0 && x < len); + scanline[x] += stbtt__position_trapezoid_area(height, x_top, x+1.0f, x_bottom, x+1.0f); + scanline_fill[x] += height; // everything right of this pixel is filled + } else { + int x,x1,x2; + float y_crossing, y_final, step, sign, area; + // covers 2+ pixels + if (x_top > x_bottom) { + // flip scanline vertically; signed area is the same + float t; + sy0 = y_bottom - (sy0 - y_top); + sy1 = y_bottom - (sy1 - y_top); + t = sy0, sy0 = sy1, sy1 = t; + t = x_bottom, x_bottom = x_top, x_top = t; + dx = -dx; + dy = -dy; + t = x0, x0 = xb, xb = t; + } + STBTT_assert(dy >= 0); + STBTT_assert(dx >= 0); + + x1 = (int) x_top; + x2 = (int) x_bottom; + // compute intersection with y axis at x1+1 + y_crossing = y_top + dy * (x1+1 - x0); + + // compute intersection with y axis at x2 + y_final = y_top + dy * (x2 - x0); + + // x1 x_top x2 x_bottom + // y_top +------|-----+------------+------------+--------|---+------------+ + // | | | | | | + // | | | | | | + // sy0 | Txxxxx|............|............|............|............| + // y_crossing | *xxxxx.......|............|............|............| + // | | xxxxx..|............|............|............| + // | | /- xx*xxxx........|............|............| + // | | dy < | xxxxxx..|............|............| + // y_final | | \- | xx*xxx.........|............| + // sy1 | | | | xxxxxB...|............| + // | | | | | | + // | | | | | | + // y_bottom +------------+------------+------------+------------+------------+ + // + // goal is to measure the area covered by '.' in each pixel + + // if x2 is right at the right edge of x1, y_crossing can blow up, github #1057 + // @TODO: maybe test against sy1 rather than y_bottom? + if (y_crossing > y_bottom) + y_crossing = y_bottom; + + sign = e->direction; + + // area of the rectangle covered from sy0..y_crossing + area = sign * (y_crossing-sy0); + + // area of the triangle (x_top,sy0), (x1+1,sy0), (x1+1,y_crossing) + scanline[x1] += stbtt__sized_triangle_area(area, x1+1 - x_top); + + // check if final y_crossing is blown up; no test case for this + if (y_final > y_bottom) { + y_final = y_bottom; + dy = (y_final - y_crossing ) / (x2 - (x1+1)); // if denom=0, y_final = y_crossing, so y_final <= y_bottom + } + + // in second pixel, area covered by line segment found in first pixel + // is always a rectangle 1 wide * the height of that line segment; this + // is exactly what the variable 'area' stores. it also gets a contribution + // from the line segment within it. the THIRD pixel will get the first + // pixel's rectangle contribution, the second pixel's rectangle contribution, + // and its own contribution. the 'own contribution' is the same in every pixel except + // the leftmost and rightmost, a trapezoid that slides down in each pixel. + // the second pixel's contribution to the third pixel will be the + // rectangle 1 wide times the height change in the second pixel, which is dy. + + step = sign * dy * 1; // dy is dy/dx, change in y for every 1 change in x, + // which multiplied by 1-pixel-width is how much pixel area changes for each step in x + // so the area advances by 'step' every time + + for (x = x1+1; x < x2; ++x) { + scanline[x] += area + step/2; // area of trapezoid is 1*step/2 + area += step; + } + STBTT_assert(STBTT_fabs(area) <= 1.01f); // accumulated error from area += step unless we round step down + STBTT_assert(sy1 > y_final-0.01f); + + // area covered in the last pixel is the rectangle from all the pixels to the left, + // plus the trapezoid filled by the line segment in this pixel all the way to the right edge + scanline[x2] += area + sign * stbtt__position_trapezoid_area(sy1-y_final, (float) x2, x2+1.0f, x_bottom, x2+1.0f); + + // the rest of the line is filled based on the total height of the line segment in this pixel + scanline_fill[x2] += sign * (sy1-sy0); + } + } else { + // if edge goes outside of box we're drawing, we require + // clipping logic. since this does not match the intended use + // of this library, we use a different, very slow brute + // force implementation + // note though that this does happen some of the time because + // x_top and x_bottom can be extrapolated at the top & bottom of + // the shape and actually lie outside the bounding box + int x; + for (x=0; x < len; ++x) { + // cases: + // + // there can be up to two intersections with the pixel. any intersection + // with left or right edges can be handled by splitting into two (or three) + // regions. intersections with top & bottom do not necessitate case-wise logic. + // + // the old way of doing this found the intersections with the left & right edges, + // then used some simple logic to produce up to three segments in sorted order + // from top-to-bottom. however, this had a problem: if an x edge was epsilon + // across the x border, then the corresponding y position might not be distinct + // from the other y segment, and it might ignored as an empty segment. to avoid + // that, we need to explicitly produce segments based on x positions. + + // rename variables to clearly-defined pairs + float y0 = y_top; + float x1 = (float) (x); + float x2 = (float) (x+1); + float x3 = xb; + float y3 = y_bottom; + + // x = e->x + e->dx * (y-y_top) + // (y-y_top) = (x - e->x) / e->dx + // y = (x - e->x) / e->dx + y_top + float y1 = (x - x0) / dx + y_top; + float y2 = (x+1 - x0) / dx + y_top; + + if (x0 < x1 && x3 > x2) { // three segments descending down-right + stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x1,y1); + stbtt__handle_clipped_edge(scanline,x,e, x1,y1, x2,y2); + stbtt__handle_clipped_edge(scanline,x,e, x2,y2, x3,y3); + } else if (x3 < x1 && x0 > x2) { // three segments descending down-left + stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x2,y2); + stbtt__handle_clipped_edge(scanline,x,e, x2,y2, x1,y1); + stbtt__handle_clipped_edge(scanline,x,e, x1,y1, x3,y3); + } else if (x0 < x1 && x3 > x1) { // two segments across x, down-right + stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x1,y1); + stbtt__handle_clipped_edge(scanline,x,e, x1,y1, x3,y3); + } else if (x3 < x1 && x0 > x1) { // two segments across x, down-left + stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x1,y1); + stbtt__handle_clipped_edge(scanline,x,e, x1,y1, x3,y3); + } else if (x0 < x2 && x3 > x2) { // two segments across x+1, down-right + stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x2,y2); + stbtt__handle_clipped_edge(scanline,x,e, x2,y2, x3,y3); + } else if (x3 < x2 && x0 > x2) { // two segments across x+1, down-left + stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x2,y2); + stbtt__handle_clipped_edge(scanline,x,e, x2,y2, x3,y3); + } else { // one segment + stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x3,y3); + } + } + } + } + e = e->next; + } +} + +// directly AA rasterize edges w/o supersampling +static void stbtt__rasterize_sorted_edges(stbtt__bitmap *result, stbtt__edge *e, int n, int vsubsample, int off_x, int off_y, void *userdata) +{ + stbtt__hheap hh = { 0, 0, 0 }; + stbtt__active_edge *active = NULL; + int y,j=0, i; + float scanline_data[129], *scanline, *scanline2; + + STBTT__NOTUSED(vsubsample); + + if (result->w > 64) + scanline = (float *) STBTT_malloc((result->w*2+1) * sizeof(float), userdata); + else + scanline = scanline_data; + + scanline2 = scanline + result->w; + + y = off_y; + e[n].y0 = (float) (off_y + result->h) + 1; + + while (j < result->h) { + // find center of pixel for this scanline + float scan_y_top = y + 0.0f; + float scan_y_bottom = y + 1.0f; + stbtt__active_edge **step = &active; + + STBTT_memset(scanline , 0, result->w*sizeof(scanline[0])); + STBTT_memset(scanline2, 0, (result->w+1)*sizeof(scanline[0])); + + // update all active edges; + // remove all active edges that terminate before the top of this scanline + while (*step) { + stbtt__active_edge * z = *step; + if (z->ey <= scan_y_top) { + *step = z->next; // delete from list + STBTT_assert(z->direction); + z->direction = 0; + stbtt__hheap_free(&hh, z); + } else { + step = &((*step)->next); // advance through list + } + } + + // insert all edges that start before the bottom of this scanline + while (e->y0 <= scan_y_bottom) { + if (e->y0 != e->y1) { + stbtt__active_edge *z = stbtt__new_active(&hh, e, off_x, scan_y_top, userdata); + if (z != NULL) { + if (j == 0 && off_y != 0) { + if (z->ey < scan_y_top) { + // this can happen due to subpixel positioning and some kind of fp rounding error i think + z->ey = scan_y_top; + } + } + STBTT_assert(z->ey >= scan_y_top); // if we get really unlucky a tiny bit of an edge can be out of bounds + // insert at front + z->next = active; + active = z; + } + } + ++e; + } + + // now process all active edges + if (active) + stbtt__fill_active_edges_new(scanline, scanline2+1, result->w, active, scan_y_top); + + { + float sum = 0; + for (i=0; i < result->w; ++i) { + float k; + int m; + sum += scanline2[i]; + k = scanline[i] + sum; + k = (float) STBTT_fabs(k)*255 + 0.5f; + m = (int) k; + if (m > 255) m = 255; + result->pixels[j*result->stride + i] = (unsigned char) m; + } + } + // advance all the edges + step = &active; + while (*step) { + stbtt__active_edge *z = *step; + z->fx += z->fdx; // advance to position for current scanline + step = &((*step)->next); // advance through list + } + + ++y; + ++j; + } + + stbtt__hheap_cleanup(&hh, userdata); + + if (scanline != scanline_data) + STBTT_free(scanline, userdata); +} +#else +#error "Unrecognized value of STBTT_RASTERIZER_VERSION" +#endif + +#define STBTT__COMPARE(a,b) ((a)->y0 < (b)->y0) + +static void stbtt__sort_edges_ins_sort(stbtt__edge *p, int n) +{ + int i,j; + for (i=1; i < n; ++i) { + stbtt__edge t = p[i], *a = &t; + j = i; + while (j > 0) { + stbtt__edge *b = &p[j-1]; + int c = STBTT__COMPARE(a,b); + if (!c) break; + p[j] = p[j-1]; + --j; + } + if (i != j) + p[j] = t; + } +} + +static void stbtt__sort_edges_quicksort(stbtt__edge *p, int n) +{ + /* threshold for transitioning to insertion sort */ + while (n > 12) { + stbtt__edge t; + int c01,c12,c,m,i,j; + + /* compute median of three */ + m = n >> 1; + c01 = STBTT__COMPARE(&p[0],&p[m]); + c12 = STBTT__COMPARE(&p[m],&p[n-1]); + /* if 0 >= mid >= end, or 0 < mid < end, then use mid */ + if (c01 != c12) { + /* otherwise, we'll need to swap something else to middle */ + int z; + c = STBTT__COMPARE(&p[0],&p[n-1]); + /* 0>mid && midn => n; 0 0 */ + /* 0n: 0>n => 0; 0 n */ + z = (c == c12) ? 0 : n-1; + t = p[z]; + p[z] = p[m]; + p[m] = t; + } + /* now p[m] is the median-of-three */ + /* swap it to the beginning so it won't move around */ + t = p[0]; + p[0] = p[m]; + p[m] = t; + + /* partition loop */ + i=1; + j=n-1; + for(;;) { + /* handling of equality is crucial here */ + /* for sentinels & efficiency with duplicates */ + for (;;++i) { + if (!STBTT__COMPARE(&p[i], &p[0])) break; + } + for (;;--j) { + if (!STBTT__COMPARE(&p[0], &p[j])) break; + } + /* make sure we haven't crossed */ + if (i >= j) break; + t = p[i]; + p[i] = p[j]; + p[j] = t; + + ++i; + --j; + } + /* recurse on smaller side, iterate on larger */ + if (j < (n-i)) { + stbtt__sort_edges_quicksort(p,j); + p = p+i; + n = n-i; + } else { + stbtt__sort_edges_quicksort(p+i, n-i); + n = j; + } + } +} + +static void stbtt__sort_edges(stbtt__edge *p, int n) +{ + stbtt__sort_edges_quicksort(p, n); + stbtt__sort_edges_ins_sort(p, n); +} + +typedef struct +{ + float x,y; +} stbtt__point; + +static void stbtt__rasterize(stbtt__bitmap *result, stbtt__point *pts, int *wcount, int windings, float scale_x, float scale_y, float shift_x, float shift_y, int off_x, int off_y, int invert, void *userdata) +{ + float y_scale_inv = invert ? -scale_y : scale_y; + stbtt__edge *e; + int n,i,j,k,m; +#if STBTT_RASTERIZER_VERSION == 1 + int vsubsample = result->h < 8 ? 15 : 5; +#elif STBTT_RASTERIZER_VERSION == 2 + int vsubsample = 1; +#else + #error "Unrecognized value of STBTT_RASTERIZER_VERSION" +#endif + // vsubsample should divide 255 evenly; otherwise we won't reach full opacity + + // now we have to blow out the windings into explicit edge lists + n = 0; + for (i=0; i < windings; ++i) + n += wcount[i]; + + e = (stbtt__edge *) STBTT_malloc(sizeof(*e) * (n+1), userdata); // add an extra one as a sentinel + if (e == 0) return; + n = 0; + + m=0; + for (i=0; i < windings; ++i) { + stbtt__point *p = pts + m; + m += wcount[i]; + j = wcount[i]-1; + for (k=0; k < wcount[i]; j=k++) { + int a=k,b=j; + // skip the edge if horizontal + if (p[j].y == p[k].y) + continue; + // add edge from j to k to the list + e[n].invert = 0; + if (invert ? p[j].y > p[k].y : p[j].y < p[k].y) { + e[n].invert = 1; + a=j,b=k; + } + e[n].x0 = p[a].x * scale_x + shift_x; + e[n].y0 = (p[a].y * y_scale_inv + shift_y) * vsubsample; + e[n].x1 = p[b].x * scale_x + shift_x; + e[n].y1 = (p[b].y * y_scale_inv + shift_y) * vsubsample; + ++n; + } + } + + // now sort the edges by their highest point (should snap to integer, and then by x) + //STBTT_sort(e, n, sizeof(e[0]), stbtt__edge_compare); + stbtt__sort_edges(e, n); + + // now, traverse the scanlines and find the intersections on each scanline, use xor winding rule + stbtt__rasterize_sorted_edges(result, e, n, vsubsample, off_x, off_y, userdata); + + STBTT_free(e, userdata); +} + +static void stbtt__add_point(stbtt__point *points, int n, float x, float y) +{ + if (!points) return; // during first pass, it's unallocated + points[n].x = x; + points[n].y = y; +} + +// tessellate until threshold p is happy... @TODO warped to compensate for non-linear stretching +static int stbtt__tesselate_curve(stbtt__point *points, int *num_points, float x0, float y0, float x1, float y1, float x2, float y2, float objspace_flatness_squared, int n) +{ + // midpoint + float mx = (x0 + 2*x1 + x2)/4; + float my = (y0 + 2*y1 + y2)/4; + // versus directly drawn line + float dx = (x0+x2)/2 - mx; + float dy = (y0+y2)/2 - my; + if (n > 16) // 65536 segments on one curve better be enough! + return 1; + if (dx*dx+dy*dy > objspace_flatness_squared) { // half-pixel error allowed... need to be smaller if AA + stbtt__tesselate_curve(points, num_points, x0,y0, (x0+x1)/2.0f,(y0+y1)/2.0f, mx,my, objspace_flatness_squared,n+1); + stbtt__tesselate_curve(points, num_points, mx,my, (x1+x2)/2.0f,(y1+y2)/2.0f, x2,y2, objspace_flatness_squared,n+1); + } else { + stbtt__add_point(points, *num_points,x2,y2); + *num_points = *num_points+1; + } + return 1; +} + +static void stbtt__tesselate_cubic(stbtt__point *points, int *num_points, float x0, float y0, float x1, float y1, float x2, float y2, float x3, float y3, float objspace_flatness_squared, int n) +{ + // @TODO this "flatness" calculation is just made-up nonsense that seems to work well enough + float dx0 = x1-x0; + float dy0 = y1-y0; + float dx1 = x2-x1; + float dy1 = y2-y1; + float dx2 = x3-x2; + float dy2 = y3-y2; + float dx = x3-x0; + float dy = y3-y0; + float longlen = (float) (STBTT_sqrt(dx0*dx0+dy0*dy0)+STBTT_sqrt(dx1*dx1+dy1*dy1)+STBTT_sqrt(dx2*dx2+dy2*dy2)); + float shortlen = (float) STBTT_sqrt(dx*dx+dy*dy); + float flatness_squared = longlen*longlen-shortlen*shortlen; + + if (n > 16) // 65536 segments on one curve better be enough! + return; + + if (flatness_squared > objspace_flatness_squared) { + float x01 = (x0+x1)/2; + float y01 = (y0+y1)/2; + float x12 = (x1+x2)/2; + float y12 = (y1+y2)/2; + float x23 = (x2+x3)/2; + float y23 = (y2+y3)/2; + + float xa = (x01+x12)/2; + float ya = (y01+y12)/2; + float xb = (x12+x23)/2; + float yb = (y12+y23)/2; + + float mx = (xa+xb)/2; + float my = (ya+yb)/2; + + stbtt__tesselate_cubic(points, num_points, x0,y0, x01,y01, xa,ya, mx,my, objspace_flatness_squared,n+1); + stbtt__tesselate_cubic(points, num_points, mx,my, xb,yb, x23,y23, x3,y3, objspace_flatness_squared,n+1); + } else { + stbtt__add_point(points, *num_points,x3,y3); + *num_points = *num_points+1; + } +} + +// returns number of contours +static stbtt__point *stbtt_FlattenCurves(stbtt_vertex *vertices, int num_verts, float objspace_flatness, int **contour_lengths, int *num_contours, void *userdata) +{ + stbtt__point *points=0; + int num_points=0; + + float objspace_flatness_squared = objspace_flatness * objspace_flatness; + int i,n=0,start=0, pass; + + // count how many "moves" there are to get the contour count + for (i=0; i < num_verts; ++i) + if (vertices[i].type == STBTT_vmove) + ++n; + + *num_contours = n; + if (n == 0) return 0; + + *contour_lengths = (int *) STBTT_malloc(sizeof(**contour_lengths) * n, userdata); + + if (*contour_lengths == 0) { + *num_contours = 0; + return 0; + } + + // make two passes through the points so we don't need to realloc + for (pass=0; pass < 2; ++pass) { + float x=0,y=0; + if (pass == 1) { + points = (stbtt__point *) STBTT_malloc(num_points * sizeof(points[0]), userdata); + if (points == NULL) goto error; + } + num_points = 0; + n= -1; + for (i=0; i < num_verts; ++i) { + switch (vertices[i].type) { + case STBTT_vmove: + // start the next contour + if (n >= 0) + (*contour_lengths)[n] = num_points - start; + ++n; + start = num_points; + + x = vertices[i].x, y = vertices[i].y; + stbtt__add_point(points, num_points++, x,y); + break; + case STBTT_vline: + x = vertices[i].x, y = vertices[i].y; + stbtt__add_point(points, num_points++, x, y); + break; + case STBTT_vcurve: + stbtt__tesselate_curve(points, &num_points, x,y, + vertices[i].cx, vertices[i].cy, + vertices[i].x, vertices[i].y, + objspace_flatness_squared, 0); + x = vertices[i].x, y = vertices[i].y; + break; + case STBTT_vcubic: + stbtt__tesselate_cubic(points, &num_points, x,y, + vertices[i].cx, vertices[i].cy, + vertices[i].cx1, vertices[i].cy1, + vertices[i].x, vertices[i].y, + objspace_flatness_squared, 0); + x = vertices[i].x, y = vertices[i].y; + break; + } + } + (*contour_lengths)[n] = num_points - start; + } + + return points; +error: + STBTT_free(points, userdata); + STBTT_free(*contour_lengths, userdata); + *contour_lengths = 0; + *num_contours = 0; + return NULL; +} + +STBTT_DEF void stbtt_Rasterize(stbtt__bitmap *result, float flatness_in_pixels, stbtt_vertex *vertices, int num_verts, float scale_x, float scale_y, float shift_x, float shift_y, int x_off, int y_off, int invert, void *userdata) +{ + float scale = scale_x > scale_y ? scale_y : scale_x; + int winding_count = 0; + int *winding_lengths = NULL; + stbtt__point *windings = stbtt_FlattenCurves(vertices, num_verts, flatness_in_pixels / scale, &winding_lengths, &winding_count, userdata); + if (windings) { + stbtt__rasterize(result, windings, winding_lengths, winding_count, scale_x, scale_y, shift_x, shift_y, x_off, y_off, invert, userdata); + STBTT_free(winding_lengths, userdata); + STBTT_free(windings, userdata); + } +} + +STBTT_DEF void stbtt_FreeBitmap(unsigned char *bitmap, void *userdata) +{ + STBTT_free(bitmap, userdata); +} + +STBTT_DEF unsigned char *stbtt_GetGlyphBitmapSubpixel(const stbtt_fontinfo *info, float scale_x, float scale_y, float shift_x, float shift_y, int glyph, int *width, int *height, int *xoff, int *yoff) +{ + int ix0,iy0,ix1,iy1; + stbtt__bitmap gbm; + stbtt_vertex *vertices; + int num_verts = stbtt_GetGlyphShape(info, glyph, &vertices); + + if (scale_x == 0) scale_x = scale_y; + if (scale_y == 0) { + if (scale_x == 0) { + STBTT_free(vertices, info->userdata); + return NULL; + } + scale_y = scale_x; + } + + stbtt_GetGlyphBitmapBoxSubpixel(info, glyph, scale_x, scale_y, shift_x, shift_y, &ix0,&iy0,&ix1,&iy1); + + // now we get the size + gbm.w = (ix1 - ix0); + gbm.h = (iy1 - iy0); + gbm.pixels = NULL; // in case we error + + if (width ) *width = gbm.w; + if (height) *height = gbm.h; + if (xoff ) *xoff = ix0; + if (yoff ) *yoff = iy0; + + if (gbm.w && gbm.h) { + gbm.pixels = (unsigned char *) STBTT_malloc(gbm.w * gbm.h, info->userdata); + if (gbm.pixels) { + gbm.stride = gbm.w; + + stbtt_Rasterize(&gbm, 0.35f, vertices, num_verts, scale_x, scale_y, shift_x, shift_y, ix0, iy0, 1, info->userdata); + } + } + STBTT_free(vertices, info->userdata); + return gbm.pixels; +} + +STBTT_DEF unsigned char *stbtt_GetGlyphBitmap(const stbtt_fontinfo *info, float scale_x, float scale_y, int glyph, int *width, int *height, int *xoff, int *yoff) +{ + return stbtt_GetGlyphBitmapSubpixel(info, scale_x, scale_y, 0.0f, 0.0f, glyph, width, height, xoff, yoff); +} + +STBTT_DEF void stbtt_MakeGlyphBitmapSubpixel(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int glyph) +{ + int ix0,iy0; + stbtt_vertex *vertices; + int num_verts = stbtt_GetGlyphShape(info, glyph, &vertices); + stbtt__bitmap gbm; + + stbtt_GetGlyphBitmapBoxSubpixel(info, glyph, scale_x, scale_y, shift_x, shift_y, &ix0,&iy0,0,0); + gbm.pixels = output; + gbm.w = out_w; + gbm.h = out_h; + gbm.stride = out_stride; + + if (gbm.w && gbm.h) + stbtt_Rasterize(&gbm, 0.35f, vertices, num_verts, scale_x, scale_y, shift_x, shift_y, ix0,iy0, 1, info->userdata); + + STBTT_free(vertices, info->userdata); +} + +STBTT_DEF void stbtt_MakeGlyphBitmap(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, int glyph) +{ + stbtt_MakeGlyphBitmapSubpixel(info, output, out_w, out_h, out_stride, scale_x, scale_y, 0.0f,0.0f, glyph); +} + +STBTT_DEF unsigned char *stbtt_GetCodepointBitmapSubpixel(const stbtt_fontinfo *info, float scale_x, float scale_y, float shift_x, float shift_y, int codepoint, int *width, int *height, int *xoff, int *yoff) +{ + return stbtt_GetGlyphBitmapSubpixel(info, scale_x, scale_y,shift_x,shift_y, stbtt_FindGlyphIndex(info,codepoint), width,height,xoff,yoff); +} + +STBTT_DEF void stbtt_MakeCodepointBitmapSubpixelPrefilter(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int oversample_x, int oversample_y, float *sub_x, float *sub_y, int codepoint) +{ + stbtt_MakeGlyphBitmapSubpixelPrefilter(info, output, out_w, out_h, out_stride, scale_x, scale_y, shift_x, shift_y, oversample_x, oversample_y, sub_x, sub_y, stbtt_FindGlyphIndex(info,codepoint)); +} + +STBTT_DEF void stbtt_MakeCodepointBitmapSubpixel(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int codepoint) +{ + stbtt_MakeGlyphBitmapSubpixel(info, output, out_w, out_h, out_stride, scale_x, scale_y, shift_x, shift_y, stbtt_FindGlyphIndex(info,codepoint)); +} + +STBTT_DEF unsigned char *stbtt_GetCodepointBitmap(const stbtt_fontinfo *info, float scale_x, float scale_y, int codepoint, int *width, int *height, int *xoff, int *yoff) +{ + return stbtt_GetCodepointBitmapSubpixel(info, scale_x, scale_y, 0.0f,0.0f, codepoint, width,height,xoff,yoff); +} + +STBTT_DEF void stbtt_MakeCodepointBitmap(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, int codepoint) +{ + stbtt_MakeCodepointBitmapSubpixel(info, output, out_w, out_h, out_stride, scale_x, scale_y, 0.0f,0.0f, codepoint); +} + +////////////////////////////////////////////////////////////////////////////// +// +// bitmap baking +// +// This is SUPER-CRAPPY packing to keep source code small + +static int stbtt_BakeFontBitmap_internal(unsigned char *data, int offset, // font location (use offset=0 for plain .ttf) + float pixel_height, // height of font in pixels + unsigned char *pixels, int pw, int ph, // bitmap to be filled in + int first_char, int num_chars, // characters to bake + stbtt_bakedchar *chardata) +{ + float scale; + int x,y,bottom_y, i; + stbtt_fontinfo f; + f.userdata = NULL; + if (!stbtt_InitFont(&f, data, offset)) + return -1; + STBTT_memset(pixels, 0, pw*ph); // background of 0 around pixels + x=y=1; + bottom_y = 1; + + scale = stbtt_ScaleForPixelHeight(&f, pixel_height); + + for (i=0; i < num_chars; ++i) { + int advance, lsb, x0,y0,x1,y1,gw,gh; + int g = stbtt_FindGlyphIndex(&f, first_char + i); + stbtt_GetGlyphHMetrics(&f, g, &advance, &lsb); + stbtt_GetGlyphBitmapBox(&f, g, scale,scale, &x0,&y0,&x1,&y1); + gw = x1-x0; + gh = y1-y0; + if (x + gw + 1 >= pw) + y = bottom_y, x = 1; // advance to next row + if (y + gh + 1 >= ph) // check if it fits vertically AFTER potentially moving to next row + return -i; + STBTT_assert(x+gw < pw); + STBTT_assert(y+gh < ph); + stbtt_MakeGlyphBitmap(&f, pixels+x+y*pw, gw,gh,pw, scale,scale, g); + chardata[i].x0 = (stbtt_int16) x; + chardata[i].y0 = (stbtt_int16) y; + chardata[i].x1 = (stbtt_int16) (x + gw); + chardata[i].y1 = (stbtt_int16) (y + gh); + chardata[i].xadvance = scale * advance; + chardata[i].xoff = (float) x0; + chardata[i].yoff = (float) y0; + x = x + gw + 1; + if (y+gh+1 > bottom_y) + bottom_y = y+gh+1; + } + return bottom_y; +} + +STBTT_DEF void stbtt_GetBakedQuad(const stbtt_bakedchar *chardata, int pw, int ph, int char_index, float *xpos, float *ypos, stbtt_aligned_quad *q, int opengl_fillrule) +{ + float d3d_bias = opengl_fillrule ? 0 : -0.5f; + float ipw = 1.0f / pw, iph = 1.0f / ph; + const stbtt_bakedchar *b = chardata + char_index; + int round_x = STBTT_ifloor((*xpos + b->xoff) + 0.5f); + int round_y = STBTT_ifloor((*ypos + b->yoff) + 0.5f); + + q->x0 = round_x + d3d_bias; + q->y0 = round_y + d3d_bias; + q->x1 = round_x + b->x1 - b->x0 + d3d_bias; + q->y1 = round_y + b->y1 - b->y0 + d3d_bias; + + q->s0 = b->x0 * ipw; + q->t0 = b->y0 * iph; + q->s1 = b->x1 * ipw; + q->t1 = b->y1 * iph; + + *xpos += b->xadvance; +} + +////////////////////////////////////////////////////////////////////////////// +// +// rectangle packing replacement routines if you don't have stb_rect_pack.h +// + +#ifndef STB_RECT_PACK_VERSION + +typedef int stbrp_coord; + +//////////////////////////////////////////////////////////////////////////////////// +// // +// // +// COMPILER WARNING ?!?!? // +// // +// // +// if you get a compile warning due to these symbols being defined more than // +// once, move #include "stb_rect_pack.h" before #include "stb_truetype.h" // +// // +//////////////////////////////////////////////////////////////////////////////////// + +typedef struct +{ + int width,height; + int x,y,bottom_y; +} stbrp_context; + +typedef struct +{ + unsigned char x; +} stbrp_node; + +struct stbrp_rect +{ + stbrp_coord x,y; + int id,w,h,was_packed; +}; + +static void stbrp_init_target(stbrp_context *con, int pw, int ph, stbrp_node *nodes, int num_nodes) +{ + con->width = pw; + con->height = ph; + con->x = 0; + con->y = 0; + con->bottom_y = 0; + STBTT__NOTUSED(nodes); + STBTT__NOTUSED(num_nodes); +} + +static void stbrp_pack_rects(stbrp_context *con, stbrp_rect *rects, int num_rects) +{ + int i; + for (i=0; i < num_rects; ++i) { + if (con->x + rects[i].w > con->width) { + con->x = 0; + con->y = con->bottom_y; + } + if (con->y + rects[i].h > con->height) + break; + rects[i].x = con->x; + rects[i].y = con->y; + rects[i].was_packed = 1; + con->x += rects[i].w; + if (con->y + rects[i].h > con->bottom_y) + con->bottom_y = con->y + rects[i].h; + } + for ( ; i < num_rects; ++i) + rects[i].was_packed = 0; +} +#endif + +////////////////////////////////////////////////////////////////////////////// +// +// bitmap baking +// +// This is SUPER-AWESOME (tm Ryan Gordon) packing using stb_rect_pack.h. If +// stb_rect_pack.h isn't available, it uses the BakeFontBitmap strategy. + +STBTT_DEF int stbtt_PackBegin(stbtt_pack_context *spc, unsigned char *pixels, int pw, int ph, int stride_in_bytes, int padding, void *alloc_context) +{ + stbrp_context *context = (stbrp_context *) STBTT_malloc(sizeof(*context) ,alloc_context); + int num_nodes = pw - padding; + stbrp_node *nodes = (stbrp_node *) STBTT_malloc(sizeof(*nodes ) * num_nodes,alloc_context); + + if (context == NULL || nodes == NULL) { + if (context != NULL) STBTT_free(context, alloc_context); + if (nodes != NULL) STBTT_free(nodes , alloc_context); + return 0; + } + + spc->user_allocator_context = alloc_context; + spc->width = pw; + spc->height = ph; + spc->pixels = pixels; + spc->pack_info = context; + spc->nodes = nodes; + spc->padding = padding; + spc->stride_in_bytes = stride_in_bytes != 0 ? stride_in_bytes : pw; + spc->h_oversample = 1; + spc->v_oversample = 1; + spc->skip_missing = 0; + + stbrp_init_target(context, pw-padding, ph-padding, nodes, num_nodes); + + if (pixels) + STBTT_memset(pixels, 0, pw*ph); // background of 0 around pixels + + return 1; +} + +STBTT_DEF void stbtt_PackEnd (stbtt_pack_context *spc) +{ + STBTT_free(spc->nodes , spc->user_allocator_context); + STBTT_free(spc->pack_info, spc->user_allocator_context); +} + +STBTT_DEF void stbtt_PackSetOversampling(stbtt_pack_context *spc, unsigned int h_oversample, unsigned int v_oversample) +{ + STBTT_assert(h_oversample <= STBTT_MAX_OVERSAMPLE); + STBTT_assert(v_oversample <= STBTT_MAX_OVERSAMPLE); + if (h_oversample <= STBTT_MAX_OVERSAMPLE) + spc->h_oversample = h_oversample; + if (v_oversample <= STBTT_MAX_OVERSAMPLE) + spc->v_oversample = v_oversample; +} + +STBTT_DEF void stbtt_PackSetSkipMissingCodepoints(stbtt_pack_context *spc, int skip) +{ + spc->skip_missing = skip; +} + +#define STBTT__OVER_MASK (STBTT_MAX_OVERSAMPLE-1) + +static void stbtt__h_prefilter(unsigned char *pixels, int w, int h, int stride_in_bytes, unsigned int kernel_width) +{ + unsigned char buffer[STBTT_MAX_OVERSAMPLE]; + int safe_w = w - kernel_width; + int j; + STBTT_memset(buffer, 0, STBTT_MAX_OVERSAMPLE); // suppress bogus warning from VS2013 -analyze + for (j=0; j < h; ++j) { + int i; + unsigned int total; + STBTT_memset(buffer, 0, kernel_width); + + total = 0; + + // make kernel_width a constant in common cases so compiler can optimize out the divide + switch (kernel_width) { + case 2: + for (i=0; i <= safe_w; ++i) { + total += pixels[i] - buffer[i & STBTT__OVER_MASK]; + buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i]; + pixels[i] = (unsigned char) (total / 2); + } + break; + case 3: + for (i=0; i <= safe_w; ++i) { + total += pixels[i] - buffer[i & STBTT__OVER_MASK]; + buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i]; + pixels[i] = (unsigned char) (total / 3); + } + break; + case 4: + for (i=0; i <= safe_w; ++i) { + total += pixels[i] - buffer[i & STBTT__OVER_MASK]; + buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i]; + pixels[i] = (unsigned char) (total / 4); + } + break; + case 5: + for (i=0; i <= safe_w; ++i) { + total += pixels[i] - buffer[i & STBTT__OVER_MASK]; + buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i]; + pixels[i] = (unsigned char) (total / 5); + } + break; + default: + for (i=0; i <= safe_w; ++i) { + total += pixels[i] - buffer[i & STBTT__OVER_MASK]; + buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i]; + pixels[i] = (unsigned char) (total / kernel_width); + } + break; + } + + for (; i < w; ++i) { + STBTT_assert(pixels[i] == 0); + total -= buffer[i & STBTT__OVER_MASK]; + pixels[i] = (unsigned char) (total / kernel_width); + } + + pixels += stride_in_bytes; + } +} + +static void stbtt__v_prefilter(unsigned char *pixels, int w, int h, int stride_in_bytes, unsigned int kernel_width) +{ + unsigned char buffer[STBTT_MAX_OVERSAMPLE]; + int safe_h = h - kernel_width; + int j; + STBTT_memset(buffer, 0, STBTT_MAX_OVERSAMPLE); // suppress bogus warning from VS2013 -analyze + for (j=0; j < w; ++j) { + int i; + unsigned int total; + STBTT_memset(buffer, 0, kernel_width); + + total = 0; + + // make kernel_width a constant in common cases so compiler can optimize out the divide + switch (kernel_width) { + case 2: + for (i=0; i <= safe_h; ++i) { + total += pixels[i*stride_in_bytes] - buffer[i & STBTT__OVER_MASK]; + buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i*stride_in_bytes]; + pixels[i*stride_in_bytes] = (unsigned char) (total / 2); + } + break; + case 3: + for (i=0; i <= safe_h; ++i) { + total += pixels[i*stride_in_bytes] - buffer[i & STBTT__OVER_MASK]; + buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i*stride_in_bytes]; + pixels[i*stride_in_bytes] = (unsigned char) (total / 3); + } + break; + case 4: + for (i=0; i <= safe_h; ++i) { + total += pixels[i*stride_in_bytes] - buffer[i & STBTT__OVER_MASK]; + buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i*stride_in_bytes]; + pixels[i*stride_in_bytes] = (unsigned char) (total / 4); + } + break; + case 5: + for (i=0; i <= safe_h; ++i) { + total += pixels[i*stride_in_bytes] - buffer[i & STBTT__OVER_MASK]; + buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i*stride_in_bytes]; + pixels[i*stride_in_bytes] = (unsigned char) (total / 5); + } + break; + default: + for (i=0; i <= safe_h; ++i) { + total += pixels[i*stride_in_bytes] - buffer[i & STBTT__OVER_MASK]; + buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i*stride_in_bytes]; + pixels[i*stride_in_bytes] = (unsigned char) (total / kernel_width); + } + break; + } + + for (; i < h; ++i) { + STBTT_assert(pixels[i*stride_in_bytes] == 0); + total -= buffer[i & STBTT__OVER_MASK]; + pixels[i*stride_in_bytes] = (unsigned char) (total / kernel_width); + } + + pixels += 1; + } +} + +static float stbtt__oversample_shift(int oversample) +{ + if (!oversample) + return 0.0f; + + // The prefilter is a box filter of width "oversample", + // which shifts phase by (oversample - 1)/2 pixels in + // oversampled space. We want to shift in the opposite + // direction to counter this. + return (float)-(oversample - 1) / (2.0f * (float)oversample); +} + +// rects array must be big enough to accommodate all characters in the given ranges +STBTT_DEF int stbtt_PackFontRangesGatherRects(stbtt_pack_context *spc, const stbtt_fontinfo *info, stbtt_pack_range *ranges, int num_ranges, stbrp_rect *rects) +{ + int i,j,k; + int missing_glyph_added = 0; + + k=0; + for (i=0; i < num_ranges; ++i) { + float fh = ranges[i].font_size; + float scale = fh > 0 ? stbtt_ScaleForPixelHeight(info, fh) : stbtt_ScaleForMappingEmToPixels(info, -fh); + ranges[i].h_oversample = (unsigned char) spc->h_oversample; + ranges[i].v_oversample = (unsigned char) spc->v_oversample; + for (j=0; j < ranges[i].num_chars; ++j) { + int x0,y0,x1,y1; + int codepoint = ranges[i].array_of_unicode_codepoints == NULL ? ranges[i].first_unicode_codepoint_in_range + j : ranges[i].array_of_unicode_codepoints[j]; + int glyph = stbtt_FindGlyphIndex(info, codepoint); + if (glyph == 0 && (spc->skip_missing || missing_glyph_added)) { + rects[k].w = rects[k].h = 0; + } else { + stbtt_GetGlyphBitmapBoxSubpixel(info,glyph, + scale * spc->h_oversample, + scale * spc->v_oversample, + 0,0, + &x0,&y0,&x1,&y1); + rects[k].w = (stbrp_coord) (x1-x0 + spc->padding + spc->h_oversample-1); + rects[k].h = (stbrp_coord) (y1-y0 + spc->padding + spc->v_oversample-1); + if (glyph == 0) + missing_glyph_added = 1; + } + ++k; + } + } + + return k; +} + +STBTT_DEF void stbtt_MakeGlyphBitmapSubpixelPrefilter(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int prefilter_x, int prefilter_y, float *sub_x, float *sub_y, int glyph) +{ + stbtt_MakeGlyphBitmapSubpixel(info, + output, + out_w - (prefilter_x - 1), + out_h - (prefilter_y - 1), + out_stride, + scale_x, + scale_y, + shift_x, + shift_y, + glyph); + + if (prefilter_x > 1) + stbtt__h_prefilter(output, out_w, out_h, out_stride, prefilter_x); + + if (prefilter_y > 1) + stbtt__v_prefilter(output, out_w, out_h, out_stride, prefilter_y); + + *sub_x = stbtt__oversample_shift(prefilter_x); + *sub_y = stbtt__oversample_shift(prefilter_y); +} + +// rects array must be big enough to accommodate all characters in the given ranges +STBTT_DEF int stbtt_PackFontRangesRenderIntoRects(stbtt_pack_context *spc, const stbtt_fontinfo *info, stbtt_pack_range *ranges, int num_ranges, stbrp_rect *rects) +{ + int i,j,k, missing_glyph = -1, return_value = 1; + + // save current values + int old_h_over = spc->h_oversample; + int old_v_over = spc->v_oversample; + + k = 0; + for (i=0; i < num_ranges; ++i) { + float fh = ranges[i].font_size; + float scale = fh > 0 ? stbtt_ScaleForPixelHeight(info, fh) : stbtt_ScaleForMappingEmToPixels(info, -fh); + float recip_h,recip_v,sub_x,sub_y; + spc->h_oversample = ranges[i].h_oversample; + spc->v_oversample = ranges[i].v_oversample; + recip_h = 1.0f / spc->h_oversample; + recip_v = 1.0f / spc->v_oversample; + sub_x = stbtt__oversample_shift(spc->h_oversample); + sub_y = stbtt__oversample_shift(spc->v_oversample); + for (j=0; j < ranges[i].num_chars; ++j) { + stbrp_rect *r = &rects[k]; + if (r->was_packed && r->w != 0 && r->h != 0) { + stbtt_packedchar *bc = &ranges[i].chardata_for_range[j]; + int advance, lsb, x0,y0,x1,y1; + int codepoint = ranges[i].array_of_unicode_codepoints == NULL ? ranges[i].first_unicode_codepoint_in_range + j : ranges[i].array_of_unicode_codepoints[j]; + int glyph = stbtt_FindGlyphIndex(info, codepoint); + stbrp_coord pad = (stbrp_coord) spc->padding; + + // pad on left and top + r->x += pad; + r->y += pad; + r->w -= pad; + r->h -= pad; + stbtt_GetGlyphHMetrics(info, glyph, &advance, &lsb); + stbtt_GetGlyphBitmapBox(info, glyph, + scale * spc->h_oversample, + scale * spc->v_oversample, + &x0,&y0,&x1,&y1); + stbtt_MakeGlyphBitmapSubpixel(info, + spc->pixels + r->x + r->y*spc->stride_in_bytes, + r->w - spc->h_oversample+1, + r->h - spc->v_oversample+1, + spc->stride_in_bytes, + scale * spc->h_oversample, + scale * spc->v_oversample, + 0,0, + glyph); + + if (spc->h_oversample > 1) + stbtt__h_prefilter(spc->pixels + r->x + r->y*spc->stride_in_bytes, + r->w, r->h, spc->stride_in_bytes, + spc->h_oversample); + + if (spc->v_oversample > 1) + stbtt__v_prefilter(spc->pixels + r->x + r->y*spc->stride_in_bytes, + r->w, r->h, spc->stride_in_bytes, + spc->v_oversample); + + bc->x0 = (stbtt_int16) r->x; + bc->y0 = (stbtt_int16) r->y; + bc->x1 = (stbtt_int16) (r->x + r->w); + bc->y1 = (stbtt_int16) (r->y + r->h); + bc->xadvance = scale * advance; + bc->xoff = (float) x0 * recip_h + sub_x; + bc->yoff = (float) y0 * recip_v + sub_y; + bc->xoff2 = (x0 + r->w) * recip_h + sub_x; + bc->yoff2 = (y0 + r->h) * recip_v + sub_y; + + if (glyph == 0) + missing_glyph = j; + } else if (spc->skip_missing) { + return_value = 0; + } else if (r->was_packed && r->w == 0 && r->h == 0 && missing_glyph >= 0) { + ranges[i].chardata_for_range[j] = ranges[i].chardata_for_range[missing_glyph]; + } else { + return_value = 0; // if any fail, report failure + } + + ++k; + } + } + + // restore original values + spc->h_oversample = old_h_over; + spc->v_oversample = old_v_over; + + return return_value; +} + +STBTT_DEF void stbtt_PackFontRangesPackRects(stbtt_pack_context *spc, stbrp_rect *rects, int num_rects) +{ + stbrp_pack_rects((stbrp_context *) spc->pack_info, rects, num_rects); +} + +STBTT_DEF int stbtt_PackFontRanges(stbtt_pack_context *spc, const unsigned char *fontdata, int font_index, stbtt_pack_range *ranges, int num_ranges) +{ + stbtt_fontinfo info; + int i,j,n, return_value = 1; + //stbrp_context *context = (stbrp_context *) spc->pack_info; + stbrp_rect *rects; + + // flag all characters as NOT packed + for (i=0; i < num_ranges; ++i) + for (j=0; j < ranges[i].num_chars; ++j) + ranges[i].chardata_for_range[j].x0 = + ranges[i].chardata_for_range[j].y0 = + ranges[i].chardata_for_range[j].x1 = + ranges[i].chardata_for_range[j].y1 = 0; + + n = 0; + for (i=0; i < num_ranges; ++i) + n += ranges[i].num_chars; + + rects = (stbrp_rect *) STBTT_malloc(sizeof(*rects) * n, spc->user_allocator_context); + if (rects == NULL) + return 0; + + info.userdata = spc->user_allocator_context; + stbtt_InitFont(&info, fontdata, stbtt_GetFontOffsetForIndex(fontdata,font_index)); + + n = stbtt_PackFontRangesGatherRects(spc, &info, ranges, num_ranges, rects); + + stbtt_PackFontRangesPackRects(spc, rects, n); + + return_value = stbtt_PackFontRangesRenderIntoRects(spc, &info, ranges, num_ranges, rects); + + STBTT_free(rects, spc->user_allocator_context); + return return_value; +} + +STBTT_DEF int stbtt_PackFontRange(stbtt_pack_context *spc, const unsigned char *fontdata, int font_index, float font_size, + int first_unicode_codepoint_in_range, int num_chars_in_range, stbtt_packedchar *chardata_for_range) +{ + stbtt_pack_range range; + range.first_unicode_codepoint_in_range = first_unicode_codepoint_in_range; + range.array_of_unicode_codepoints = NULL; + range.num_chars = num_chars_in_range; + range.chardata_for_range = chardata_for_range; + range.font_size = font_size; + return stbtt_PackFontRanges(spc, fontdata, font_index, &range, 1); +} + +STBTT_DEF void stbtt_GetScaledFontVMetrics(const unsigned char *fontdata, int index, float size, float *ascent, float *descent, float *lineGap) +{ + int i_ascent, i_descent, i_lineGap; + float scale; + stbtt_fontinfo info; + stbtt_InitFont(&info, fontdata, stbtt_GetFontOffsetForIndex(fontdata, index)); + scale = size > 0 ? stbtt_ScaleForPixelHeight(&info, size) : stbtt_ScaleForMappingEmToPixels(&info, -size); + stbtt_GetFontVMetrics(&info, &i_ascent, &i_descent, &i_lineGap); + *ascent = (float) i_ascent * scale; + *descent = (float) i_descent * scale; + *lineGap = (float) i_lineGap * scale; +} + +STBTT_DEF void stbtt_GetPackedQuad(const stbtt_packedchar *chardata, int pw, int ph, int char_index, float *xpos, float *ypos, stbtt_aligned_quad *q, int align_to_integer) +{ + float ipw = 1.0f / pw, iph = 1.0f / ph; + const stbtt_packedchar *b = chardata + char_index; + + if (align_to_integer) { + float x = (float) STBTT_ifloor((*xpos + b->xoff) + 0.5f); + float y = (float) STBTT_ifloor((*ypos + b->yoff) + 0.5f); + q->x0 = x; + q->y0 = y; + q->x1 = x + b->xoff2 - b->xoff; + q->y1 = y + b->yoff2 - b->yoff; + } else { + q->x0 = *xpos + b->xoff; + q->y0 = *ypos + b->yoff; + q->x1 = *xpos + b->xoff2; + q->y1 = *ypos + b->yoff2; + } + + q->s0 = b->x0 * ipw; + q->t0 = b->y0 * iph; + q->s1 = b->x1 * ipw; + q->t1 = b->y1 * iph; + + *xpos += b->xadvance; +} + +////////////////////////////////////////////////////////////////////////////// +// +// sdf computation +// + +#define STBTT_min(a,b) ((a) < (b) ? (a) : (b)) +#define STBTT_max(a,b) ((a) < (b) ? (b) : (a)) + +static int stbtt__ray_intersect_bezier(float orig[2], float ray[2], float q0[2], float q1[2], float q2[2], float hits[2][2]) +{ + float q0perp = q0[1]*ray[0] - q0[0]*ray[1]; + float q1perp = q1[1]*ray[0] - q1[0]*ray[1]; + float q2perp = q2[1]*ray[0] - q2[0]*ray[1]; + float roperp = orig[1]*ray[0] - orig[0]*ray[1]; + + float a = q0perp - 2*q1perp + q2perp; + float b = q1perp - q0perp; + float c = q0perp - roperp; + + float s0 = 0., s1 = 0.; + int num_s = 0; + + if (a != 0.0) { + float discr = b*b - a*c; + if (discr > 0.0) { + float rcpna = -1 / a; + float d = (float) STBTT_sqrt(discr); + s0 = (b+d) * rcpna; + s1 = (b-d) * rcpna; + if (s0 >= 0.0 && s0 <= 1.0) + num_s = 1; + if (d > 0.0 && s1 >= 0.0 && s1 <= 1.0) { + if (num_s == 0) s0 = s1; + ++num_s; + } + } + } else { + // 2*b*s + c = 0 + // s = -c / (2*b) + s0 = c / (-2 * b); + if (s0 >= 0.0 && s0 <= 1.0) + num_s = 1; + } + + if (num_s == 0) + return 0; + else { + float rcp_len2 = 1 / (ray[0]*ray[0] + ray[1]*ray[1]); + float rayn_x = ray[0] * rcp_len2, rayn_y = ray[1] * rcp_len2; + + float q0d = q0[0]*rayn_x + q0[1]*rayn_y; + float q1d = q1[0]*rayn_x + q1[1]*rayn_y; + float q2d = q2[0]*rayn_x + q2[1]*rayn_y; + float rod = orig[0]*rayn_x + orig[1]*rayn_y; + + float q10d = q1d - q0d; + float q20d = q2d - q0d; + float q0rd = q0d - rod; + + hits[0][0] = q0rd + s0*(2.0f - 2.0f*s0)*q10d + s0*s0*q20d; + hits[0][1] = a*s0+b; + + if (num_s > 1) { + hits[1][0] = q0rd + s1*(2.0f - 2.0f*s1)*q10d + s1*s1*q20d; + hits[1][1] = a*s1+b; + return 2; + } else { + return 1; + } + } +} + +static int equal(float *a, float *b) +{ + return (a[0] == b[0] && a[1] == b[1]); +} + +static int stbtt__compute_crossings_x(float x, float y, int nverts, stbtt_vertex *verts) +{ + int i; + float orig[2], ray[2] = { 1, 0 }; + float y_frac; + int winding = 0; + + // make sure y never passes through a vertex of the shape + y_frac = (float) STBTT_fmod(y, 1.0f); + if (y_frac < 0.01f) + y += 0.01f; + else if (y_frac > 0.99f) + y -= 0.01f; + + orig[0] = x; + orig[1] = y; + + // test a ray from (-infinity,y) to (x,y) + for (i=0; i < nverts; ++i) { + if (verts[i].type == STBTT_vline) { + int x0 = (int) verts[i-1].x, y0 = (int) verts[i-1].y; + int x1 = (int) verts[i ].x, y1 = (int) verts[i ].y; + if (y > STBTT_min(y0,y1) && y < STBTT_max(y0,y1) && x > STBTT_min(x0,x1)) { + float x_inter = (y - y0) / (y1 - y0) * (x1-x0) + x0; + if (x_inter < x) + winding += (y0 < y1) ? 1 : -1; + } + } + if (verts[i].type == STBTT_vcurve) { + int x0 = (int) verts[i-1].x , y0 = (int) verts[i-1].y ; + int x1 = (int) verts[i ].cx, y1 = (int) verts[i ].cy; + int x2 = (int) verts[i ].x , y2 = (int) verts[i ].y ; + int ax = STBTT_min(x0,STBTT_min(x1,x2)), ay = STBTT_min(y0,STBTT_min(y1,y2)); + int by = STBTT_max(y0,STBTT_max(y1,y2)); + if (y > ay && y < by && x > ax) { + float q0[2],q1[2],q2[2]; + float hits[2][2]; + q0[0] = (float)x0; + q0[1] = (float)y0; + q1[0] = (float)x1; + q1[1] = (float)y1; + q2[0] = (float)x2; + q2[1] = (float)y2; + if (equal(q0,q1) || equal(q1,q2)) { + x0 = (int)verts[i-1].x; + y0 = (int)verts[i-1].y; + x1 = (int)verts[i ].x; + y1 = (int)verts[i ].y; + if (y > STBTT_min(y0,y1) && y < STBTT_max(y0,y1) && x > STBTT_min(x0,x1)) { + float x_inter = (y - y0) / (y1 - y0) * (x1-x0) + x0; + if (x_inter < x) + winding += (y0 < y1) ? 1 : -1; + } + } else { + int num_hits = stbtt__ray_intersect_bezier(orig, ray, q0, q1, q2, hits); + if (num_hits >= 1) + if (hits[0][0] < 0) + winding += (hits[0][1] < 0 ? -1 : 1); + if (num_hits >= 2) + if (hits[1][0] < 0) + winding += (hits[1][1] < 0 ? -1 : 1); + } + } + } + } + return winding; +} + +static float stbtt__cuberoot( float x ) +{ + if (x<0) + return -(float) STBTT_pow(-x,1.0f/3.0f); + else + return (float) STBTT_pow( x,1.0f/3.0f); +} + +// x^3 + a*x^2 + b*x + c = 0 +static int stbtt__solve_cubic(float a, float b, float c, float* r) +{ + float s = -a / 3; + float p = b - a*a / 3; + float q = a * (2*a*a - 9*b) / 27 + c; + float p3 = p*p*p; + float d = q*q + 4*p3 / 27; + if (d >= 0) { + float z = (float) STBTT_sqrt(d); + float u = (-q + z) / 2; + float v = (-q - z) / 2; + u = stbtt__cuberoot(u); + v = stbtt__cuberoot(v); + r[0] = s + u + v; + return 1; + } else { + float u = (float) STBTT_sqrt(-p/3); + float v = (float) STBTT_acos(-STBTT_sqrt(-27/p3) * q / 2) / 3; // p3 must be negative, since d is negative + float m = (float) STBTT_cos(v); + float n = (float) STBTT_cos(v-3.141592/2)*1.732050808f; + r[0] = s + u * 2 * m; + r[1] = s - u * (m + n); + r[2] = s - u * (m - n); + + //STBTT_assert( STBTT_fabs(((r[0]+a)*r[0]+b)*r[0]+c) < 0.05f); // these asserts may not be safe at all scales, though they're in bezier t parameter units so maybe? + //STBTT_assert( STBTT_fabs(((r[1]+a)*r[1]+b)*r[1]+c) < 0.05f); + //STBTT_assert( STBTT_fabs(((r[2]+a)*r[2]+b)*r[2]+c) < 0.05f); + return 3; + } +} + +STBTT_DEF unsigned char * stbtt_GetGlyphSDF(const stbtt_fontinfo *info, float scale, int glyph, int padding, unsigned char onedge_value, float pixel_dist_scale, int *width, int *height, int *xoff, int *yoff) +{ + float scale_x = scale, scale_y = scale; + int ix0,iy0,ix1,iy1; + int w,h; + unsigned char *data; + + if (scale == 0) return NULL; + + stbtt_GetGlyphBitmapBoxSubpixel(info, glyph, scale, scale, 0.0f,0.0f, &ix0,&iy0,&ix1,&iy1); + + // if empty, return NULL + if (ix0 == ix1 || iy0 == iy1) + return NULL; + + ix0 -= padding; + iy0 -= padding; + ix1 += padding; + iy1 += padding; + + w = (ix1 - ix0); + h = (iy1 - iy0); + + if (width ) *width = w; + if (height) *height = h; + if (xoff ) *xoff = ix0; + if (yoff ) *yoff = iy0; + + // invert for y-downwards bitmaps + scale_y = -scale_y; + + { + // distance from singular values (in the same units as the pixel grid) + const float eps = 1./1024, eps2 = eps*eps; + int x,y,i,j; + float *precompute; + stbtt_vertex *verts; + int num_verts = stbtt_GetGlyphShape(info, glyph, &verts); + data = (unsigned char *) STBTT_malloc(w * h, info->userdata); + precompute = (float *) STBTT_malloc(num_verts * sizeof(float), info->userdata); + + for (i=0,j=num_verts-1; i < num_verts; j=i++) { + if (verts[i].type == STBTT_vline) { + float x0 = verts[i].x*scale_x, y0 = verts[i].y*scale_y; + float x1 = verts[j].x*scale_x, y1 = verts[j].y*scale_y; + float dist = (float) STBTT_sqrt((x1-x0)*(x1-x0) + (y1-y0)*(y1-y0)); + precompute[i] = (dist < eps) ? 0.0f : 1.0f / dist; + } else if (verts[i].type == STBTT_vcurve) { + float x2 = verts[j].x *scale_x, y2 = verts[j].y *scale_y; + float x1 = verts[i].cx*scale_x, y1 = verts[i].cy*scale_y; + float x0 = verts[i].x *scale_x, y0 = verts[i].y *scale_y; + float bx = x0 - 2*x1 + x2, by = y0 - 2*y1 + y2; + float len2 = bx*bx + by*by; + if (len2 >= eps2) + precompute[i] = 1.0f / len2; + else + precompute[i] = 0.0f; + } else + precompute[i] = 0.0f; + } + + for (y=iy0; y < iy1; ++y) { + for (x=ix0; x < ix1; ++x) { + float val; + float min_dist = 999999.0f; + float sx = (float) x + 0.5f; + float sy = (float) y + 0.5f; + float x_gspace = (sx / scale_x); + float y_gspace = (sy / scale_y); + + int winding = stbtt__compute_crossings_x(x_gspace, y_gspace, num_verts, verts); // @OPTIMIZE: this could just be a rasterization, but needs to be line vs. non-tesselated curves so a new path + + for (i=0; i < num_verts; ++i) { + float x0 = verts[i].x*scale_x, y0 = verts[i].y*scale_y; + + if (verts[i].type == STBTT_vline && precompute[i] != 0.0f) { + float x1 = verts[i-1].x*scale_x, y1 = verts[i-1].y*scale_y; + + float dist,dist2 = (x0-sx)*(x0-sx) + (y0-sy)*(y0-sy); + if (dist2 < min_dist*min_dist) + min_dist = (float) STBTT_sqrt(dist2); + + // coarse culling against bbox + //if (sx > STBTT_min(x0,x1)-min_dist && sx < STBTT_max(x0,x1)+min_dist && + // sy > STBTT_min(y0,y1)-min_dist && sy < STBTT_max(y0,y1)+min_dist) + dist = (float) STBTT_fabs((x1-x0)*(y0-sy) - (y1-y0)*(x0-sx)) * precompute[i]; + STBTT_assert(i != 0); + if (dist < min_dist) { + // check position along line + // x' = x0 + t*(x1-x0), y' = y0 + t*(y1-y0) + // minimize (x'-sx)*(x'-sx)+(y'-sy)*(y'-sy) + float dx = x1-x0, dy = y1-y0; + float px = x0-sx, py = y0-sy; + // minimize (px+t*dx)^2 + (py+t*dy)^2 = px*px + 2*px*dx*t + t^2*dx*dx + py*py + 2*py*dy*t + t^2*dy*dy + // derivative: 2*px*dx + 2*py*dy + (2*dx*dx+2*dy*dy)*t, set to 0 and solve + float t = -(px*dx + py*dy) / (dx*dx + dy*dy); + if (t >= 0.0f && t <= 1.0f) + min_dist = dist; + } + } else if (verts[i].type == STBTT_vcurve) { + float x2 = verts[i-1].x *scale_x, y2 = verts[i-1].y *scale_y; + float x1 = verts[i ].cx*scale_x, y1 = verts[i ].cy*scale_y; + float box_x0 = STBTT_min(STBTT_min(x0,x1),x2); + float box_y0 = STBTT_min(STBTT_min(y0,y1),y2); + float box_x1 = STBTT_max(STBTT_max(x0,x1),x2); + float box_y1 = STBTT_max(STBTT_max(y0,y1),y2); + // coarse culling against bbox to avoid computing cubic unnecessarily + if (sx > box_x0-min_dist && sx < box_x1+min_dist && sy > box_y0-min_dist && sy < box_y1+min_dist) { + int num=0; + float ax = x1-x0, ay = y1-y0; + float bx = x0 - 2*x1 + x2, by = y0 - 2*y1 + y2; + float mx = x0 - sx, my = y0 - sy; + float res[3] = {0.f,0.f,0.f}; + float px,py,t,it,dist2; + float a_inv = precompute[i]; + if (a_inv == 0.0) { // if a_inv is 0, it's 2nd degree so use quadratic formula + float a = 3*(ax*bx + ay*by); + float b = 2*(ax*ax + ay*ay) + (mx*bx+my*by); + float c = mx*ax+my*ay; + if (STBTT_fabs(a) < eps2) { // if a is 0, it's linear + if (STBTT_fabs(b) >= eps2) { + res[num++] = -c/b; + } + } else { + float discriminant = b*b - 4*a*c; + if (discriminant < 0) + num = 0; + else { + float root = (float) STBTT_sqrt(discriminant); + res[0] = (-b - root)/(2*a); + res[1] = (-b + root)/(2*a); + num = 2; // don't bother distinguishing 1-solution case, as code below will still work + } + } + } else { + float b = 3*(ax*bx + ay*by) * a_inv; // could precompute this as it doesn't depend on sample point + float c = (2*(ax*ax + ay*ay) + (mx*bx+my*by)) * a_inv; + float d = (mx*ax+my*ay) * a_inv; + num = stbtt__solve_cubic(b, c, d, res); + } + dist2 = (x0-sx)*(x0-sx) + (y0-sy)*(y0-sy); + if (dist2 < min_dist*min_dist) + min_dist = (float) STBTT_sqrt(dist2); + + if (num >= 1 && res[0] >= 0.0f && res[0] <= 1.0f) { + t = res[0], it = 1.0f - t; + px = it*it*x0 + 2*t*it*x1 + t*t*x2; + py = it*it*y0 + 2*t*it*y1 + t*t*y2; + dist2 = (px-sx)*(px-sx) + (py-sy)*(py-sy); + if (dist2 < min_dist * min_dist) + min_dist = (float) STBTT_sqrt(dist2); + } + if (num >= 2 && res[1] >= 0.0f && res[1] <= 1.0f) { + t = res[1], it = 1.0f - t; + px = it*it*x0 + 2*t*it*x1 + t*t*x2; + py = it*it*y0 + 2*t*it*y1 + t*t*y2; + dist2 = (px-sx)*(px-sx) + (py-sy)*(py-sy); + if (dist2 < min_dist * min_dist) + min_dist = (float) STBTT_sqrt(dist2); + } + if (num >= 3 && res[2] >= 0.0f && res[2] <= 1.0f) { + t = res[2], it = 1.0f - t; + px = it*it*x0 + 2*t*it*x1 + t*t*x2; + py = it*it*y0 + 2*t*it*y1 + t*t*y2; + dist2 = (px-sx)*(px-sx) + (py-sy)*(py-sy); + if (dist2 < min_dist * min_dist) + min_dist = (float) STBTT_sqrt(dist2); + } + } + } + } + if (winding == 0) + min_dist = -min_dist; // if outside the shape, value is negative + val = onedge_value + pixel_dist_scale * min_dist; + if (val < 0) + val = 0; + else if (val > 255) + val = 255; + data[(y-iy0)*w+(x-ix0)] = (unsigned char) val; + } + } + STBTT_free(precompute, info->userdata); + STBTT_free(verts, info->userdata); + } + return data; +} + +STBTT_DEF unsigned char * stbtt_GetCodepointSDF(const stbtt_fontinfo *info, float scale, int codepoint, int padding, unsigned char onedge_value, float pixel_dist_scale, int *width, int *height, int *xoff, int *yoff) +{ + return stbtt_GetGlyphSDF(info, scale, stbtt_FindGlyphIndex(info, codepoint), padding, onedge_value, pixel_dist_scale, width, height, xoff, yoff); +} + +STBTT_DEF void stbtt_FreeSDF(unsigned char *bitmap, void *userdata) +{ + STBTT_free(bitmap, userdata); +} + +////////////////////////////////////////////////////////////////////////////// +// +// font name matching -- recommended not to use this +// + +// check if a utf8 string contains a prefix which is the utf16 string; if so return length of matching utf8 string +static stbtt_int32 stbtt__CompareUTF8toUTF16_bigendian_prefix(stbtt_uint8 *s1, stbtt_int32 len1, stbtt_uint8 *s2, stbtt_int32 len2) +{ + stbtt_int32 i=0; + + // convert utf16 to utf8 and compare the results while converting + while (len2) { + stbtt_uint16 ch = s2[0]*256 + s2[1]; + if (ch < 0x80) { + if (i >= len1) return -1; + if (s1[i++] != ch) return -1; + } else if (ch < 0x800) { + if (i+1 >= len1) return -1; + if (s1[i++] != 0xc0 + (ch >> 6)) return -1; + if (s1[i++] != 0x80 + (ch & 0x3f)) return -1; + } else if (ch >= 0xd800 && ch < 0xdc00) { + stbtt_uint32 c; + stbtt_uint16 ch2 = s2[2]*256 + s2[3]; + if (i+3 >= len1) return -1; + c = ((ch - 0xd800) << 10) + (ch2 - 0xdc00) + 0x10000; + if (s1[i++] != 0xf0 + (c >> 18)) return -1; + if (s1[i++] != 0x80 + ((c >> 12) & 0x3f)) return -1; + if (s1[i++] != 0x80 + ((c >> 6) & 0x3f)) return -1; + if (s1[i++] != 0x80 + ((c ) & 0x3f)) return -1; + s2 += 2; // plus another 2 below + len2 -= 2; + } else if (ch >= 0xdc00 && ch < 0xe000) { + return -1; + } else { + if (i+2 >= len1) return -1; + if (s1[i++] != 0xe0 + (ch >> 12)) return -1; + if (s1[i++] != 0x80 + ((ch >> 6) & 0x3f)) return -1; + if (s1[i++] != 0x80 + ((ch ) & 0x3f)) return -1; + } + s2 += 2; + len2 -= 2; + } + return i; +} + +static int stbtt_CompareUTF8toUTF16_bigendian_internal(char *s1, int len1, char *s2, int len2) +{ + return len1 == stbtt__CompareUTF8toUTF16_bigendian_prefix((stbtt_uint8*) s1, len1, (stbtt_uint8*) s2, len2); +} + +// returns results in whatever encoding you request... but note that 2-byte encodings +// will be BIG-ENDIAN... use stbtt_CompareUTF8toUTF16_bigendian() to compare +STBTT_DEF const char *stbtt_GetFontNameString(const stbtt_fontinfo *font, int *length, int platformID, int encodingID, int languageID, int nameID) +{ + stbtt_int32 i,count,stringOffset; + stbtt_uint8 *fc = font->data; + stbtt_uint32 offset = font->fontstart; + stbtt_uint32 nm = stbtt__find_table(fc, offset, "name"); + if (!nm) return NULL; + + count = ttUSHORT(fc+nm+2); + stringOffset = nm + ttUSHORT(fc+nm+4); + for (i=0; i < count; ++i) { + stbtt_uint32 loc = nm + 6 + 12 * i; + if (platformID == ttUSHORT(fc+loc+0) && encodingID == ttUSHORT(fc+loc+2) + && languageID == ttUSHORT(fc+loc+4) && nameID == ttUSHORT(fc+loc+6)) { + *length = ttUSHORT(fc+loc+8); + return (const char *) (fc+stringOffset+ttUSHORT(fc+loc+10)); + } + } + return NULL; +} + +static int stbtt__matchpair(stbtt_uint8 *fc, stbtt_uint32 nm, stbtt_uint8 *name, stbtt_int32 nlen, stbtt_int32 target_id, stbtt_int32 next_id) +{ + stbtt_int32 i; + stbtt_int32 count = ttUSHORT(fc+nm+2); + stbtt_int32 stringOffset = nm + ttUSHORT(fc+nm+4); + + for (i=0; i < count; ++i) { + stbtt_uint32 loc = nm + 6 + 12 * i; + stbtt_int32 id = ttUSHORT(fc+loc+6); + if (id == target_id) { + // find the encoding + stbtt_int32 platform = ttUSHORT(fc+loc+0), encoding = ttUSHORT(fc+loc+2), language = ttUSHORT(fc+loc+4); + + // is this a Unicode encoding? + if (platform == 0 || (platform == 3 && encoding == 1) || (platform == 3 && encoding == 10)) { + stbtt_int32 slen = ttUSHORT(fc+loc+8); + stbtt_int32 off = ttUSHORT(fc+loc+10); + + // check if there's a prefix match + stbtt_int32 matchlen = stbtt__CompareUTF8toUTF16_bigendian_prefix(name, nlen, fc+stringOffset+off,slen); + if (matchlen >= 0) { + // check for target_id+1 immediately following, with same encoding & language + if (i+1 < count && ttUSHORT(fc+loc+12+6) == next_id && ttUSHORT(fc+loc+12) == platform && ttUSHORT(fc+loc+12+2) == encoding && ttUSHORT(fc+loc+12+4) == language) { + slen = ttUSHORT(fc+loc+12+8); + off = ttUSHORT(fc+loc+12+10); + if (slen == 0) { + if (matchlen == nlen) + return 1; + } else if (matchlen < nlen && name[matchlen] == ' ') { + ++matchlen; + if (stbtt_CompareUTF8toUTF16_bigendian_internal((char*) (name+matchlen), nlen-matchlen, (char*)(fc+stringOffset+off),slen)) + return 1; + } + } else { + // if nothing immediately following + if (matchlen == nlen) + return 1; + } + } + } + + // @TODO handle other encodings + } + } + return 0; +} + +static int stbtt__matches(stbtt_uint8 *fc, stbtt_uint32 offset, stbtt_uint8 *name, stbtt_int32 flags) +{ + stbtt_int32 nlen = (stbtt_int32) STBTT_strlen((char *) name); + stbtt_uint32 nm,hd; + if (!stbtt__isfont(fc+offset)) return 0; + + // check italics/bold/underline flags in macStyle... + if (flags) { + hd = stbtt__find_table(fc, offset, "head"); + if ((ttUSHORT(fc+hd+44) & 7) != (flags & 7)) return 0; + } + + nm = stbtt__find_table(fc, offset, "name"); + if (!nm) return 0; + + if (flags) { + // if we checked the macStyle flags, then just check the family and ignore the subfamily + if (stbtt__matchpair(fc, nm, name, nlen, 16, -1)) return 1; + if (stbtt__matchpair(fc, nm, name, nlen, 1, -1)) return 1; + if (stbtt__matchpair(fc, nm, name, nlen, 3, -1)) return 1; + } else { + if (stbtt__matchpair(fc, nm, name, nlen, 16, 17)) return 1; + if (stbtt__matchpair(fc, nm, name, nlen, 1, 2)) return 1; + if (stbtt__matchpair(fc, nm, name, nlen, 3, -1)) return 1; + } + + return 0; +} + +static int stbtt_FindMatchingFont_internal(unsigned char *font_collection, char *name_utf8, stbtt_int32 flags) +{ + stbtt_int32 i; + for (i=0;;++i) { + stbtt_int32 off = stbtt_GetFontOffsetForIndex(font_collection, i); + if (off < 0) return off; + if (stbtt__matches((stbtt_uint8 *) font_collection, off, (stbtt_uint8*) name_utf8, flags)) + return off; + } +} + +#if defined(__GNUC__) || defined(__clang__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wcast-qual" +#endif + +STBTT_DEF int stbtt_BakeFontBitmap(const unsigned char *data, int offset, + float pixel_height, unsigned char *pixels, int pw, int ph, + int first_char, int num_chars, stbtt_bakedchar *chardata) +{ + return stbtt_BakeFontBitmap_internal((unsigned char *) data, offset, pixel_height, pixels, pw, ph, first_char, num_chars, chardata); +} + +STBTT_DEF int stbtt_GetFontOffsetForIndex(const unsigned char *data, int index) +{ + return stbtt_GetFontOffsetForIndex_internal((unsigned char *) data, index); +} + +STBTT_DEF int stbtt_GetNumberOfFonts(const unsigned char *data) +{ + return stbtt_GetNumberOfFonts_internal((unsigned char *) data); +} + +STBTT_DEF int stbtt_InitFont(stbtt_fontinfo *info, const unsigned char *data, int offset) +{ + return stbtt_InitFont_internal(info, (unsigned char *) data, offset); +} + +STBTT_DEF int stbtt_FindMatchingFont(const unsigned char *fontdata, const char *name, int flags) +{ + return stbtt_FindMatchingFont_internal((unsigned char *) fontdata, (char *) name, flags); +} + +STBTT_DEF int stbtt_CompareUTF8toUTF16_bigendian(const char *s1, int len1, const char *s2, int len2) +{ + return stbtt_CompareUTF8toUTF16_bigendian_internal((char *) s1, len1, (char *) s2, len2); +} + +#if defined(__GNUC__) || defined(__clang__) +#pragma GCC diagnostic pop +#endif + +#endif // STB_TRUETYPE_IMPLEMENTATION + + +// FULL VERSION HISTORY +// +// 1.25 (2021-07-11) many fixes +// 1.24 (2020-02-05) fix warning +// 1.23 (2020-02-02) query SVG data for glyphs; query whole kerning table (but only kern not GPOS) +// 1.22 (2019-08-11) minimize missing-glyph duplication; fix kerning if both 'GPOS' and 'kern' are defined +// 1.21 (2019-02-25) fix warning +// 1.20 (2019-02-07) PackFontRange skips missing codepoints; GetScaleFontVMetrics() +// 1.19 (2018-02-11) OpenType GPOS kerning (horizontal only), STBTT_fmod +// 1.18 (2018-01-29) add missing function +// 1.17 (2017-07-23) make more arguments const; doc fix +// 1.16 (2017-07-12) SDF support +// 1.15 (2017-03-03) make more arguments const +// 1.14 (2017-01-16) num-fonts-in-TTC function +// 1.13 (2017-01-02) support OpenType fonts, certain Apple fonts +// 1.12 (2016-10-25) suppress warnings about casting away const with -Wcast-qual +// 1.11 (2016-04-02) fix unused-variable warning +// 1.10 (2016-04-02) allow user-defined fabs() replacement +// fix memory leak if fontsize=0.0 +// fix warning from duplicate typedef +// 1.09 (2016-01-16) warning fix; avoid crash on outofmem; use alloc userdata for PackFontRanges +// 1.08 (2015-09-13) document stbtt_Rasterize(); fixes for vertical & horizontal edges +// 1.07 (2015-08-01) allow PackFontRanges to accept arrays of sparse codepoints; +// allow PackFontRanges to pack and render in separate phases; +// fix stbtt_GetFontOFfsetForIndex (never worked for non-0 input?); +// fixed an assert() bug in the new rasterizer +// replace assert() with STBTT_assert() in new rasterizer +// 1.06 (2015-07-14) performance improvements (~35% faster on x86 and x64 on test machine) +// also more precise AA rasterizer, except if shapes overlap +// remove need for STBTT_sort +// 1.05 (2015-04-15) fix misplaced definitions for STBTT_STATIC +// 1.04 (2015-04-15) typo in example +// 1.03 (2015-04-12) STBTT_STATIC, fix memory leak in new packing, various fixes +// 1.02 (2014-12-10) fix various warnings & compile issues w/ stb_rect_pack, C++ +// 1.01 (2014-12-08) fix subpixel position when oversampling to exactly match +// non-oversampled; STBTT_POINT_SIZE for packed case only +// 1.00 (2014-12-06) add new PackBegin etc. API, w/ support for oversampling +// 0.99 (2014-09-18) fix multiple bugs with subpixel rendering (ryg) +// 0.9 (2014-08-07) support certain mac/iOS fonts without an MS platformID +// 0.8b (2014-07-07) fix a warning +// 0.8 (2014-05-25) fix a few more warnings +// 0.7 (2013-09-25) bugfix: subpixel glyph bug fixed in 0.5 had come back +// 0.6c (2012-07-24) improve documentation +// 0.6b (2012-07-20) fix a few more warnings +// 0.6 (2012-07-17) fix warnings; added stbtt_ScaleForMappingEmToPixels, +// stbtt_GetFontBoundingBox, stbtt_IsGlyphEmpty +// 0.5 (2011-12-09) bugfixes: +// subpixel glyph renderer computed wrong bounding box +// first vertex of shape can be off-curve (FreeSans) +// 0.4b (2011-12-03) fixed an error in the font baking example +// 0.4 (2011-12-01) kerning, subpixel rendering (tor) +// bugfixes for: +// codepoint-to-glyph conversion using table fmt=12 +// codepoint-to-glyph conversion using table fmt=4 +// stbtt_GetBakedQuad with non-square texture (Zer) +// updated Hello World! sample to use kerning and subpixel +// fixed some warnings +// 0.3 (2009-06-24) cmap fmt=12, compound shapes (MM) +// userdata, malloc-from-userdata, non-zero fill (stb) +// 0.2 (2009-03-11) Fix unsigned/signed char warnings +// 0.1 (2009-03-09) First public release +// + +/* +------------------------------------------------------------------------------ +This software is available under 2 licenses -- choose whichever you prefer. +------------------------------------------------------------------------------ +ALTERNATIVE A - MIT License +Copyright (c) 2017 Sean Barrett +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is furnished to do +so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +------------------------------------------------------------------------------ +ALTERNATIVE B - Public Domain (www.unlicense.org) +This is free and unencumbered software released into the public domain. +Anyone is free to copy, modify, publish, use, compile, sell, or distribute this +software, either in source code form or as a compiled binary, for any purpose, +commercial or non-commercial, and by any means. +In jurisdictions that recognize copyright laws, the author or authors of this +software dedicate any and all copyright interest in the software to the public +domain. We make this dedication for the benefit of the public at large and to +the detriment of our heirs and successors. We intend this dedication to be an +overt act of relinquishment in perpetuity of all present and future rights to +this software under copyright law. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN +ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +------------------------------------------------------------------------------ +*/ diff --git a/tests/data/c/stb/stb_vorbis.c b/tests/data/c/stb/stb_vorbis.c new file mode 100644 index 000000000..3e5c2504c --- /dev/null +++ b/tests/data/c/stb/stb_vorbis.c @@ -0,0 +1,5584 @@ +// Ogg Vorbis audio decoder - v1.22 - public domain +// http://nothings.org/stb_vorbis/ +// +// Original version written by Sean Barrett in 2007. +// +// Originally sponsored by RAD Game Tools. Seeking implementation +// sponsored by Phillip Bennefall, Marc Andersen, Aaron Baker, +// Elias Software, Aras Pranckevicius, and Sean Barrett. +// +// LICENSE +// +// See end of file for license information. +// +// Limitations: +// +// - floor 0 not supported (used in old ogg vorbis files pre-2004) +// - lossless sample-truncation at beginning ignored +// - cannot concatenate multiple vorbis streams +// - sample positions are 32-bit, limiting seekable 192Khz +// files to around 6 hours (Ogg supports 64-bit) +// +// Feature contributors: +// Dougall Johnson (sample-exact seeking) +// +// Bugfix/warning contributors: +// Terje Mathisen Niklas Frykholm Andy Hill +// Casey Muratori John Bolton Gargaj +// Laurent Gomila Marc LeBlanc Ronny Chevalier +// Bernhard Wodo Evan Balster github:alxprd +// Tom Beaumont Ingo Leitgeb Nicolas Guillemot +// Phillip Bennefall Rohit Thiago Goulart +// github:manxorist Saga Musix github:infatum +// Timur Gagiev Maxwell Koo Peter Waller +// github:audinowho Dougall Johnson David Reid +// github:Clownacy Pedro J. Estebanez Remi Verschelde +// AnthoFoxo github:morlat Gabriel Ravier +// +// Partial history: +// 1.22 - 2021-07-11 - various small fixes +// 1.21 - 2021-07-02 - fix bug for files with no comments +// 1.20 - 2020-07-11 - several small fixes +// 1.19 - 2020-02-05 - warnings +// 1.18 - 2020-02-02 - fix seek bugs; parse header comments; misc warnings etc. +// 1.17 - 2019-07-08 - fix CVE-2019-13217..CVE-2019-13223 (by ForAllSecure) +// 1.16 - 2019-03-04 - fix warnings +// 1.15 - 2019-02-07 - explicit failure if Ogg Skeleton data is found +// 1.14 - 2018-02-11 - delete bogus dealloca usage +// 1.13 - 2018-01-29 - fix truncation of last frame (hopefully) +// 1.12 - 2017-11-21 - limit residue begin/end to blocksize/2 to avoid large temp allocs in bad/corrupt files +// 1.11 - 2017-07-23 - fix MinGW compilation +// 1.10 - 2017-03-03 - more robust seeking; fix negative ilog(); clear error in open_memory +// 1.09 - 2016-04-04 - back out 'truncation of last frame' fix from previous version +// 1.08 - 2016-04-02 - warnings; setup memory leaks; truncation of last frame +// 1.07 - 2015-01-16 - fixes for crashes on invalid files; warning fixes; const +// 1.06 - 2015-08-31 - full, correct support for seeking API (Dougall Johnson) +// some crash fixes when out of memory or with corrupt files +// fix some inappropriately signed shifts +// 1.05 - 2015-04-19 - don't define __forceinline if it's redundant +// 1.04 - 2014-08-27 - fix missing const-correct case in API +// 1.03 - 2014-08-07 - warning fixes +// 1.02 - 2014-07-09 - declare qsort comparison as explicitly _cdecl in Windows +// 1.01 - 2014-06-18 - fix stb_vorbis_get_samples_float (interleaved was correct) +// 1.0 - 2014-05-26 - fix memory leaks; fix warnings; fix bugs in >2-channel; +// (API change) report sample rate for decode-full-file funcs +// +// See end of file for full version history. + + +////////////////////////////////////////////////////////////////////////////// +// +// HEADER BEGINS HERE +// + +#ifndef STB_VORBIS_INCLUDE_STB_VORBIS_H +#define STB_VORBIS_INCLUDE_STB_VORBIS_H + +#if defined(STB_VORBIS_NO_CRT) && !defined(STB_VORBIS_NO_STDIO) +#define STB_VORBIS_NO_STDIO 1 +#endif + +#ifndef STB_VORBIS_NO_STDIO +#include +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +/////////// THREAD SAFETY + +// Individual stb_vorbis* handles are not thread-safe; you cannot decode from +// them from multiple threads at the same time. However, you can have multiple +// stb_vorbis* handles and decode from them independently in multiple thrads. + + +/////////// MEMORY ALLOCATION + +// normally stb_vorbis uses malloc() to allocate memory at startup, +// and alloca() to allocate temporary memory during a frame on the +// stack. (Memory consumption will depend on the amount of setup +// data in the file and how you set the compile flags for speed +// vs. size. In my test files the maximal-size usage is ~150KB.) +// +// You can modify the wrapper functions in the source (setup_malloc, +// setup_temp_malloc, temp_malloc) to change this behavior, or you +// can use a simpler allocation model: you pass in a buffer from +// which stb_vorbis will allocate _all_ its memory (including the +// temp memory). "open" may fail with a VORBIS_outofmem if you +// do not pass in enough data; there is no way to determine how +// much you do need except to succeed (at which point you can +// query get_info to find the exact amount required. yes I know +// this is lame). +// +// If you pass in a non-NULL buffer of the type below, allocation +// will occur from it as described above. Otherwise just pass NULL +// to use malloc()/alloca() + +typedef struct +{ + char *alloc_buffer; + int alloc_buffer_length_in_bytes; +} stb_vorbis_alloc; + + +/////////// FUNCTIONS USEABLE WITH ALL INPUT MODES + +typedef struct stb_vorbis stb_vorbis; + +typedef struct +{ + unsigned int sample_rate; + int channels; + + unsigned int setup_memory_required; + unsigned int setup_temp_memory_required; + unsigned int temp_memory_required; + + int max_frame_size; +} stb_vorbis_info; + +typedef struct +{ + char *vendor; + + int comment_list_length; + char **comment_list; +} stb_vorbis_comment; + +// get general information about the file +extern stb_vorbis_info stb_vorbis_get_info(stb_vorbis *f); + +// get ogg comments +extern stb_vorbis_comment stb_vorbis_get_comment(stb_vorbis *f); + +// get the last error detected (clears it, too) +extern int stb_vorbis_get_error(stb_vorbis *f); + +// close an ogg vorbis file and free all memory in use +extern void stb_vorbis_close(stb_vorbis *f); + +// this function returns the offset (in samples) from the beginning of the +// file that will be returned by the next decode, if it is known, or -1 +// otherwise. after a flush_pushdata() call, this may take a while before +// it becomes valid again. +// NOT WORKING YET after a seek with PULLDATA API +extern int stb_vorbis_get_sample_offset(stb_vorbis *f); + +// returns the current seek point within the file, or offset from the beginning +// of the memory buffer. In pushdata mode it returns 0. +extern unsigned int stb_vorbis_get_file_offset(stb_vorbis *f); + +/////////// PUSHDATA API + +#ifndef STB_VORBIS_NO_PUSHDATA_API + +// this API allows you to get blocks of data from any source and hand +// them to stb_vorbis. you have to buffer them; stb_vorbis will tell +// you how much it used, and you have to give it the rest next time; +// and stb_vorbis may not have enough data to work with and you will +// need to give it the same data again PLUS more. Note that the Vorbis +// specification does not bound the size of an individual frame. + +extern stb_vorbis *stb_vorbis_open_pushdata( + const unsigned char * datablock, int datablock_length_in_bytes, + int *datablock_memory_consumed_in_bytes, + int *error, + const stb_vorbis_alloc *alloc_buffer); +// create a vorbis decoder by passing in the initial data block containing +// the ogg&vorbis headers (you don't need to do parse them, just provide +// the first N bytes of the file--you're told if it's not enough, see below) +// on success, returns an stb_vorbis *, does not set error, returns the amount of +// data parsed/consumed on this call in *datablock_memory_consumed_in_bytes; +// on failure, returns NULL on error and sets *error, does not change *datablock_memory_consumed +// if returns NULL and *error is VORBIS_need_more_data, then the input block was +// incomplete and you need to pass in a larger block from the start of the file + +extern int stb_vorbis_decode_frame_pushdata( + stb_vorbis *f, + const unsigned char *datablock, int datablock_length_in_bytes, + int *channels, // place to write number of float * buffers + float ***output, // place to write float ** array of float * buffers + int *samples // place to write number of output samples + ); +// decode a frame of audio sample data if possible from the passed-in data block +// +// return value: number of bytes we used from datablock +// +// possible cases: +// 0 bytes used, 0 samples output (need more data) +// N bytes used, 0 samples output (resynching the stream, keep going) +// N bytes used, M samples output (one frame of data) +// note that after opening a file, you will ALWAYS get one N-bytes,0-sample +// frame, because Vorbis always "discards" the first frame. +// +// Note that on resynch, stb_vorbis will rarely consume all of the buffer, +// instead only datablock_length_in_bytes-3 or less. This is because it wants +// to avoid missing parts of a page header if they cross a datablock boundary, +// without writing state-machiney code to record a partial detection. +// +// The number of channels returned are stored in *channels (which can be +// NULL--it is always the same as the number of channels reported by +// get_info). *output will contain an array of float* buffers, one per +// channel. In other words, (*output)[0][0] contains the first sample from +// the first channel, and (*output)[1][0] contains the first sample from +// the second channel. +// +// *output points into stb_vorbis's internal output buffer storage; these +// buffers are owned by stb_vorbis and application code should not free +// them or modify their contents. They are transient and will be overwritten +// once you ask for more data to get decoded, so be sure to grab any data +// you need before then. + +extern void stb_vorbis_flush_pushdata(stb_vorbis *f); +// inform stb_vorbis that your next datablock will not be contiguous with +// previous ones (e.g. you've seeked in the data); future attempts to decode +// frames will cause stb_vorbis to resynchronize (as noted above), and +// once it sees a valid Ogg page (typically 4-8KB, as large as 64KB), it +// will begin decoding the _next_ frame. +// +// if you want to seek using pushdata, you need to seek in your file, then +// call stb_vorbis_flush_pushdata(), then start calling decoding, then once +// decoding is returning you data, call stb_vorbis_get_sample_offset, and +// if you don't like the result, seek your file again and repeat. +#endif + + +////////// PULLING INPUT API + +#ifndef STB_VORBIS_NO_PULLDATA_API +// This API assumes stb_vorbis is allowed to pull data from a source-- +// either a block of memory containing the _entire_ vorbis stream, or a +// FILE * that you or it create, or possibly some other reading mechanism +// if you go modify the source to replace the FILE * case with some kind +// of callback to your code. (But if you don't support seeking, you may +// just want to go ahead and use pushdata.) + +#if !defined(STB_VORBIS_NO_STDIO) && !defined(STB_VORBIS_NO_INTEGER_CONVERSION) +extern int stb_vorbis_decode_filename(const char *filename, int *channels, int *sample_rate, short **output); +#endif +#if !defined(STB_VORBIS_NO_INTEGER_CONVERSION) +extern int stb_vorbis_decode_memory(const unsigned char *mem, int len, int *channels, int *sample_rate, short **output); +#endif +// decode an entire file and output the data interleaved into a malloc()ed +// buffer stored in *output. The return value is the number of samples +// decoded, or -1 if the file could not be opened or was not an ogg vorbis file. +// When you're done with it, just free() the pointer returned in *output. + +extern stb_vorbis * stb_vorbis_open_memory(const unsigned char *data, int len, + int *error, const stb_vorbis_alloc *alloc_buffer); +// create an ogg vorbis decoder from an ogg vorbis stream in memory (note +// this must be the entire stream!). on failure, returns NULL and sets *error + +#ifndef STB_VORBIS_NO_STDIO +extern stb_vorbis * stb_vorbis_open_filename(const char *filename, + int *error, const stb_vorbis_alloc *alloc_buffer); +// create an ogg vorbis decoder from a filename via fopen(). on failure, +// returns NULL and sets *error (possibly to VORBIS_file_open_failure). + +extern stb_vorbis * stb_vorbis_open_file(FILE *f, int close_handle_on_close, + int *error, const stb_vorbis_alloc *alloc_buffer); +// create an ogg vorbis decoder from an open FILE *, looking for a stream at +// the _current_ seek point (ftell). on failure, returns NULL and sets *error. +// note that stb_vorbis must "own" this stream; if you seek it in between +// calls to stb_vorbis, it will become confused. Moreover, if you attempt to +// perform stb_vorbis_seek_*() operations on this file, it will assume it +// owns the _entire_ rest of the file after the start point. Use the next +// function, stb_vorbis_open_file_section(), to limit it. + +extern stb_vorbis * stb_vorbis_open_file_section(FILE *f, int close_handle_on_close, + int *error, const stb_vorbis_alloc *alloc_buffer, unsigned int len); +// create an ogg vorbis decoder from an open FILE *, looking for a stream at +// the _current_ seek point (ftell); the stream will be of length 'len' bytes. +// on failure, returns NULL and sets *error. note that stb_vorbis must "own" +// this stream; if you seek it in between calls to stb_vorbis, it will become +// confused. +#endif + +extern int stb_vorbis_seek_frame(stb_vorbis *f, unsigned int sample_number); +extern int stb_vorbis_seek(stb_vorbis *f, unsigned int sample_number); +// these functions seek in the Vorbis file to (approximately) 'sample_number'. +// after calling seek_frame(), the next call to get_frame_*() will include +// the specified sample. after calling stb_vorbis_seek(), the next call to +// stb_vorbis_get_samples_* will start with the specified sample. If you +// do not need to seek to EXACTLY the target sample when using get_samples_*, +// you can also use seek_frame(). + +extern int stb_vorbis_seek_start(stb_vorbis *f); +// this function is equivalent to stb_vorbis_seek(f,0) + +extern unsigned int stb_vorbis_stream_length_in_samples(stb_vorbis *f); +extern float stb_vorbis_stream_length_in_seconds(stb_vorbis *f); +// these functions return the total length of the vorbis stream + +extern int stb_vorbis_get_frame_float(stb_vorbis *f, int *channels, float ***output); +// decode the next frame and return the number of samples. the number of +// channels returned are stored in *channels (which can be NULL--it is always +// the same as the number of channels reported by get_info). *output will +// contain an array of float* buffers, one per channel. These outputs will +// be overwritten on the next call to stb_vorbis_get_frame_*. +// +// You generally should not intermix calls to stb_vorbis_get_frame_*() +// and stb_vorbis_get_samples_*(), since the latter calls the former. + +#ifndef STB_VORBIS_NO_INTEGER_CONVERSION +extern int stb_vorbis_get_frame_short_interleaved(stb_vorbis *f, int num_c, short *buffer, int num_shorts); +extern int stb_vorbis_get_frame_short (stb_vorbis *f, int num_c, short **buffer, int num_samples); +#endif +// decode the next frame and return the number of *samples* per channel. +// Note that for interleaved data, you pass in the number of shorts (the +// size of your array), but the return value is the number of samples per +// channel, not the total number of samples. +// +// The data is coerced to the number of channels you request according to the +// channel coercion rules (see below). You must pass in the size of your +// buffer(s) so that stb_vorbis will not overwrite the end of the buffer. +// The maximum buffer size needed can be gotten from get_info(); however, +// the Vorbis I specification implies an absolute maximum of 4096 samples +// per channel. + +// Channel coercion rules: +// Let M be the number of channels requested, and N the number of channels present, +// and Cn be the nth channel; let stereo L be the sum of all L and center channels, +// and stereo R be the sum of all R and center channels (channel assignment from the +// vorbis spec). +// M N output +// 1 k sum(Ck) for all k +// 2 * stereo L, stereo R +// k l k > l, the first l channels, then 0s +// k l k <= l, the first k channels +// Note that this is not _good_ surround etc. mixing at all! It's just so +// you get something useful. + +extern int stb_vorbis_get_samples_float_interleaved(stb_vorbis *f, int channels, float *buffer, int num_floats); +extern int stb_vorbis_get_samples_float(stb_vorbis *f, int channels, float **buffer, int num_samples); +// gets num_samples samples, not necessarily on a frame boundary--this requires +// buffering so you have to supply the buffers. DOES NOT APPLY THE COERCION RULES. +// Returns the number of samples stored per channel; it may be less than requested +// at the end of the file. If there are no more samples in the file, returns 0. + +#ifndef STB_VORBIS_NO_INTEGER_CONVERSION +extern int stb_vorbis_get_samples_short_interleaved(stb_vorbis *f, int channels, short *buffer, int num_shorts); +extern int stb_vorbis_get_samples_short(stb_vorbis *f, int channels, short **buffer, int num_samples); +#endif +// gets num_samples samples, not necessarily on a frame boundary--this requires +// buffering so you have to supply the buffers. Applies the coercion rules above +// to produce 'channels' channels. Returns the number of samples stored per channel; +// it may be less than requested at the end of the file. If there are no more +// samples in the file, returns 0. + +#endif + +//////// ERROR CODES + +enum STBVorbisError +{ + VORBIS__no_error, + + VORBIS_need_more_data=1, // not a real error + + VORBIS_invalid_api_mixing, // can't mix API modes + VORBIS_outofmem, // not enough memory + VORBIS_feature_not_supported, // uses floor 0 + VORBIS_too_many_channels, // STB_VORBIS_MAX_CHANNELS is too small + VORBIS_file_open_failure, // fopen() failed + VORBIS_seek_without_length, // can't seek in unknown-length file + + VORBIS_unexpected_eof=10, // file is truncated? + VORBIS_seek_invalid, // seek past EOF + + // decoding errors (corrupt/invalid stream) -- you probably + // don't care about the exact details of these + + // vorbis errors: + VORBIS_invalid_setup=20, + VORBIS_invalid_stream, + + // ogg errors: + VORBIS_missing_capture_pattern=30, + VORBIS_invalid_stream_structure_version, + VORBIS_continued_packet_flag_invalid, + VORBIS_incorrect_stream_serial_number, + VORBIS_invalid_first_page, + VORBIS_bad_packet_type, + VORBIS_cant_find_last_page, + VORBIS_seek_failed, + VORBIS_ogg_skeleton_not_supported +}; + + +#ifdef __cplusplus +} +#endif + +#endif // STB_VORBIS_INCLUDE_STB_VORBIS_H +// +// HEADER ENDS HERE +// +////////////////////////////////////////////////////////////////////////////// + +#ifndef STB_VORBIS_HEADER_ONLY + +// global configuration settings (e.g. set these in the project/makefile), +// or just set them in this file at the top (although ideally the first few +// should be visible when the header file is compiled too, although it's not +// crucial) + +// STB_VORBIS_NO_PUSHDATA_API +// does not compile the code for the various stb_vorbis_*_pushdata() +// functions +// #define STB_VORBIS_NO_PUSHDATA_API + +// STB_VORBIS_NO_PULLDATA_API +// does not compile the code for the non-pushdata APIs +// #define STB_VORBIS_NO_PULLDATA_API + +// STB_VORBIS_NO_STDIO +// does not compile the code for the APIs that use FILE *s internally +// or externally (implied by STB_VORBIS_NO_PULLDATA_API) +// #define STB_VORBIS_NO_STDIO + +// STB_VORBIS_NO_INTEGER_CONVERSION +// does not compile the code for converting audio sample data from +// float to integer (implied by STB_VORBIS_NO_PULLDATA_API) +// #define STB_VORBIS_NO_INTEGER_CONVERSION + +// STB_VORBIS_NO_FAST_SCALED_FLOAT +// does not use a fast float-to-int trick to accelerate float-to-int on +// most platforms which requires endianness be defined correctly. +//#define STB_VORBIS_NO_FAST_SCALED_FLOAT + + +// STB_VORBIS_MAX_CHANNELS [number] +// globally define this to the maximum number of channels you need. +// The spec does not put a restriction on channels except that +// the count is stored in a byte, so 255 is the hard limit. +// Reducing this saves about 16 bytes per value, so using 16 saves +// (255-16)*16 or around 4KB. Plus anything other memory usage +// I forgot to account for. Can probably go as low as 8 (7.1 audio), +// 6 (5.1 audio), or 2 (stereo only). +#ifndef STB_VORBIS_MAX_CHANNELS +#define STB_VORBIS_MAX_CHANNELS 16 // enough for anyone? +#endif + +// STB_VORBIS_PUSHDATA_CRC_COUNT [number] +// after a flush_pushdata(), stb_vorbis begins scanning for the +// next valid page, without backtracking. when it finds something +// that looks like a page, it streams through it and verifies its +// CRC32. Should that validation fail, it keeps scanning. But it's +// possible that _while_ streaming through to check the CRC32 of +// one candidate page, it sees another candidate page. This #define +// determines how many "overlapping" candidate pages it can search +// at once. Note that "real" pages are typically ~4KB to ~8KB, whereas +// garbage pages could be as big as 64KB, but probably average ~16KB. +// So don't hose ourselves by scanning an apparent 64KB page and +// missing a ton of real ones in the interim; so minimum of 2 +#ifndef STB_VORBIS_PUSHDATA_CRC_COUNT +#define STB_VORBIS_PUSHDATA_CRC_COUNT 4 +#endif + +// STB_VORBIS_FAST_HUFFMAN_LENGTH [number] +// sets the log size of the huffman-acceleration table. Maximum +// supported value is 24. with larger numbers, more decodings are O(1), +// but the table size is larger so worse cache missing, so you'll have +// to probe (and try multiple ogg vorbis files) to find the sweet spot. +#ifndef STB_VORBIS_FAST_HUFFMAN_LENGTH +#define STB_VORBIS_FAST_HUFFMAN_LENGTH 10 +#endif + +// STB_VORBIS_FAST_BINARY_LENGTH [number] +// sets the log size of the binary-search acceleration table. this +// is used in similar fashion to the fast-huffman size to set initial +// parameters for the binary search + +// STB_VORBIS_FAST_HUFFMAN_INT +// The fast huffman tables are much more efficient if they can be +// stored as 16-bit results instead of 32-bit results. This restricts +// the codebooks to having only 65535 possible outcomes, though. +// (At least, accelerated by the huffman table.) +#ifndef STB_VORBIS_FAST_HUFFMAN_INT +#define STB_VORBIS_FAST_HUFFMAN_SHORT +#endif + +// STB_VORBIS_NO_HUFFMAN_BINARY_SEARCH +// If the 'fast huffman' search doesn't succeed, then stb_vorbis falls +// back on binary searching for the correct one. This requires storing +// extra tables with the huffman codes in sorted order. Defining this +// symbol trades off space for speed by forcing a linear search in the +// non-fast case, except for "sparse" codebooks. +// #define STB_VORBIS_NO_HUFFMAN_BINARY_SEARCH + +// STB_VORBIS_DIVIDES_IN_RESIDUE +// stb_vorbis precomputes the result of the scalar residue decoding +// that would otherwise require a divide per chunk. you can trade off +// space for time by defining this symbol. +// #define STB_VORBIS_DIVIDES_IN_RESIDUE + +// STB_VORBIS_DIVIDES_IN_CODEBOOK +// vorbis VQ codebooks can be encoded two ways: with every case explicitly +// stored, or with all elements being chosen from a small range of values, +// and all values possible in all elements. By default, stb_vorbis expands +// this latter kind out to look like the former kind for ease of decoding, +// because otherwise an integer divide-per-vector-element is required to +// unpack the index. If you define STB_VORBIS_DIVIDES_IN_CODEBOOK, you can +// trade off storage for speed. +//#define STB_VORBIS_DIVIDES_IN_CODEBOOK + +#ifdef STB_VORBIS_CODEBOOK_SHORTS +#error "STB_VORBIS_CODEBOOK_SHORTS is no longer supported as it produced incorrect results for some input formats" +#endif + +// STB_VORBIS_DIVIDE_TABLE +// this replaces small integer divides in the floor decode loop with +// table lookups. made less than 1% difference, so disabled by default. + +// STB_VORBIS_NO_INLINE_DECODE +// disables the inlining of the scalar codebook fast-huffman decode. +// might save a little codespace; useful for debugging +// #define STB_VORBIS_NO_INLINE_DECODE + +// STB_VORBIS_NO_DEFER_FLOOR +// Normally we only decode the floor without synthesizing the actual +// full curve. We can instead synthesize the curve immediately. This +// requires more memory and is very likely slower, so I don't think +// you'd ever want to do it except for debugging. +// #define STB_VORBIS_NO_DEFER_FLOOR + + + + +////////////////////////////////////////////////////////////////////////////// + +#ifdef STB_VORBIS_NO_PULLDATA_API + #define STB_VORBIS_NO_INTEGER_CONVERSION + #define STB_VORBIS_NO_STDIO +#endif + +#if defined(STB_VORBIS_NO_CRT) && !defined(STB_VORBIS_NO_STDIO) + #define STB_VORBIS_NO_STDIO 1 +#endif + +#ifndef STB_VORBIS_NO_INTEGER_CONVERSION +#ifndef STB_VORBIS_NO_FAST_SCALED_FLOAT + + // only need endianness for fast-float-to-int, which we don't + // use for pushdata + + #ifndef STB_VORBIS_BIG_ENDIAN + #define STB_VORBIS_ENDIAN 0 + #else + #define STB_VORBIS_ENDIAN 1 + #endif + +#endif +#endif + + +#ifndef STB_VORBIS_NO_STDIO +#include +#endif + +#ifndef STB_VORBIS_NO_CRT + #include + #include + #include + #include + + // find definition of alloca if it's not in stdlib.h: + #if defined(_MSC_VER) || defined(__MINGW32__) + #include + #endif + #if defined(__linux__) || defined(__linux) || defined(__sun__) || defined(__EMSCRIPTEN__) || defined(__NEWLIB__) + #include + #endif +#else // STB_VORBIS_NO_CRT + #define NULL 0 + #define malloc(s) 0 + #define free(s) ((void) 0) + #define realloc(s) 0 +#endif // STB_VORBIS_NO_CRT + +#include + +#ifdef __MINGW32__ + // eff you mingw: + // "fixed": + // http://sourceforge.net/p/mingw-w64/mailman/message/32882927/ + // "no that broke the build, reverted, who cares about C": + // http://sourceforge.net/p/mingw-w64/mailman/message/32890381/ + #ifdef __forceinline + #undef __forceinline + #endif + #define __forceinline + #ifndef alloca + #define alloca __builtin_alloca + #endif +#elif !defined(_MSC_VER) + #if __GNUC__ + #define __forceinline inline + #else + #define __forceinline + #endif +#endif + +#if STB_VORBIS_MAX_CHANNELS > 256 +#error "Value of STB_VORBIS_MAX_CHANNELS outside of allowed range" +#endif + +#if STB_VORBIS_FAST_HUFFMAN_LENGTH > 24 +#error "Value of STB_VORBIS_FAST_HUFFMAN_LENGTH outside of allowed range" +#endif + + +#if 0 +#include +#define CHECK(f) _CrtIsValidHeapPointer(f->channel_buffers[1]) +#else +#define CHECK(f) ((void) 0) +#endif + +#define MAX_BLOCKSIZE_LOG 13 // from specification +#define MAX_BLOCKSIZE (1 << MAX_BLOCKSIZE_LOG) + + +typedef unsigned char uint8; +typedef signed char int8; +typedef unsigned short uint16; +typedef signed short int16; +typedef unsigned int uint32; +typedef signed int int32; + +#ifndef TRUE +#define TRUE 1 +#define FALSE 0 +#endif + +typedef float codetype; + +#ifdef _MSC_VER +#define STBV_NOTUSED(v) (void)(v) +#else +#define STBV_NOTUSED(v) (void)sizeof(v) +#endif + +// @NOTE +// +// Some arrays below are tagged "//varies", which means it's actually +// a variable-sized piece of data, but rather than malloc I assume it's +// small enough it's better to just allocate it all together with the +// main thing +// +// Most of the variables are specified with the smallest size I could pack +// them into. It might give better performance to make them all full-sized +// integers. It should be safe to freely rearrange the structures or change +// the sizes larger--nothing relies on silently truncating etc., nor the +// order of variables. + +#define FAST_HUFFMAN_TABLE_SIZE (1 << STB_VORBIS_FAST_HUFFMAN_LENGTH) +#define FAST_HUFFMAN_TABLE_MASK (FAST_HUFFMAN_TABLE_SIZE - 1) + +typedef struct +{ + int dimensions, entries; + uint8 *codeword_lengths; + float minimum_value; + float delta_value; + uint8 value_bits; + uint8 lookup_type; + uint8 sequence_p; + uint8 sparse; + uint32 lookup_values; + codetype *multiplicands; + uint32 *codewords; + #ifdef STB_VORBIS_FAST_HUFFMAN_SHORT + int16 fast_huffman[FAST_HUFFMAN_TABLE_SIZE]; + #else + int32 fast_huffman[FAST_HUFFMAN_TABLE_SIZE]; + #endif + uint32 *sorted_codewords; + int *sorted_values; + int sorted_entries; +} Codebook; + +typedef struct +{ + uint8 order; + uint16 rate; + uint16 bark_map_size; + uint8 amplitude_bits; + uint8 amplitude_offset; + uint8 number_of_books; + uint8 book_list[16]; // varies +} Floor0; + +typedef struct +{ + uint8 partitions; + uint8 partition_class_list[32]; // varies + uint8 class_dimensions[16]; // varies + uint8 class_subclasses[16]; // varies + uint8 class_masterbooks[16]; // varies + int16 subclass_books[16][8]; // varies + uint16 Xlist[31*8+2]; // varies + uint8 sorted_order[31*8+2]; + uint8 neighbors[31*8+2][2]; + uint8 floor1_multiplier; + uint8 rangebits; + int values; +} Floor1; + +typedef union +{ + Floor0 floor0; + Floor1 floor1; +} Floor; + +typedef struct +{ + uint32 begin, end; + uint32 part_size; + uint8 classifications; + uint8 classbook; + uint8 **classdata; + int16 (*residue_books)[8]; +} Residue; + +typedef struct +{ + uint8 magnitude; + uint8 angle; + uint8 mux; +} MappingChannel; + +typedef struct +{ + uint16 coupling_steps; + MappingChannel *chan; + uint8 submaps; + uint8 submap_floor[15]; // varies + uint8 submap_residue[15]; // varies +} Mapping; + +typedef struct +{ + uint8 blockflag; + uint8 mapping; + uint16 windowtype; + uint16 transformtype; +} Mode; + +typedef struct +{ + uint32 goal_crc; // expected crc if match + int bytes_left; // bytes left in packet + uint32 crc_so_far; // running crc + int bytes_done; // bytes processed in _current_ chunk + uint32 sample_loc; // granule pos encoded in page +} CRCscan; + +typedef struct +{ + uint32 page_start, page_end; + uint32 last_decoded_sample; +} ProbedPage; + +struct stb_vorbis +{ + // user-accessible info + unsigned int sample_rate; + int channels; + + unsigned int setup_memory_required; + unsigned int temp_memory_required; + unsigned int setup_temp_memory_required; + + char *vendor; + int comment_list_length; + char **comment_list; + + // input config +#ifndef STB_VORBIS_NO_STDIO + FILE *f; + uint32 f_start; + int close_on_free; +#endif + + uint8 *stream; + uint8 *stream_start; + uint8 *stream_end; + + uint32 stream_len; + + uint8 push_mode; + + // the page to seek to when seeking to start, may be zero + uint32 first_audio_page_offset; + + // p_first is the page on which the first audio packet ends + // (but not necessarily the page on which it starts) + ProbedPage p_first, p_last; + + // memory management + stb_vorbis_alloc alloc; + int setup_offset; + int temp_offset; + + // run-time results + int eof; + enum STBVorbisError error; + + // user-useful data + + // header info + int blocksize[2]; + int blocksize_0, blocksize_1; + int codebook_count; + Codebook *codebooks; + int floor_count; + uint16 floor_types[64]; // varies + Floor *floor_config; + int residue_count; + uint16 residue_types[64]; // varies + Residue *residue_config; + int mapping_count; + Mapping *mapping; + int mode_count; + Mode mode_config[64]; // varies + + uint32 total_samples; + + // decode buffer + float *channel_buffers[STB_VORBIS_MAX_CHANNELS]; + float *outputs [STB_VORBIS_MAX_CHANNELS]; + + float *previous_window[STB_VORBIS_MAX_CHANNELS]; + int previous_length; + + #ifndef STB_VORBIS_NO_DEFER_FLOOR + int16 *finalY[STB_VORBIS_MAX_CHANNELS]; + #else + float *floor_buffers[STB_VORBIS_MAX_CHANNELS]; + #endif + + uint32 current_loc; // sample location of next frame to decode + int current_loc_valid; + + // per-blocksize precomputed data + + // twiddle factors + float *A[2],*B[2],*C[2]; + float *window[2]; + uint16 *bit_reverse[2]; + + // current page/packet/segment streaming info + uint32 serial; // stream serial number for verification + int last_page; + int segment_count; + uint8 segments[255]; + uint8 page_flag; + uint8 bytes_in_seg; + uint8 first_decode; + int next_seg; + int last_seg; // flag that we're on the last segment + int last_seg_which; // what was the segment number of the last seg? + uint32 acc; + int valid_bits; + int packet_bytes; + int end_seg_with_known_loc; + uint32 known_loc_for_packet; + int discard_samples_deferred; + uint32 samples_output; + + // push mode scanning + int page_crc_tests; // only in push_mode: number of tests active; -1 if not searching +#ifndef STB_VORBIS_NO_PUSHDATA_API + CRCscan scan[STB_VORBIS_PUSHDATA_CRC_COUNT]; +#endif + + // sample-access + int channel_buffer_start; + int channel_buffer_end; +}; + +#if defined(STB_VORBIS_NO_PUSHDATA_API) + #define IS_PUSH_MODE(f) FALSE +#elif defined(STB_VORBIS_NO_PULLDATA_API) + #define IS_PUSH_MODE(f) TRUE +#else + #define IS_PUSH_MODE(f) ((f)->push_mode) +#endif + +typedef struct stb_vorbis vorb; + +static int error(vorb *f, enum STBVorbisError e) +{ + f->error = e; + if (!f->eof && e != VORBIS_need_more_data) { + f->error=e; // breakpoint for debugging + } + return 0; +} + + +// these functions are used for allocating temporary memory +// while decoding. if you can afford the stack space, use +// alloca(); otherwise, provide a temp buffer and it will +// allocate out of those. + +#define array_size_required(count,size) (count*(sizeof(void *)+(size))) + +#define temp_alloc(f,size) (f->alloc.alloc_buffer ? setup_temp_malloc(f,size) : alloca(size)) +#define temp_free(f,p) (void)0 +#define temp_alloc_save(f) ((f)->temp_offset) +#define temp_alloc_restore(f,p) ((f)->temp_offset = (p)) + +#define temp_block_array(f,count,size) make_block_array(temp_alloc(f,array_size_required(count,size)), count, size) + +// given a sufficiently large block of memory, make an array of pointers to subblocks of it +static void *make_block_array(void *mem, int count, int size) +{ + int i; + void ** p = (void **) mem; + char *q = (char *) (p + count); + for (i=0; i < count; ++i) { + p[i] = q; + q += size; + } + return p; +} + +static void *setup_malloc(vorb *f, int sz) +{ + sz = (sz+7) & ~7; // round up to nearest 8 for alignment of future allocs. + f->setup_memory_required += sz; + if (f->alloc.alloc_buffer) { + void *p = (char *) f->alloc.alloc_buffer + f->setup_offset; + if (f->setup_offset + sz > f->temp_offset) return NULL; + f->setup_offset += sz; + return p; + } + return sz ? malloc(sz) : NULL; +} + +static void setup_free(vorb *f, void *p) +{ + if (f->alloc.alloc_buffer) return; // do nothing; setup mem is a stack + free(p); +} + +static void *setup_temp_malloc(vorb *f, int sz) +{ + sz = (sz+7) & ~7; // round up to nearest 8 for alignment of future allocs. + if (f->alloc.alloc_buffer) { + if (f->temp_offset - sz < f->setup_offset) return NULL; + f->temp_offset -= sz; + return (char *) f->alloc.alloc_buffer + f->temp_offset; + } + return malloc(sz); +} + +static void setup_temp_free(vorb *f, void *p, int sz) +{ + if (f->alloc.alloc_buffer) { + f->temp_offset += (sz+7)&~7; + return; + } + free(p); +} + +#define CRC32_POLY 0x04c11db7 // from spec + +static uint32 crc_table[256]; +static void crc32_init(void) +{ + int i,j; + uint32 s; + for(i=0; i < 256; i++) { + for (s=(uint32) i << 24, j=0; j < 8; ++j) + s = (s << 1) ^ (s >= (1U<<31) ? CRC32_POLY : 0); + crc_table[i] = s; + } +} + +static __forceinline uint32 crc32_update(uint32 crc, uint8 byte) +{ + return (crc << 8) ^ crc_table[byte ^ (crc >> 24)]; +} + + +// used in setup, and for huffman that doesn't go fast path +static unsigned int bit_reverse(unsigned int n) +{ + n = ((n & 0xAAAAAAAA) >> 1) | ((n & 0x55555555) << 1); + n = ((n & 0xCCCCCCCC) >> 2) | ((n & 0x33333333) << 2); + n = ((n & 0xF0F0F0F0) >> 4) | ((n & 0x0F0F0F0F) << 4); + n = ((n & 0xFF00FF00) >> 8) | ((n & 0x00FF00FF) << 8); + return (n >> 16) | (n << 16); +} + +static float square(float x) +{ + return x*x; +} + +// this is a weird definition of log2() for which log2(1) = 1, log2(2) = 2, log2(4) = 3 +// as required by the specification. fast(?) implementation from stb.h +// @OPTIMIZE: called multiple times per-packet with "constants"; move to setup +static int ilog(int32 n) +{ + static signed char log2_4[16] = { 0,1,2,2,3,3,3,3,4,4,4,4,4,4,4,4 }; + + if (n < 0) return 0; // signed n returns 0 + + // 2 compares if n < 16, 3 compares otherwise (4 if signed or n > 1<<29) + if (n < (1 << 14)) + if (n < (1 << 4)) return 0 + log2_4[n ]; + else if (n < (1 << 9)) return 5 + log2_4[n >> 5]; + else return 10 + log2_4[n >> 10]; + else if (n < (1 << 24)) + if (n < (1 << 19)) return 15 + log2_4[n >> 15]; + else return 20 + log2_4[n >> 20]; + else if (n < (1 << 29)) return 25 + log2_4[n >> 25]; + else return 30 + log2_4[n >> 30]; +} + +#ifndef M_PI + #define M_PI 3.14159265358979323846264f // from CRC +#endif + +// code length assigned to a value with no huffman encoding +#define NO_CODE 255 + +/////////////////////// LEAF SETUP FUNCTIONS ////////////////////////// +// +// these functions are only called at setup, and only a few times +// per file + +static float float32_unpack(uint32 x) +{ + // from the specification + uint32 mantissa = x & 0x1fffff; + uint32 sign = x & 0x80000000; + uint32 exp = (x & 0x7fe00000) >> 21; + double res = sign ? -(double)mantissa : (double)mantissa; + return (float) ldexp((float)res, (int)exp-788); +} + + +// zlib & jpeg huffman tables assume that the output symbols +// can either be arbitrarily arranged, or have monotonically +// increasing frequencies--they rely on the lengths being sorted; +// this makes for a very simple generation algorithm. +// vorbis allows a huffman table with non-sorted lengths. This +// requires a more sophisticated construction, since symbols in +// order do not map to huffman codes "in order". +static void add_entry(Codebook *c, uint32 huff_code, int symbol, int count, int len, uint32 *values) +{ + if (!c->sparse) { + c->codewords [symbol] = huff_code; + } else { + c->codewords [count] = huff_code; + c->codeword_lengths[count] = len; + values [count] = symbol; + } +} + +static int compute_codewords(Codebook *c, uint8 *len, int n, uint32 *values) +{ + int i,k,m=0; + uint32 available[32]; + + memset(available, 0, sizeof(available)); + // find the first entry + for (k=0; k < n; ++k) if (len[k] < NO_CODE) break; + if (k == n) { assert(c->sorted_entries == 0); return TRUE; } + assert(len[k] < 32); // no error return required, code reading lens checks this + // add to the list + add_entry(c, 0, k, m++, len[k], values); + // add all available leaves + for (i=1; i <= len[k]; ++i) + available[i] = 1U << (32-i); + // note that the above code treats the first case specially, + // but it's really the same as the following code, so they + // could probably be combined (except the initial code is 0, + // and I use 0 in available[] to mean 'empty') + for (i=k+1; i < n; ++i) { + uint32 res; + int z = len[i], y; + if (z == NO_CODE) continue; + assert(z < 32); // no error return required, code reading lens checks this + // find lowest available leaf (should always be earliest, + // which is what the specification calls for) + // note that this property, and the fact we can never have + // more than one free leaf at a given level, isn't totally + // trivial to prove, but it seems true and the assert never + // fires, so! + while (z > 0 && !available[z]) --z; + if (z == 0) { return FALSE; } + res = available[z]; + available[z] = 0; + add_entry(c, bit_reverse(res), i, m++, len[i], values); + // propagate availability up the tree + if (z != len[i]) { + for (y=len[i]; y > z; --y) { + assert(available[y] == 0); + available[y] = res + (1 << (32-y)); + } + } + } + return TRUE; +} + +// accelerated huffman table allows fast O(1) match of all symbols +// of length <= STB_VORBIS_FAST_HUFFMAN_LENGTH +static void compute_accelerated_huffman(Codebook *c) +{ + int i, len; + for (i=0; i < FAST_HUFFMAN_TABLE_SIZE; ++i) + c->fast_huffman[i] = -1; + + len = c->sparse ? c->sorted_entries : c->entries; + #ifdef STB_VORBIS_FAST_HUFFMAN_SHORT + if (len > 32767) len = 32767; // largest possible value we can encode! + #endif + for (i=0; i < len; ++i) { + if (c->codeword_lengths[i] <= STB_VORBIS_FAST_HUFFMAN_LENGTH) { + uint32 z = c->sparse ? bit_reverse(c->sorted_codewords[i]) : c->codewords[i]; + // set table entries for all bit combinations in the higher bits + while (z < FAST_HUFFMAN_TABLE_SIZE) { + c->fast_huffman[z] = i; + z += 1 << c->codeword_lengths[i]; + } + } + } +} + +#ifdef _MSC_VER +#define STBV_CDECL __cdecl +#else +#define STBV_CDECL +#endif + +static int STBV_CDECL uint32_compare(const void *p, const void *q) +{ + uint32 x = * (uint32 *) p; + uint32 y = * (uint32 *) q; + return x < y ? -1 : x > y; +} + +static int include_in_sort(Codebook *c, uint8 len) +{ + if (c->sparse) { assert(len != NO_CODE); return TRUE; } + if (len == NO_CODE) return FALSE; + if (len > STB_VORBIS_FAST_HUFFMAN_LENGTH) return TRUE; + return FALSE; +} + +// if the fast table above doesn't work, we want to binary +// search them... need to reverse the bits +static void compute_sorted_huffman(Codebook *c, uint8 *lengths, uint32 *values) +{ + int i, len; + // build a list of all the entries + // OPTIMIZATION: don't include the short ones, since they'll be caught by FAST_HUFFMAN. + // this is kind of a frivolous optimization--I don't see any performance improvement, + // but it's like 4 extra lines of code, so. + if (!c->sparse) { + int k = 0; + for (i=0; i < c->entries; ++i) + if (include_in_sort(c, lengths[i])) + c->sorted_codewords[k++] = bit_reverse(c->codewords[i]); + assert(k == c->sorted_entries); + } else { + for (i=0; i < c->sorted_entries; ++i) + c->sorted_codewords[i] = bit_reverse(c->codewords[i]); + } + + qsort(c->sorted_codewords, c->sorted_entries, sizeof(c->sorted_codewords[0]), uint32_compare); + c->sorted_codewords[c->sorted_entries] = 0xffffffff; + + len = c->sparse ? c->sorted_entries : c->entries; + // now we need to indicate how they correspond; we could either + // #1: sort a different data structure that says who they correspond to + // #2: for each sorted entry, search the original list to find who corresponds + // #3: for each original entry, find the sorted entry + // #1 requires extra storage, #2 is slow, #3 can use binary search! + for (i=0; i < len; ++i) { + int huff_len = c->sparse ? lengths[values[i]] : lengths[i]; + if (include_in_sort(c,huff_len)) { + uint32 code = bit_reverse(c->codewords[i]); + int x=0, n=c->sorted_entries; + while (n > 1) { + // invariant: sc[x] <= code < sc[x+n] + int m = x + (n >> 1); + if (c->sorted_codewords[m] <= code) { + x = m; + n -= (n>>1); + } else { + n >>= 1; + } + } + assert(c->sorted_codewords[x] == code); + if (c->sparse) { + c->sorted_values[x] = values[i]; + c->codeword_lengths[x] = huff_len; + } else { + c->sorted_values[x] = i; + } + } + } +} + +// only run while parsing the header (3 times) +static int vorbis_validate(uint8 *data) +{ + static uint8 vorbis[6] = { 'v', 'o', 'r', 'b', 'i', 's' }; + return memcmp(data, vorbis, 6) == 0; +} + +// called from setup only, once per code book +// (formula implied by specification) +static int lookup1_values(int entries, int dim) +{ + int r = (int) floor(exp((float) log((float) entries) / dim)); + if ((int) floor(pow((float) r+1, dim)) <= entries) // (int) cast for MinGW warning; + ++r; // floor() to avoid _ftol() when non-CRT + if (pow((float) r+1, dim) <= entries) + return -1; + if ((int) floor(pow((float) r, dim)) > entries) + return -1; + return r; +} + +// called twice per file +static void compute_twiddle_factors(int n, float *A, float *B, float *C) +{ + int n4 = n >> 2, n8 = n >> 3; + int k,k2; + + for (k=k2=0; k < n4; ++k,k2+=2) { + A[k2 ] = (float) cos(4*k*M_PI/n); + A[k2+1] = (float) -sin(4*k*M_PI/n); + B[k2 ] = (float) cos((k2+1)*M_PI/n/2) * 0.5f; + B[k2+1] = (float) sin((k2+1)*M_PI/n/2) * 0.5f; + } + for (k=k2=0; k < n8; ++k,k2+=2) { + C[k2 ] = (float) cos(2*(k2+1)*M_PI/n); + C[k2+1] = (float) -sin(2*(k2+1)*M_PI/n); + } +} + +static void compute_window(int n, float *window) +{ + int n2 = n >> 1, i; + for (i=0; i < n2; ++i) + window[i] = (float) sin(0.5 * M_PI * square((float) sin((i - 0 + 0.5) / n2 * 0.5 * M_PI))); +} + +static void compute_bitreverse(int n, uint16 *rev) +{ + int ld = ilog(n) - 1; // ilog is off-by-one from normal definitions + int i, n8 = n >> 3; + for (i=0; i < n8; ++i) + rev[i] = (bit_reverse(i) >> (32-ld+3)) << 2; +} + +static int init_blocksize(vorb *f, int b, int n) +{ + int n2 = n >> 1, n4 = n >> 2, n8 = n >> 3; + f->A[b] = (float *) setup_malloc(f, sizeof(float) * n2); + f->B[b] = (float *) setup_malloc(f, sizeof(float) * n2); + f->C[b] = (float *) setup_malloc(f, sizeof(float) * n4); + if (!f->A[b] || !f->B[b] || !f->C[b]) return error(f, VORBIS_outofmem); + compute_twiddle_factors(n, f->A[b], f->B[b], f->C[b]); + f->window[b] = (float *) setup_malloc(f, sizeof(float) * n2); + if (!f->window[b]) return error(f, VORBIS_outofmem); + compute_window(n, f->window[b]); + f->bit_reverse[b] = (uint16 *) setup_malloc(f, sizeof(uint16) * n8); + if (!f->bit_reverse[b]) return error(f, VORBIS_outofmem); + compute_bitreverse(n, f->bit_reverse[b]); + return TRUE; +} + +static void neighbors(uint16 *x, int n, int *plow, int *phigh) +{ + int low = -1; + int high = 65536; + int i; + for (i=0; i < n; ++i) { + if (x[i] > low && x[i] < x[n]) { *plow = i; low = x[i]; } + if (x[i] < high && x[i] > x[n]) { *phigh = i; high = x[i]; } + } +} + +// this has been repurposed so y is now the original index instead of y +typedef struct +{ + uint16 x,id; +} stbv__floor_ordering; + +static int STBV_CDECL point_compare(const void *p, const void *q) +{ + stbv__floor_ordering *a = (stbv__floor_ordering *) p; + stbv__floor_ordering *b = (stbv__floor_ordering *) q; + return a->x < b->x ? -1 : a->x > b->x; +} + +// +/////////////////////// END LEAF SETUP FUNCTIONS ////////////////////////// + + +#if defined(STB_VORBIS_NO_STDIO) + #define USE_MEMORY(z) TRUE +#else + #define USE_MEMORY(z) ((z)->stream) +#endif + +static uint8 get8(vorb *z) +{ + if (USE_MEMORY(z)) { + if (z->stream >= z->stream_end) { z->eof = TRUE; return 0; } + return *z->stream++; + } + + #ifndef STB_VORBIS_NO_STDIO + { + int c = fgetc(z->f); + if (c == EOF) { z->eof = TRUE; return 0; } + return c; + } + #endif +} + +static uint32 get32(vorb *f) +{ + uint32 x; + x = get8(f); + x += get8(f) << 8; + x += get8(f) << 16; + x += (uint32) get8(f) << 24; + return x; +} + +static int getn(vorb *z, uint8 *data, int n) +{ + if (USE_MEMORY(z)) { + if (z->stream+n > z->stream_end) { z->eof = 1; return 0; } + memcpy(data, z->stream, n); + z->stream += n; + return 1; + } + + #ifndef STB_VORBIS_NO_STDIO + if (fread(data, n, 1, z->f) == 1) + return 1; + else { + z->eof = 1; + return 0; + } + #endif +} + +static void skip(vorb *z, int n) +{ + if (USE_MEMORY(z)) { + z->stream += n; + if (z->stream >= z->stream_end) z->eof = 1; + return; + } + #ifndef STB_VORBIS_NO_STDIO + { + long x = ftell(z->f); + fseek(z->f, x+n, SEEK_SET); + } + #endif +} + +static int set_file_offset(stb_vorbis *f, unsigned int loc) +{ + #ifndef STB_VORBIS_NO_PUSHDATA_API + if (f->push_mode) return 0; + #endif + f->eof = 0; + if (USE_MEMORY(f)) { + if (f->stream_start + loc >= f->stream_end || f->stream_start + loc < f->stream_start) { + f->stream = f->stream_end; + f->eof = 1; + return 0; + } else { + f->stream = f->stream_start + loc; + return 1; + } + } + #ifndef STB_VORBIS_NO_STDIO + if (loc + f->f_start < loc || loc >= 0x80000000) { + loc = 0x7fffffff; + f->eof = 1; + } else { + loc += f->f_start; + } + if (!fseek(f->f, loc, SEEK_SET)) + return 1; + f->eof = 1; + fseek(f->f, f->f_start, SEEK_END); + return 0; + #endif +} + + +static uint8 ogg_page_header[4] = { 0x4f, 0x67, 0x67, 0x53 }; + +static int capture_pattern(vorb *f) +{ + if (0x4f != get8(f)) return FALSE; + if (0x67 != get8(f)) return FALSE; + if (0x67 != get8(f)) return FALSE; + if (0x53 != get8(f)) return FALSE; + return TRUE; +} + +#define PAGEFLAG_continued_packet 1 +#define PAGEFLAG_first_page 2 +#define PAGEFLAG_last_page 4 + +static int start_page_no_capturepattern(vorb *f) +{ + uint32 loc0,loc1,n; + if (f->first_decode && !IS_PUSH_MODE(f)) { + f->p_first.page_start = stb_vorbis_get_file_offset(f) - 4; + } + // stream structure version + if (0 != get8(f)) return error(f, VORBIS_invalid_stream_structure_version); + // header flag + f->page_flag = get8(f); + // absolute granule position + loc0 = get32(f); + loc1 = get32(f); + // @TODO: validate loc0,loc1 as valid positions? + // stream serial number -- vorbis doesn't interleave, so discard + get32(f); + //if (f->serial != get32(f)) return error(f, VORBIS_incorrect_stream_serial_number); + // page sequence number + n = get32(f); + f->last_page = n; + // CRC32 + get32(f); + // page_segments + f->segment_count = get8(f); + if (!getn(f, f->segments, f->segment_count)) + return error(f, VORBIS_unexpected_eof); + // assume we _don't_ know any the sample position of any segments + f->end_seg_with_known_loc = -2; + if (loc0 != ~0U || loc1 != ~0U) { + int i; + // determine which packet is the last one that will complete + for (i=f->segment_count-1; i >= 0; --i) + if (f->segments[i] < 255) + break; + // 'i' is now the index of the _last_ segment of a packet that ends + if (i >= 0) { + f->end_seg_with_known_loc = i; + f->known_loc_for_packet = loc0; + } + } + if (f->first_decode) { + int i,len; + len = 0; + for (i=0; i < f->segment_count; ++i) + len += f->segments[i]; + len += 27 + f->segment_count; + f->p_first.page_end = f->p_first.page_start + len; + f->p_first.last_decoded_sample = loc0; + } + f->next_seg = 0; + return TRUE; +} + +static int start_page(vorb *f) +{ + if (!capture_pattern(f)) return error(f, VORBIS_missing_capture_pattern); + return start_page_no_capturepattern(f); +} + +static int start_packet(vorb *f) +{ + while (f->next_seg == -1) { + if (!start_page(f)) return FALSE; + if (f->page_flag & PAGEFLAG_continued_packet) + return error(f, VORBIS_continued_packet_flag_invalid); + } + f->last_seg = FALSE; + f->valid_bits = 0; + f->packet_bytes = 0; + f->bytes_in_seg = 0; + // f->next_seg is now valid + return TRUE; +} + +static int maybe_start_packet(vorb *f) +{ + if (f->next_seg == -1) { + int x = get8(f); + if (f->eof) return FALSE; // EOF at page boundary is not an error! + if (0x4f != x ) return error(f, VORBIS_missing_capture_pattern); + if (0x67 != get8(f)) return error(f, VORBIS_missing_capture_pattern); + if (0x67 != get8(f)) return error(f, VORBIS_missing_capture_pattern); + if (0x53 != get8(f)) return error(f, VORBIS_missing_capture_pattern); + if (!start_page_no_capturepattern(f)) return FALSE; + if (f->page_flag & PAGEFLAG_continued_packet) { + // set up enough state that we can read this packet if we want, + // e.g. during recovery + f->last_seg = FALSE; + f->bytes_in_seg = 0; + return error(f, VORBIS_continued_packet_flag_invalid); + } + } + return start_packet(f); +} + +static int next_segment(vorb *f) +{ + int len; + if (f->last_seg) return 0; + if (f->next_seg == -1) { + f->last_seg_which = f->segment_count-1; // in case start_page fails + if (!start_page(f)) { f->last_seg = 1; return 0; } + if (!(f->page_flag & PAGEFLAG_continued_packet)) return error(f, VORBIS_continued_packet_flag_invalid); + } + len = f->segments[f->next_seg++]; + if (len < 255) { + f->last_seg = TRUE; + f->last_seg_which = f->next_seg-1; + } + if (f->next_seg >= f->segment_count) + f->next_seg = -1; + assert(f->bytes_in_seg == 0); + f->bytes_in_seg = len; + return len; +} + +#define EOP (-1) +#define INVALID_BITS (-1) + +static int get8_packet_raw(vorb *f) +{ + if (!f->bytes_in_seg) { // CLANG! + if (f->last_seg) return EOP; + else if (!next_segment(f)) return EOP; + } + assert(f->bytes_in_seg > 0); + --f->bytes_in_seg; + ++f->packet_bytes; + return get8(f); +} + +static int get8_packet(vorb *f) +{ + int x = get8_packet_raw(f); + f->valid_bits = 0; + return x; +} + +static int get32_packet(vorb *f) +{ + uint32 x; + x = get8_packet(f); + x += get8_packet(f) << 8; + x += get8_packet(f) << 16; + x += (uint32) get8_packet(f) << 24; + return x; +} + +static void flush_packet(vorb *f) +{ + while (get8_packet_raw(f) != EOP); +} + +// @OPTIMIZE: this is the secondary bit decoder, so it's probably not as important +// as the huffman decoder? +static uint32 get_bits(vorb *f, int n) +{ + uint32 z; + + if (f->valid_bits < 0) return 0; + if (f->valid_bits < n) { + if (n > 24) { + // the accumulator technique below would not work correctly in this case + z = get_bits(f, 24); + z += get_bits(f, n-24) << 24; + return z; + } + if (f->valid_bits == 0) f->acc = 0; + while (f->valid_bits < n) { + int z = get8_packet_raw(f); + if (z == EOP) { + f->valid_bits = INVALID_BITS; + return 0; + } + f->acc += z << f->valid_bits; + f->valid_bits += 8; + } + } + + assert(f->valid_bits >= n); + z = f->acc & ((1 << n)-1); + f->acc >>= n; + f->valid_bits -= n; + return z; +} + +// @OPTIMIZE: primary accumulator for huffman +// expand the buffer to as many bits as possible without reading off end of packet +// it might be nice to allow f->valid_bits and f->acc to be stored in registers, +// e.g. cache them locally and decode locally +static __forceinline void prep_huffman(vorb *f) +{ + if (f->valid_bits <= 24) { + if (f->valid_bits == 0) f->acc = 0; + do { + int z; + if (f->last_seg && !f->bytes_in_seg) return; + z = get8_packet_raw(f); + if (z == EOP) return; + f->acc += (unsigned) z << f->valid_bits; + f->valid_bits += 8; + } while (f->valid_bits <= 24); + } +} + +enum +{ + VORBIS_packet_id = 1, + VORBIS_packet_comment = 3, + VORBIS_packet_setup = 5 +}; + +static int codebook_decode_scalar_raw(vorb *f, Codebook *c) +{ + int i; + prep_huffman(f); + + if (c->codewords == NULL && c->sorted_codewords == NULL) + return -1; + + // cases to use binary search: sorted_codewords && !c->codewords + // sorted_codewords && c->entries > 8 + if (c->entries > 8 ? c->sorted_codewords!=NULL : !c->codewords) { + // binary search + uint32 code = bit_reverse(f->acc); + int x=0, n=c->sorted_entries, len; + + while (n > 1) { + // invariant: sc[x] <= code < sc[x+n] + int m = x + (n >> 1); + if (c->sorted_codewords[m] <= code) { + x = m; + n -= (n>>1); + } else { + n >>= 1; + } + } + // x is now the sorted index + if (!c->sparse) x = c->sorted_values[x]; + // x is now sorted index if sparse, or symbol otherwise + len = c->codeword_lengths[x]; + if (f->valid_bits >= len) { + f->acc >>= len; + f->valid_bits -= len; + return x; + } + + f->valid_bits = 0; + return -1; + } + + // if small, linear search + assert(!c->sparse); + for (i=0; i < c->entries; ++i) { + if (c->codeword_lengths[i] == NO_CODE) continue; + if (c->codewords[i] == (f->acc & ((1 << c->codeword_lengths[i])-1))) { + if (f->valid_bits >= c->codeword_lengths[i]) { + f->acc >>= c->codeword_lengths[i]; + f->valid_bits -= c->codeword_lengths[i]; + return i; + } + f->valid_bits = 0; + return -1; + } + } + + error(f, VORBIS_invalid_stream); + f->valid_bits = 0; + return -1; +} + +#ifndef STB_VORBIS_NO_INLINE_DECODE + +#define DECODE_RAW(var, f,c) \ + if (f->valid_bits < STB_VORBIS_FAST_HUFFMAN_LENGTH) \ + prep_huffman(f); \ + var = f->acc & FAST_HUFFMAN_TABLE_MASK; \ + var = c->fast_huffman[var]; \ + if (var >= 0) { \ + int n = c->codeword_lengths[var]; \ + f->acc >>= n; \ + f->valid_bits -= n; \ + if (f->valid_bits < 0) { f->valid_bits = 0; var = -1; } \ + } else { \ + var = codebook_decode_scalar_raw(f,c); \ + } + +#else + +static int codebook_decode_scalar(vorb *f, Codebook *c) +{ + int i; + if (f->valid_bits < STB_VORBIS_FAST_HUFFMAN_LENGTH) + prep_huffman(f); + // fast huffman table lookup + i = f->acc & FAST_HUFFMAN_TABLE_MASK; + i = c->fast_huffman[i]; + if (i >= 0) { + f->acc >>= c->codeword_lengths[i]; + f->valid_bits -= c->codeword_lengths[i]; + if (f->valid_bits < 0) { f->valid_bits = 0; return -1; } + return i; + } + return codebook_decode_scalar_raw(f,c); +} + +#define DECODE_RAW(var,f,c) var = codebook_decode_scalar(f,c); + +#endif + +#define DECODE(var,f,c) \ + DECODE_RAW(var,f,c) \ + if (c->sparse) var = c->sorted_values[var]; + +#ifndef STB_VORBIS_DIVIDES_IN_CODEBOOK + #define DECODE_VQ(var,f,c) DECODE_RAW(var,f,c) +#else + #define DECODE_VQ(var,f,c) DECODE(var,f,c) +#endif + + + + + + +// CODEBOOK_ELEMENT_FAST is an optimization for the CODEBOOK_FLOATS case +// where we avoid one addition +#define CODEBOOK_ELEMENT(c,off) (c->multiplicands[off]) +#define CODEBOOK_ELEMENT_FAST(c,off) (c->multiplicands[off]) +#define CODEBOOK_ELEMENT_BASE(c) (0) + +static int codebook_decode_start(vorb *f, Codebook *c) +{ + int z = -1; + + // type 0 is only legal in a scalar context + if (c->lookup_type == 0) + error(f, VORBIS_invalid_stream); + else { + DECODE_VQ(z,f,c); + if (c->sparse) assert(z < c->sorted_entries); + if (z < 0) { // check for EOP + if (!f->bytes_in_seg) + if (f->last_seg) + return z; + error(f, VORBIS_invalid_stream); + } + } + return z; +} + +static int codebook_decode(vorb *f, Codebook *c, float *output, int len) +{ + int i,z = codebook_decode_start(f,c); + if (z < 0) return FALSE; + if (len > c->dimensions) len = c->dimensions; + +#ifdef STB_VORBIS_DIVIDES_IN_CODEBOOK + if (c->lookup_type == 1) { + float last = CODEBOOK_ELEMENT_BASE(c); + int div = 1; + for (i=0; i < len; ++i) { + int off = (z / div) % c->lookup_values; + float val = CODEBOOK_ELEMENT_FAST(c,off) + last; + output[i] += val; + if (c->sequence_p) last = val + c->minimum_value; + div *= c->lookup_values; + } + return TRUE; + } +#endif + + z *= c->dimensions; + if (c->sequence_p) { + float last = CODEBOOK_ELEMENT_BASE(c); + for (i=0; i < len; ++i) { + float val = CODEBOOK_ELEMENT_FAST(c,z+i) + last; + output[i] += val; + last = val + c->minimum_value; + } + } else { + float last = CODEBOOK_ELEMENT_BASE(c); + for (i=0; i < len; ++i) { + output[i] += CODEBOOK_ELEMENT_FAST(c,z+i) + last; + } + } + + return TRUE; +} + +static int codebook_decode_step(vorb *f, Codebook *c, float *output, int len, int step) +{ + int i,z = codebook_decode_start(f,c); + float last = CODEBOOK_ELEMENT_BASE(c); + if (z < 0) return FALSE; + if (len > c->dimensions) len = c->dimensions; + +#ifdef STB_VORBIS_DIVIDES_IN_CODEBOOK + if (c->lookup_type == 1) { + int div = 1; + for (i=0; i < len; ++i) { + int off = (z / div) % c->lookup_values; + float val = CODEBOOK_ELEMENT_FAST(c,off) + last; + output[i*step] += val; + if (c->sequence_p) last = val; + div *= c->lookup_values; + } + return TRUE; + } +#endif + + z *= c->dimensions; + for (i=0; i < len; ++i) { + float val = CODEBOOK_ELEMENT_FAST(c,z+i) + last; + output[i*step] += val; + if (c->sequence_p) last = val; + } + + return TRUE; +} + +static int codebook_decode_deinterleave_repeat(vorb *f, Codebook *c, float **outputs, int ch, int *c_inter_p, int *p_inter_p, int len, int total_decode) +{ + int c_inter = *c_inter_p; + int p_inter = *p_inter_p; + int i,z, effective = c->dimensions; + + // type 0 is only legal in a scalar context + if (c->lookup_type == 0) return error(f, VORBIS_invalid_stream); + + while (total_decode > 0) { + float last = CODEBOOK_ELEMENT_BASE(c); + DECODE_VQ(z,f,c); + #ifndef STB_VORBIS_DIVIDES_IN_CODEBOOK + assert(!c->sparse || z < c->sorted_entries); + #endif + if (z < 0) { + if (!f->bytes_in_seg) + if (f->last_seg) return FALSE; + return error(f, VORBIS_invalid_stream); + } + + // if this will take us off the end of the buffers, stop short! + // we check by computing the length of the virtual interleaved + // buffer (len*ch), our current offset within it (p_inter*ch)+(c_inter), + // and the length we'll be using (effective) + if (c_inter + p_inter*ch + effective > len * ch) { + effective = len*ch - (p_inter*ch - c_inter); + } + + #ifdef STB_VORBIS_DIVIDES_IN_CODEBOOK + if (c->lookup_type == 1) { + int div = 1; + for (i=0; i < effective; ++i) { + int off = (z / div) % c->lookup_values; + float val = CODEBOOK_ELEMENT_FAST(c,off) + last; + if (outputs[c_inter]) + outputs[c_inter][p_inter] += val; + if (++c_inter == ch) { c_inter = 0; ++p_inter; } + if (c->sequence_p) last = val; + div *= c->lookup_values; + } + } else + #endif + { + z *= c->dimensions; + if (c->sequence_p) { + for (i=0; i < effective; ++i) { + float val = CODEBOOK_ELEMENT_FAST(c,z+i) + last; + if (outputs[c_inter]) + outputs[c_inter][p_inter] += val; + if (++c_inter == ch) { c_inter = 0; ++p_inter; } + last = val; + } + } else { + for (i=0; i < effective; ++i) { + float val = CODEBOOK_ELEMENT_FAST(c,z+i) + last; + if (outputs[c_inter]) + outputs[c_inter][p_inter] += val; + if (++c_inter == ch) { c_inter = 0; ++p_inter; } + } + } + } + + total_decode -= effective; + } + *c_inter_p = c_inter; + *p_inter_p = p_inter; + return TRUE; +} + +static int predict_point(int x, int x0, int x1, int y0, int y1) +{ + int dy = y1 - y0; + int adx = x1 - x0; + // @OPTIMIZE: force int division to round in the right direction... is this necessary on x86? + int err = abs(dy) * (x - x0); + int off = err / adx; + return dy < 0 ? y0 - off : y0 + off; +} + +// the following table is block-copied from the specification +static float inverse_db_table[256] = +{ + 1.0649863e-07f, 1.1341951e-07f, 1.2079015e-07f, 1.2863978e-07f, + 1.3699951e-07f, 1.4590251e-07f, 1.5538408e-07f, 1.6548181e-07f, + 1.7623575e-07f, 1.8768855e-07f, 1.9988561e-07f, 2.1287530e-07f, + 2.2670913e-07f, 2.4144197e-07f, 2.5713223e-07f, 2.7384213e-07f, + 2.9163793e-07f, 3.1059021e-07f, 3.3077411e-07f, 3.5226968e-07f, + 3.7516214e-07f, 3.9954229e-07f, 4.2550680e-07f, 4.5315863e-07f, + 4.8260743e-07f, 5.1396998e-07f, 5.4737065e-07f, 5.8294187e-07f, + 6.2082472e-07f, 6.6116941e-07f, 7.0413592e-07f, 7.4989464e-07f, + 7.9862701e-07f, 8.5052630e-07f, 9.0579828e-07f, 9.6466216e-07f, + 1.0273513e-06f, 1.0941144e-06f, 1.1652161e-06f, 1.2409384e-06f, + 1.3215816e-06f, 1.4074654e-06f, 1.4989305e-06f, 1.5963394e-06f, + 1.7000785e-06f, 1.8105592e-06f, 1.9282195e-06f, 2.0535261e-06f, + 2.1869758e-06f, 2.3290978e-06f, 2.4804557e-06f, 2.6416497e-06f, + 2.8133190e-06f, 2.9961443e-06f, 3.1908506e-06f, 3.3982101e-06f, + 3.6190449e-06f, 3.8542308e-06f, 4.1047004e-06f, 4.3714470e-06f, + 4.6555282e-06f, 4.9580707e-06f, 5.2802740e-06f, 5.6234160e-06f, + 5.9888572e-06f, 6.3780469e-06f, 6.7925283e-06f, 7.2339451e-06f, + 7.7040476e-06f, 8.2047000e-06f, 8.7378876e-06f, 9.3057248e-06f, + 9.9104632e-06f, 1.0554501e-05f, 1.1240392e-05f, 1.1970856e-05f, + 1.2748789e-05f, 1.3577278e-05f, 1.4459606e-05f, 1.5399272e-05f, + 1.6400004e-05f, 1.7465768e-05f, 1.8600792e-05f, 1.9809576e-05f, + 2.1096914e-05f, 2.2467911e-05f, 2.3928002e-05f, 2.5482978e-05f, + 2.7139006e-05f, 2.8902651e-05f, 3.0780908e-05f, 3.2781225e-05f, + 3.4911534e-05f, 3.7180282e-05f, 3.9596466e-05f, 4.2169667e-05f, + 4.4910090e-05f, 4.7828601e-05f, 5.0936773e-05f, 5.4246931e-05f, + 5.7772202e-05f, 6.1526565e-05f, 6.5524908e-05f, 6.9783085e-05f, + 7.4317983e-05f, 7.9147585e-05f, 8.4291040e-05f, 8.9768747e-05f, + 9.5602426e-05f, 0.00010181521f, 0.00010843174f, 0.00011547824f, + 0.00012298267f, 0.00013097477f, 0.00013948625f, 0.00014855085f, + 0.00015820453f, 0.00016848555f, 0.00017943469f, 0.00019109536f, + 0.00020351382f, 0.00021673929f, 0.00023082423f, 0.00024582449f, + 0.00026179955f, 0.00027881276f, 0.00029693158f, 0.00031622787f, + 0.00033677814f, 0.00035866388f, 0.00038197188f, 0.00040679456f, + 0.00043323036f, 0.00046138411f, 0.00049136745f, 0.00052329927f, + 0.00055730621f, 0.00059352311f, 0.00063209358f, 0.00067317058f, + 0.00071691700f, 0.00076350630f, 0.00081312324f, 0.00086596457f, + 0.00092223983f, 0.00098217216f, 0.0010459992f, 0.0011139742f, + 0.0011863665f, 0.0012634633f, 0.0013455702f, 0.0014330129f, + 0.0015261382f, 0.0016253153f, 0.0017309374f, 0.0018434235f, + 0.0019632195f, 0.0020908006f, 0.0022266726f, 0.0023713743f, + 0.0025254795f, 0.0026895994f, 0.0028643847f, 0.0030505286f, + 0.0032487691f, 0.0034598925f, 0.0036847358f, 0.0039241906f, + 0.0041792066f, 0.0044507950f, 0.0047400328f, 0.0050480668f, + 0.0053761186f, 0.0057254891f, 0.0060975636f, 0.0064938176f, + 0.0069158225f, 0.0073652516f, 0.0078438871f, 0.0083536271f, + 0.0088964928f, 0.009474637f, 0.010090352f, 0.010746080f, + 0.011444421f, 0.012188144f, 0.012980198f, 0.013823725f, + 0.014722068f, 0.015678791f, 0.016697687f, 0.017782797f, + 0.018938423f, 0.020169149f, 0.021479854f, 0.022875735f, + 0.024362330f, 0.025945531f, 0.027631618f, 0.029427276f, + 0.031339626f, 0.033376252f, 0.035545228f, 0.037855157f, + 0.040315199f, 0.042935108f, 0.045725273f, 0.048696758f, + 0.051861348f, 0.055231591f, 0.058820850f, 0.062643361f, + 0.066714279f, 0.071049749f, 0.075666962f, 0.080584227f, + 0.085821044f, 0.091398179f, 0.097337747f, 0.10366330f, + 0.11039993f, 0.11757434f, 0.12521498f, 0.13335215f, + 0.14201813f, 0.15124727f, 0.16107617f, 0.17154380f, + 0.18269168f, 0.19456402f, 0.20720788f, 0.22067342f, + 0.23501402f, 0.25028656f, 0.26655159f, 0.28387361f, + 0.30232132f, 0.32196786f, 0.34289114f, 0.36517414f, + 0.38890521f, 0.41417847f, 0.44109412f, 0.46975890f, + 0.50028648f, 0.53279791f, 0.56742212f, 0.60429640f, + 0.64356699f, 0.68538959f, 0.72993007f, 0.77736504f, + 0.82788260f, 0.88168307f, 0.9389798f, 1.0f +}; + + +// @OPTIMIZE: if you want to replace this bresenham line-drawing routine, +// note that you must produce bit-identical output to decode correctly; +// this specific sequence of operations is specified in the spec (it's +// drawing integer-quantized frequency-space lines that the encoder +// expects to be exactly the same) +// ... also, isn't the whole point of Bresenham's algorithm to NOT +// have to divide in the setup? sigh. +#ifndef STB_VORBIS_NO_DEFER_FLOOR +#define LINE_OP(a,b) a *= b +#else +#define LINE_OP(a,b) a = b +#endif + +#ifdef STB_VORBIS_DIVIDE_TABLE +#define DIVTAB_NUMER 32 +#define DIVTAB_DENOM 64 +int8 integer_divide_table[DIVTAB_NUMER][DIVTAB_DENOM]; // 2KB +#endif + +static __forceinline void draw_line(float *output, int x0, int y0, int x1, int y1, int n) +{ + int dy = y1 - y0; + int adx = x1 - x0; + int ady = abs(dy); + int base; + int x=x0,y=y0; + int err = 0; + int sy; + +#ifdef STB_VORBIS_DIVIDE_TABLE + if (adx < DIVTAB_DENOM && ady < DIVTAB_NUMER) { + if (dy < 0) { + base = -integer_divide_table[ady][adx]; + sy = base-1; + } else { + base = integer_divide_table[ady][adx]; + sy = base+1; + } + } else { + base = dy / adx; + if (dy < 0) + sy = base - 1; + else + sy = base+1; + } +#else + base = dy / adx; + if (dy < 0) + sy = base - 1; + else + sy = base+1; +#endif + ady -= abs(base) * adx; + if (x1 > n) x1 = n; + if (x < x1) { + LINE_OP(output[x], inverse_db_table[y&255]); + for (++x; x < x1; ++x) { + err += ady; + if (err >= adx) { + err -= adx; + y += sy; + } else + y += base; + LINE_OP(output[x], inverse_db_table[y&255]); + } + } +} + +static int residue_decode(vorb *f, Codebook *book, float *target, int offset, int n, int rtype) +{ + int k; + if (rtype == 0) { + int step = n / book->dimensions; + for (k=0; k < step; ++k) + if (!codebook_decode_step(f, book, target+offset+k, n-offset-k, step)) + return FALSE; + } else { + for (k=0; k < n; ) { + if (!codebook_decode(f, book, target+offset, n-k)) + return FALSE; + k += book->dimensions; + offset += book->dimensions; + } + } + return TRUE; +} + +// n is 1/2 of the blocksize -- +// specification: "Correct per-vector decode length is [n]/2" +static void decode_residue(vorb *f, float *residue_buffers[], int ch, int n, int rn, uint8 *do_not_decode) +{ + int i,j,pass; + Residue *r = f->residue_config + rn; + int rtype = f->residue_types[rn]; + int c = r->classbook; + int classwords = f->codebooks[c].dimensions; + unsigned int actual_size = rtype == 2 ? n*2 : n; + unsigned int limit_r_begin = (r->begin < actual_size ? r->begin : actual_size); + unsigned int limit_r_end = (r->end < actual_size ? r->end : actual_size); + int n_read = limit_r_end - limit_r_begin; + int part_read = n_read / r->part_size; + int temp_alloc_point = temp_alloc_save(f); + #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE + uint8 ***part_classdata = (uint8 ***) temp_block_array(f,f->channels, part_read * sizeof(**part_classdata)); + #else + int **classifications = (int **) temp_block_array(f,f->channels, part_read * sizeof(**classifications)); + #endif + + CHECK(f); + + for (i=0; i < ch; ++i) + if (!do_not_decode[i]) + memset(residue_buffers[i], 0, sizeof(float) * n); + + if (rtype == 2 && ch != 1) { + for (j=0; j < ch; ++j) + if (!do_not_decode[j]) + break; + if (j == ch) + goto done; + + for (pass=0; pass < 8; ++pass) { + int pcount = 0, class_set = 0; + if (ch == 2) { + while (pcount < part_read) { + int z = r->begin + pcount*r->part_size; + int c_inter = (z & 1), p_inter = z>>1; + if (pass == 0) { + Codebook *c = f->codebooks+r->classbook; + int q; + DECODE(q,f,c); + if (q == EOP) goto done; + #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE + part_classdata[0][class_set] = r->classdata[q]; + #else + for (i=classwords-1; i >= 0; --i) { + classifications[0][i+pcount] = q % r->classifications; + q /= r->classifications; + } + #endif + } + for (i=0; i < classwords && pcount < part_read; ++i, ++pcount) { + int z = r->begin + pcount*r->part_size; + #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE + int c = part_classdata[0][class_set][i]; + #else + int c = classifications[0][pcount]; + #endif + int b = r->residue_books[c][pass]; + if (b >= 0) { + Codebook *book = f->codebooks + b; + #ifdef STB_VORBIS_DIVIDES_IN_CODEBOOK + if (!codebook_decode_deinterleave_repeat(f, book, residue_buffers, ch, &c_inter, &p_inter, n, r->part_size)) + goto done; + #else + // saves 1% + if (!codebook_decode_deinterleave_repeat(f, book, residue_buffers, ch, &c_inter, &p_inter, n, r->part_size)) + goto done; + #endif + } else { + z += r->part_size; + c_inter = z & 1; + p_inter = z >> 1; + } + } + #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE + ++class_set; + #endif + } + } else if (ch > 2) { + while (pcount < part_read) { + int z = r->begin + pcount*r->part_size; + int c_inter = z % ch, p_inter = z/ch; + if (pass == 0) { + Codebook *c = f->codebooks+r->classbook; + int q; + DECODE(q,f,c); + if (q == EOP) goto done; + #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE + part_classdata[0][class_set] = r->classdata[q]; + #else + for (i=classwords-1; i >= 0; --i) { + classifications[0][i+pcount] = q % r->classifications; + q /= r->classifications; + } + #endif + } + for (i=0; i < classwords && pcount < part_read; ++i, ++pcount) { + int z = r->begin + pcount*r->part_size; + #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE + int c = part_classdata[0][class_set][i]; + #else + int c = classifications[0][pcount]; + #endif + int b = r->residue_books[c][pass]; + if (b >= 0) { + Codebook *book = f->codebooks + b; + if (!codebook_decode_deinterleave_repeat(f, book, residue_buffers, ch, &c_inter, &p_inter, n, r->part_size)) + goto done; + } else { + z += r->part_size; + c_inter = z % ch; + p_inter = z / ch; + } + } + #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE + ++class_set; + #endif + } + } + } + goto done; + } + CHECK(f); + + for (pass=0; pass < 8; ++pass) { + int pcount = 0, class_set=0; + while (pcount < part_read) { + if (pass == 0) { + for (j=0; j < ch; ++j) { + if (!do_not_decode[j]) { + Codebook *c = f->codebooks+r->classbook; + int temp; + DECODE(temp,f,c); + if (temp == EOP) goto done; + #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE + part_classdata[j][class_set] = r->classdata[temp]; + #else + for (i=classwords-1; i >= 0; --i) { + classifications[j][i+pcount] = temp % r->classifications; + temp /= r->classifications; + } + #endif + } + } + } + for (i=0; i < classwords && pcount < part_read; ++i, ++pcount) { + for (j=0; j < ch; ++j) { + if (!do_not_decode[j]) { + #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE + int c = part_classdata[j][class_set][i]; + #else + int c = classifications[j][pcount]; + #endif + int b = r->residue_books[c][pass]; + if (b >= 0) { + float *target = residue_buffers[j]; + int offset = r->begin + pcount * r->part_size; + int n = r->part_size; + Codebook *book = f->codebooks + b; + if (!residue_decode(f, book, target, offset, n, rtype)) + goto done; + } + } + } + } + #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE + ++class_set; + #endif + } + } + done: + CHECK(f); + #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE + temp_free(f,part_classdata); + #else + temp_free(f,classifications); + #endif + temp_alloc_restore(f,temp_alloc_point); +} + + +#if 0 +// slow way for debugging +void inverse_mdct_slow(float *buffer, int n) +{ + int i,j; + int n2 = n >> 1; + float *x = (float *) malloc(sizeof(*x) * n2); + memcpy(x, buffer, sizeof(*x) * n2); + for (i=0; i < n; ++i) { + float acc = 0; + for (j=0; j < n2; ++j) + // formula from paper: + //acc += n/4.0f * x[j] * (float) cos(M_PI / 2 / n * (2 * i + 1 + n/2.0)*(2*j+1)); + // formula from wikipedia + //acc += 2.0f / n2 * x[j] * (float) cos(M_PI/n2 * (i + 0.5 + n2/2)*(j + 0.5)); + // these are equivalent, except the formula from the paper inverts the multiplier! + // however, what actually works is NO MULTIPLIER!?! + //acc += 64 * 2.0f / n2 * x[j] * (float) cos(M_PI/n2 * (i + 0.5 + n2/2)*(j + 0.5)); + acc += x[j] * (float) cos(M_PI / 2 / n * (2 * i + 1 + n/2.0)*(2*j+1)); + buffer[i] = acc; + } + free(x); +} +#elif 0 +// same as above, but just barely able to run in real time on modern machines +void inverse_mdct_slow(float *buffer, int n, vorb *f, int blocktype) +{ + float mcos[16384]; + int i,j; + int n2 = n >> 1, nmask = (n << 2) -1; + float *x = (float *) malloc(sizeof(*x) * n2); + memcpy(x, buffer, sizeof(*x) * n2); + for (i=0; i < 4*n; ++i) + mcos[i] = (float) cos(M_PI / 2 * i / n); + + for (i=0; i < n; ++i) { + float acc = 0; + for (j=0; j < n2; ++j) + acc += x[j] * mcos[(2 * i + 1 + n2)*(2*j+1) & nmask]; + buffer[i] = acc; + } + free(x); +} +#elif 0 +// transform to use a slow dct-iv; this is STILL basically trivial, +// but only requires half as many ops +void dct_iv_slow(float *buffer, int n) +{ + float mcos[16384]; + float x[2048]; + int i,j; + int n2 = n >> 1, nmask = (n << 3) - 1; + memcpy(x, buffer, sizeof(*x) * n); + for (i=0; i < 8*n; ++i) + mcos[i] = (float) cos(M_PI / 4 * i / n); + for (i=0; i < n; ++i) { + float acc = 0; + for (j=0; j < n; ++j) + acc += x[j] * mcos[((2 * i + 1)*(2*j+1)) & nmask]; + buffer[i] = acc; + } +} + +void inverse_mdct_slow(float *buffer, int n, vorb *f, int blocktype) +{ + int i, n4 = n >> 2, n2 = n >> 1, n3_4 = n - n4; + float temp[4096]; + + memcpy(temp, buffer, n2 * sizeof(float)); + dct_iv_slow(temp, n2); // returns -c'-d, a-b' + + for (i=0; i < n4 ; ++i) buffer[i] = temp[i+n4]; // a-b' + for ( ; i < n3_4; ++i) buffer[i] = -temp[n3_4 - i - 1]; // b-a', c+d' + for ( ; i < n ; ++i) buffer[i] = -temp[i - n3_4]; // c'+d +} +#endif + +#ifndef LIBVORBIS_MDCT +#define LIBVORBIS_MDCT 0 +#endif + +#if LIBVORBIS_MDCT +// directly call the vorbis MDCT using an interface documented +// by Jeff Roberts... useful for performance comparison +typedef struct +{ + int n; + int log2n; + + float *trig; + int *bitrev; + + float scale; +} mdct_lookup; + +extern void mdct_init(mdct_lookup *lookup, int n); +extern void mdct_clear(mdct_lookup *l); +extern void mdct_backward(mdct_lookup *init, float *in, float *out); + +mdct_lookup M1,M2; + +void inverse_mdct(float *buffer, int n, vorb *f, int blocktype) +{ + mdct_lookup *M; + if (M1.n == n) M = &M1; + else if (M2.n == n) M = &M2; + else if (M1.n == 0) { mdct_init(&M1, n); M = &M1; } + else { + if (M2.n) __asm int 3; + mdct_init(&M2, n); + M = &M2; + } + + mdct_backward(M, buffer, buffer); +} +#endif + + +// the following were split out into separate functions while optimizing; +// they could be pushed back up but eh. __forceinline showed no change; +// they're probably already being inlined. +static void imdct_step3_iter0_loop(int n, float *e, int i_off, int k_off, float *A) +{ + float *ee0 = e + i_off; + float *ee2 = ee0 + k_off; + int i; + + assert((n & 3) == 0); + for (i=(n>>2); i > 0; --i) { + float k00_20, k01_21; + k00_20 = ee0[ 0] - ee2[ 0]; + k01_21 = ee0[-1] - ee2[-1]; + ee0[ 0] += ee2[ 0];//ee0[ 0] = ee0[ 0] + ee2[ 0]; + ee0[-1] += ee2[-1];//ee0[-1] = ee0[-1] + ee2[-1]; + ee2[ 0] = k00_20 * A[0] - k01_21 * A[1]; + ee2[-1] = k01_21 * A[0] + k00_20 * A[1]; + A += 8; + + k00_20 = ee0[-2] - ee2[-2]; + k01_21 = ee0[-3] - ee2[-3]; + ee0[-2] += ee2[-2];//ee0[-2] = ee0[-2] + ee2[-2]; + ee0[-3] += ee2[-3];//ee0[-3] = ee0[-3] + ee2[-3]; + ee2[-2] = k00_20 * A[0] - k01_21 * A[1]; + ee2[-3] = k01_21 * A[0] + k00_20 * A[1]; + A += 8; + + k00_20 = ee0[-4] - ee2[-4]; + k01_21 = ee0[-5] - ee2[-5]; + ee0[-4] += ee2[-4];//ee0[-4] = ee0[-4] + ee2[-4]; + ee0[-5] += ee2[-5];//ee0[-5] = ee0[-5] + ee2[-5]; + ee2[-4] = k00_20 * A[0] - k01_21 * A[1]; + ee2[-5] = k01_21 * A[0] + k00_20 * A[1]; + A += 8; + + k00_20 = ee0[-6] - ee2[-6]; + k01_21 = ee0[-7] - ee2[-7]; + ee0[-6] += ee2[-6];//ee0[-6] = ee0[-6] + ee2[-6]; + ee0[-7] += ee2[-7];//ee0[-7] = ee0[-7] + ee2[-7]; + ee2[-6] = k00_20 * A[0] - k01_21 * A[1]; + ee2[-7] = k01_21 * A[0] + k00_20 * A[1]; + A += 8; + ee0 -= 8; + ee2 -= 8; + } +} + +static void imdct_step3_inner_r_loop(int lim, float *e, int d0, int k_off, float *A, int k1) +{ + int i; + float k00_20, k01_21; + + float *e0 = e + d0; + float *e2 = e0 + k_off; + + for (i=lim >> 2; i > 0; --i) { + k00_20 = e0[-0] - e2[-0]; + k01_21 = e0[-1] - e2[-1]; + e0[-0] += e2[-0];//e0[-0] = e0[-0] + e2[-0]; + e0[-1] += e2[-1];//e0[-1] = e0[-1] + e2[-1]; + e2[-0] = (k00_20)*A[0] - (k01_21) * A[1]; + e2[-1] = (k01_21)*A[0] + (k00_20) * A[1]; + + A += k1; + + k00_20 = e0[-2] - e2[-2]; + k01_21 = e0[-3] - e2[-3]; + e0[-2] += e2[-2];//e0[-2] = e0[-2] + e2[-2]; + e0[-3] += e2[-3];//e0[-3] = e0[-3] + e2[-3]; + e2[-2] = (k00_20)*A[0] - (k01_21) * A[1]; + e2[-3] = (k01_21)*A[0] + (k00_20) * A[1]; + + A += k1; + + k00_20 = e0[-4] - e2[-4]; + k01_21 = e0[-5] - e2[-5]; + e0[-4] += e2[-4];//e0[-4] = e0[-4] + e2[-4]; + e0[-5] += e2[-5];//e0[-5] = e0[-5] + e2[-5]; + e2[-4] = (k00_20)*A[0] - (k01_21) * A[1]; + e2[-5] = (k01_21)*A[0] + (k00_20) * A[1]; + + A += k1; + + k00_20 = e0[-6] - e2[-6]; + k01_21 = e0[-7] - e2[-7]; + e0[-6] += e2[-6];//e0[-6] = e0[-6] + e2[-6]; + e0[-7] += e2[-7];//e0[-7] = e0[-7] + e2[-7]; + e2[-6] = (k00_20)*A[0] - (k01_21) * A[1]; + e2[-7] = (k01_21)*A[0] + (k00_20) * A[1]; + + e0 -= 8; + e2 -= 8; + + A += k1; + } +} + +static void imdct_step3_inner_s_loop(int n, float *e, int i_off, int k_off, float *A, int a_off, int k0) +{ + int i; + float A0 = A[0]; + float A1 = A[0+1]; + float A2 = A[0+a_off]; + float A3 = A[0+a_off+1]; + float A4 = A[0+a_off*2+0]; + float A5 = A[0+a_off*2+1]; + float A6 = A[0+a_off*3+0]; + float A7 = A[0+a_off*3+1]; + + float k00,k11; + + float *ee0 = e +i_off; + float *ee2 = ee0+k_off; + + for (i=n; i > 0; --i) { + k00 = ee0[ 0] - ee2[ 0]; + k11 = ee0[-1] - ee2[-1]; + ee0[ 0] = ee0[ 0] + ee2[ 0]; + ee0[-1] = ee0[-1] + ee2[-1]; + ee2[ 0] = (k00) * A0 - (k11) * A1; + ee2[-1] = (k11) * A0 + (k00) * A1; + + k00 = ee0[-2] - ee2[-2]; + k11 = ee0[-3] - ee2[-3]; + ee0[-2] = ee0[-2] + ee2[-2]; + ee0[-3] = ee0[-3] + ee2[-3]; + ee2[-2] = (k00) * A2 - (k11) * A3; + ee2[-3] = (k11) * A2 + (k00) * A3; + + k00 = ee0[-4] - ee2[-4]; + k11 = ee0[-5] - ee2[-5]; + ee0[-4] = ee0[-4] + ee2[-4]; + ee0[-5] = ee0[-5] + ee2[-5]; + ee2[-4] = (k00) * A4 - (k11) * A5; + ee2[-5] = (k11) * A4 + (k00) * A5; + + k00 = ee0[-6] - ee2[-6]; + k11 = ee0[-7] - ee2[-7]; + ee0[-6] = ee0[-6] + ee2[-6]; + ee0[-7] = ee0[-7] + ee2[-7]; + ee2[-6] = (k00) * A6 - (k11) * A7; + ee2[-7] = (k11) * A6 + (k00) * A7; + + ee0 -= k0; + ee2 -= k0; + } +} + +static __forceinline void iter_54(float *z) +{ + float k00,k11,k22,k33; + float y0,y1,y2,y3; + + k00 = z[ 0] - z[-4]; + y0 = z[ 0] + z[-4]; + y2 = z[-2] + z[-6]; + k22 = z[-2] - z[-6]; + + z[-0] = y0 + y2; // z0 + z4 + z2 + z6 + z[-2] = y0 - y2; // z0 + z4 - z2 - z6 + + // done with y0,y2 + + k33 = z[-3] - z[-7]; + + z[-4] = k00 + k33; // z0 - z4 + z3 - z7 + z[-6] = k00 - k33; // z0 - z4 - z3 + z7 + + // done with k33 + + k11 = z[-1] - z[-5]; + y1 = z[-1] + z[-5]; + y3 = z[-3] + z[-7]; + + z[-1] = y1 + y3; // z1 + z5 + z3 + z7 + z[-3] = y1 - y3; // z1 + z5 - z3 - z7 + z[-5] = k11 - k22; // z1 - z5 + z2 - z6 + z[-7] = k11 + k22; // z1 - z5 - z2 + z6 +} + +static void imdct_step3_inner_s_loop_ld654(int n, float *e, int i_off, float *A, int base_n) +{ + int a_off = base_n >> 3; + float A2 = A[0+a_off]; + float *z = e + i_off; + float *base = z - 16 * n; + + while (z > base) { + float k00,k11; + float l00,l11; + + k00 = z[-0] - z[ -8]; + k11 = z[-1] - z[ -9]; + l00 = z[-2] - z[-10]; + l11 = z[-3] - z[-11]; + z[ -0] = z[-0] + z[ -8]; + z[ -1] = z[-1] + z[ -9]; + z[ -2] = z[-2] + z[-10]; + z[ -3] = z[-3] + z[-11]; + z[ -8] = k00; + z[ -9] = k11; + z[-10] = (l00+l11) * A2; + z[-11] = (l11-l00) * A2; + + k00 = z[ -4] - z[-12]; + k11 = z[ -5] - z[-13]; + l00 = z[ -6] - z[-14]; + l11 = z[ -7] - z[-15]; + z[ -4] = z[ -4] + z[-12]; + z[ -5] = z[ -5] + z[-13]; + z[ -6] = z[ -6] + z[-14]; + z[ -7] = z[ -7] + z[-15]; + z[-12] = k11; + z[-13] = -k00; + z[-14] = (l11-l00) * A2; + z[-15] = (l00+l11) * -A2; + + iter_54(z); + iter_54(z-8); + z -= 16; + } +} + +static void inverse_mdct(float *buffer, int n, vorb *f, int blocktype) +{ + int n2 = n >> 1, n4 = n >> 2, n8 = n >> 3, l; + int ld; + // @OPTIMIZE: reduce register pressure by using fewer variables? + int save_point = temp_alloc_save(f); + float *buf2 = (float *) temp_alloc(f, n2 * sizeof(*buf2)); + float *u=NULL,*v=NULL; + // twiddle factors + float *A = f->A[blocktype]; + + // IMDCT algorithm from "The use of multirate filter banks for coding of high quality digital audio" + // See notes about bugs in that paper in less-optimal implementation 'inverse_mdct_old' after this function. + + // kernel from paper + + + // merged: + // copy and reflect spectral data + // step 0 + + // note that it turns out that the items added together during + // this step are, in fact, being added to themselves (as reflected + // by step 0). inexplicable inefficiency! this became obvious + // once I combined the passes. + + // so there's a missing 'times 2' here (for adding X to itself). + // this propagates through linearly to the end, where the numbers + // are 1/2 too small, and need to be compensated for. + + { + float *d,*e, *AA, *e_stop; + d = &buf2[n2-2]; + AA = A; + e = &buffer[0]; + e_stop = &buffer[n2]; + while (e != e_stop) { + d[1] = (e[0] * AA[0] - e[2]*AA[1]); + d[0] = (e[0] * AA[1] + e[2]*AA[0]); + d -= 2; + AA += 2; + e += 4; + } + + e = &buffer[n2-3]; + while (d >= buf2) { + d[1] = (-e[2] * AA[0] - -e[0]*AA[1]); + d[0] = (-e[2] * AA[1] + -e[0]*AA[0]); + d -= 2; + AA += 2; + e -= 4; + } + } + + // now we use symbolic names for these, so that we can + // possibly swap their meaning as we change which operations + // are in place + + u = buffer; + v = buf2; + + // step 2 (paper output is w, now u) + // this could be in place, but the data ends up in the wrong + // place... _somebody_'s got to swap it, so this is nominated + { + float *AA = &A[n2-8]; + float *d0,*d1, *e0, *e1; + + e0 = &v[n4]; + e1 = &v[0]; + + d0 = &u[n4]; + d1 = &u[0]; + + while (AA >= A) { + float v40_20, v41_21; + + v41_21 = e0[1] - e1[1]; + v40_20 = e0[0] - e1[0]; + d0[1] = e0[1] + e1[1]; + d0[0] = e0[0] + e1[0]; + d1[1] = v41_21*AA[4] - v40_20*AA[5]; + d1[0] = v40_20*AA[4] + v41_21*AA[5]; + + v41_21 = e0[3] - e1[3]; + v40_20 = e0[2] - e1[2]; + d0[3] = e0[3] + e1[3]; + d0[2] = e0[2] + e1[2]; + d1[3] = v41_21*AA[0] - v40_20*AA[1]; + d1[2] = v40_20*AA[0] + v41_21*AA[1]; + + AA -= 8; + + d0 += 4; + d1 += 4; + e0 += 4; + e1 += 4; + } + } + + // step 3 + ld = ilog(n) - 1; // ilog is off-by-one from normal definitions + + // optimized step 3: + + // the original step3 loop can be nested r inside s or s inside r; + // it's written originally as s inside r, but this is dumb when r + // iterates many times, and s few. So I have two copies of it and + // switch between them halfway. + + // this is iteration 0 of step 3 + imdct_step3_iter0_loop(n >> 4, u, n2-1-n4*0, -(n >> 3), A); + imdct_step3_iter0_loop(n >> 4, u, n2-1-n4*1, -(n >> 3), A); + + // this is iteration 1 of step 3 + imdct_step3_inner_r_loop(n >> 5, u, n2-1 - n8*0, -(n >> 4), A, 16); + imdct_step3_inner_r_loop(n >> 5, u, n2-1 - n8*1, -(n >> 4), A, 16); + imdct_step3_inner_r_loop(n >> 5, u, n2-1 - n8*2, -(n >> 4), A, 16); + imdct_step3_inner_r_loop(n >> 5, u, n2-1 - n8*3, -(n >> 4), A, 16); + + l=2; + for (; l < (ld-3)>>1; ++l) { + int k0 = n >> (l+2), k0_2 = k0>>1; + int lim = 1 << (l+1); + int i; + for (i=0; i < lim; ++i) + imdct_step3_inner_r_loop(n >> (l+4), u, n2-1 - k0*i, -k0_2, A, 1 << (l+3)); + } + + for (; l < ld-6; ++l) { + int k0 = n >> (l+2), k1 = 1 << (l+3), k0_2 = k0>>1; + int rlim = n >> (l+6), r; + int lim = 1 << (l+1); + int i_off; + float *A0 = A; + i_off = n2-1; + for (r=rlim; r > 0; --r) { + imdct_step3_inner_s_loop(lim, u, i_off, -k0_2, A0, k1, k0); + A0 += k1*4; + i_off -= 8; + } + } + + // iterations with count: + // ld-6,-5,-4 all interleaved together + // the big win comes from getting rid of needless flops + // due to the constants on pass 5 & 4 being all 1 and 0; + // combining them to be simultaneous to improve cache made little difference + imdct_step3_inner_s_loop_ld654(n >> 5, u, n2-1, A, n); + + // output is u + + // step 4, 5, and 6 + // cannot be in-place because of step 5 + { + uint16 *bitrev = f->bit_reverse[blocktype]; + // weirdly, I'd have thought reading sequentially and writing + // erratically would have been better than vice-versa, but in + // fact that's not what my testing showed. (That is, with + // j = bitreverse(i), do you read i and write j, or read j and write i.) + + float *d0 = &v[n4-4]; + float *d1 = &v[n2-4]; + while (d0 >= v) { + int k4; + + k4 = bitrev[0]; + d1[3] = u[k4+0]; + d1[2] = u[k4+1]; + d0[3] = u[k4+2]; + d0[2] = u[k4+3]; + + k4 = bitrev[1]; + d1[1] = u[k4+0]; + d1[0] = u[k4+1]; + d0[1] = u[k4+2]; + d0[0] = u[k4+3]; + + d0 -= 4; + d1 -= 4; + bitrev += 2; + } + } + // (paper output is u, now v) + + + // data must be in buf2 + assert(v == buf2); + + // step 7 (paper output is v, now v) + // this is now in place + { + float *C = f->C[blocktype]; + float *d, *e; + + d = v; + e = v + n2 - 4; + + while (d < e) { + float a02,a11,b0,b1,b2,b3; + + a02 = d[0] - e[2]; + a11 = d[1] + e[3]; + + b0 = C[1]*a02 + C[0]*a11; + b1 = C[1]*a11 - C[0]*a02; + + b2 = d[0] + e[ 2]; + b3 = d[1] - e[ 3]; + + d[0] = b2 + b0; + d[1] = b3 + b1; + e[2] = b2 - b0; + e[3] = b1 - b3; + + a02 = d[2] - e[0]; + a11 = d[3] + e[1]; + + b0 = C[3]*a02 + C[2]*a11; + b1 = C[3]*a11 - C[2]*a02; + + b2 = d[2] + e[ 0]; + b3 = d[3] - e[ 1]; + + d[2] = b2 + b0; + d[3] = b3 + b1; + e[0] = b2 - b0; + e[1] = b1 - b3; + + C += 4; + d += 4; + e -= 4; + } + } + + // data must be in buf2 + + + // step 8+decode (paper output is X, now buffer) + // this generates pairs of data a la 8 and pushes them directly through + // the decode kernel (pushing rather than pulling) to avoid having + // to make another pass later + + // this cannot POSSIBLY be in place, so we refer to the buffers directly + + { + float *d0,*d1,*d2,*d3; + + float *B = f->B[blocktype] + n2 - 8; + float *e = buf2 + n2 - 8; + d0 = &buffer[0]; + d1 = &buffer[n2-4]; + d2 = &buffer[n2]; + d3 = &buffer[n-4]; + while (e >= v) { + float p0,p1,p2,p3; + + p3 = e[6]*B[7] - e[7]*B[6]; + p2 = -e[6]*B[6] - e[7]*B[7]; + + d0[0] = p3; + d1[3] = - p3; + d2[0] = p2; + d3[3] = p2; + + p1 = e[4]*B[5] - e[5]*B[4]; + p0 = -e[4]*B[4] - e[5]*B[5]; + + d0[1] = p1; + d1[2] = - p1; + d2[1] = p0; + d3[2] = p0; + + p3 = e[2]*B[3] - e[3]*B[2]; + p2 = -e[2]*B[2] - e[3]*B[3]; + + d0[2] = p3; + d1[1] = - p3; + d2[2] = p2; + d3[1] = p2; + + p1 = e[0]*B[1] - e[1]*B[0]; + p0 = -e[0]*B[0] - e[1]*B[1]; + + d0[3] = p1; + d1[0] = - p1; + d2[3] = p0; + d3[0] = p0; + + B -= 8; + e -= 8; + d0 += 4; + d2 += 4; + d1 -= 4; + d3 -= 4; + } + } + + temp_free(f,buf2); + temp_alloc_restore(f,save_point); +} + +#if 0 +// this is the original version of the above code, if you want to optimize it from scratch +void inverse_mdct_naive(float *buffer, int n) +{ + float s; + float A[1 << 12], B[1 << 12], C[1 << 11]; + int i,k,k2,k4, n2 = n >> 1, n4 = n >> 2, n8 = n >> 3, l; + int n3_4 = n - n4, ld; + // how can they claim this only uses N words?! + // oh, because they're only used sparsely, whoops + float u[1 << 13], X[1 << 13], v[1 << 13], w[1 << 13]; + // set up twiddle factors + + for (k=k2=0; k < n4; ++k,k2+=2) { + A[k2 ] = (float) cos(4*k*M_PI/n); + A[k2+1] = (float) -sin(4*k*M_PI/n); + B[k2 ] = (float) cos((k2+1)*M_PI/n/2); + B[k2+1] = (float) sin((k2+1)*M_PI/n/2); + } + for (k=k2=0; k < n8; ++k,k2+=2) { + C[k2 ] = (float) cos(2*(k2+1)*M_PI/n); + C[k2+1] = (float) -sin(2*(k2+1)*M_PI/n); + } + + // IMDCT algorithm from "The use of multirate filter banks for coding of high quality digital audio" + // Note there are bugs in that pseudocode, presumably due to them attempting + // to rename the arrays nicely rather than representing the way their actual + // implementation bounces buffers back and forth. As a result, even in the + // "some formulars corrected" version, a direct implementation fails. These + // are noted below as "paper bug". + + // copy and reflect spectral data + for (k=0; k < n2; ++k) u[k] = buffer[k]; + for ( ; k < n ; ++k) u[k] = -buffer[n - k - 1]; + // kernel from paper + // step 1 + for (k=k2=k4=0; k < n4; k+=1, k2+=2, k4+=4) { + v[n-k4-1] = (u[k4] - u[n-k4-1]) * A[k2] - (u[k4+2] - u[n-k4-3])*A[k2+1]; + v[n-k4-3] = (u[k4] - u[n-k4-1]) * A[k2+1] + (u[k4+2] - u[n-k4-3])*A[k2]; + } + // step 2 + for (k=k4=0; k < n8; k+=1, k4+=4) { + w[n2+3+k4] = v[n2+3+k4] + v[k4+3]; + w[n2+1+k4] = v[n2+1+k4] + v[k4+1]; + w[k4+3] = (v[n2+3+k4] - v[k4+3])*A[n2-4-k4] - (v[n2+1+k4]-v[k4+1])*A[n2-3-k4]; + w[k4+1] = (v[n2+1+k4] - v[k4+1])*A[n2-4-k4] + (v[n2+3+k4]-v[k4+3])*A[n2-3-k4]; + } + // step 3 + ld = ilog(n) - 1; // ilog is off-by-one from normal definitions + for (l=0; l < ld-3; ++l) { + int k0 = n >> (l+2), k1 = 1 << (l+3); + int rlim = n >> (l+4), r4, r; + int s2lim = 1 << (l+2), s2; + for (r=r4=0; r < rlim; r4+=4,++r) { + for (s2=0; s2 < s2lim; s2+=2) { + u[n-1-k0*s2-r4] = w[n-1-k0*s2-r4] + w[n-1-k0*(s2+1)-r4]; + u[n-3-k0*s2-r4] = w[n-3-k0*s2-r4] + w[n-3-k0*(s2+1)-r4]; + u[n-1-k0*(s2+1)-r4] = (w[n-1-k0*s2-r4] - w[n-1-k0*(s2+1)-r4]) * A[r*k1] + - (w[n-3-k0*s2-r4] - w[n-3-k0*(s2+1)-r4]) * A[r*k1+1]; + u[n-3-k0*(s2+1)-r4] = (w[n-3-k0*s2-r4] - w[n-3-k0*(s2+1)-r4]) * A[r*k1] + + (w[n-1-k0*s2-r4] - w[n-1-k0*(s2+1)-r4]) * A[r*k1+1]; + } + } + if (l+1 < ld-3) { + // paper bug: ping-ponging of u&w here is omitted + memcpy(w, u, sizeof(u)); + } + } + + // step 4 + for (i=0; i < n8; ++i) { + int j = bit_reverse(i) >> (32-ld+3); + assert(j < n8); + if (i == j) { + // paper bug: original code probably swapped in place; if copying, + // need to directly copy in this case + int i8 = i << 3; + v[i8+1] = u[i8+1]; + v[i8+3] = u[i8+3]; + v[i8+5] = u[i8+5]; + v[i8+7] = u[i8+7]; + } else if (i < j) { + int i8 = i << 3, j8 = j << 3; + v[j8+1] = u[i8+1], v[i8+1] = u[j8 + 1]; + v[j8+3] = u[i8+3], v[i8+3] = u[j8 + 3]; + v[j8+5] = u[i8+5], v[i8+5] = u[j8 + 5]; + v[j8+7] = u[i8+7], v[i8+7] = u[j8 + 7]; + } + } + // step 5 + for (k=0; k < n2; ++k) { + w[k] = v[k*2+1]; + } + // step 6 + for (k=k2=k4=0; k < n8; ++k, k2 += 2, k4 += 4) { + u[n-1-k2] = w[k4]; + u[n-2-k2] = w[k4+1]; + u[n3_4 - 1 - k2] = w[k4+2]; + u[n3_4 - 2 - k2] = w[k4+3]; + } + // step 7 + for (k=k2=0; k < n8; ++k, k2 += 2) { + v[n2 + k2 ] = ( u[n2 + k2] + u[n-2-k2] + C[k2+1]*(u[n2+k2]-u[n-2-k2]) + C[k2]*(u[n2+k2+1]+u[n-2-k2+1]))/2; + v[n-2 - k2] = ( u[n2 + k2] + u[n-2-k2] - C[k2+1]*(u[n2+k2]-u[n-2-k2]) - C[k2]*(u[n2+k2+1]+u[n-2-k2+1]))/2; + v[n2+1+ k2] = ( u[n2+1+k2] - u[n-1-k2] + C[k2+1]*(u[n2+1+k2]+u[n-1-k2]) - C[k2]*(u[n2+k2]-u[n-2-k2]))/2; + v[n-1 - k2] = (-u[n2+1+k2] + u[n-1-k2] + C[k2+1]*(u[n2+1+k2]+u[n-1-k2]) - C[k2]*(u[n2+k2]-u[n-2-k2]))/2; + } + // step 8 + for (k=k2=0; k < n4; ++k,k2 += 2) { + X[k] = v[k2+n2]*B[k2 ] + v[k2+1+n2]*B[k2+1]; + X[n2-1-k] = v[k2+n2]*B[k2+1] - v[k2+1+n2]*B[k2 ]; + } + + // decode kernel to output + // determined the following value experimentally + // (by first figuring out what made inverse_mdct_slow work); then matching that here + // (probably vorbis encoder premultiplies by n or n/2, to save it on the decoder?) + s = 0.5; // theoretically would be n4 + + // [[[ note! the s value of 0.5 is compensated for by the B[] in the current code, + // so it needs to use the "old" B values to behave correctly, or else + // set s to 1.0 ]]] + for (i=0; i < n4 ; ++i) buffer[i] = s * X[i+n4]; + for ( ; i < n3_4; ++i) buffer[i] = -s * X[n3_4 - i - 1]; + for ( ; i < n ; ++i) buffer[i] = -s * X[i - n3_4]; +} +#endif + +static float *get_window(vorb *f, int len) +{ + len <<= 1; + if (len == f->blocksize_0) return f->window[0]; + if (len == f->blocksize_1) return f->window[1]; + return NULL; +} + +#ifndef STB_VORBIS_NO_DEFER_FLOOR +typedef int16 YTYPE; +#else +typedef int YTYPE; +#endif +static int do_floor(vorb *f, Mapping *map, int i, int n, float *target, YTYPE *finalY, uint8 *step2_flag) +{ + int n2 = n >> 1; + int s = map->chan[i].mux, floor; + floor = map->submap_floor[s]; + if (f->floor_types[floor] == 0) { + return error(f, VORBIS_invalid_stream); + } else { + Floor1 *g = &f->floor_config[floor].floor1; + int j,q; + int lx = 0, ly = finalY[0] * g->floor1_multiplier; + for (q=1; q < g->values; ++q) { + j = g->sorted_order[q]; + #ifndef STB_VORBIS_NO_DEFER_FLOOR + STBV_NOTUSED(step2_flag); + if (finalY[j] >= 0) + #else + if (step2_flag[j]) + #endif + { + int hy = finalY[j] * g->floor1_multiplier; + int hx = g->Xlist[j]; + if (lx != hx) + draw_line(target, lx,ly, hx,hy, n2); + CHECK(f); + lx = hx, ly = hy; + } + } + if (lx < n2) { + // optimization of: draw_line(target, lx,ly, n,ly, n2); + for (j=lx; j < n2; ++j) + LINE_OP(target[j], inverse_db_table[ly]); + CHECK(f); + } + } + return TRUE; +} + +// The meaning of "left" and "right" +// +// For a given frame: +// we compute samples from 0..n +// window_center is n/2 +// we'll window and mix the samples from left_start to left_end with data from the previous frame +// all of the samples from left_end to right_start can be output without mixing; however, +// this interval is 0-length except when transitioning between short and long frames +// all of the samples from right_start to right_end need to be mixed with the next frame, +// which we don't have, so those get saved in a buffer +// frame N's right_end-right_start, the number of samples to mix with the next frame, +// has to be the same as frame N+1's left_end-left_start (which they are by +// construction) + +static int vorbis_decode_initial(vorb *f, int *p_left_start, int *p_left_end, int *p_right_start, int *p_right_end, int *mode) +{ + Mode *m; + int i, n, prev, next, window_center; + f->channel_buffer_start = f->channel_buffer_end = 0; + + retry: + if (f->eof) return FALSE; + if (!maybe_start_packet(f)) + return FALSE; + // check packet type + if (get_bits(f,1) != 0) { + if (IS_PUSH_MODE(f)) + return error(f,VORBIS_bad_packet_type); + while (EOP != get8_packet(f)); + goto retry; + } + + if (f->alloc.alloc_buffer) + assert(f->alloc.alloc_buffer_length_in_bytes == f->temp_offset); + + i = get_bits(f, ilog(f->mode_count-1)); + if (i == EOP) return FALSE; + if (i >= f->mode_count) return FALSE; + *mode = i; + m = f->mode_config + i; + if (m->blockflag) { + n = f->blocksize_1; + prev = get_bits(f,1); + next = get_bits(f,1); + } else { + prev = next = 0; + n = f->blocksize_0; + } + +// WINDOWING + + window_center = n >> 1; + if (m->blockflag && !prev) { + *p_left_start = (n - f->blocksize_0) >> 2; + *p_left_end = (n + f->blocksize_0) >> 2; + } else { + *p_left_start = 0; + *p_left_end = window_center; + } + if (m->blockflag && !next) { + *p_right_start = (n*3 - f->blocksize_0) >> 2; + *p_right_end = (n*3 + f->blocksize_0) >> 2; + } else { + *p_right_start = window_center; + *p_right_end = n; + } + + return TRUE; +} + +static int vorbis_decode_packet_rest(vorb *f, int *len, Mode *m, int left_start, int left_end, int right_start, int right_end, int *p_left) +{ + Mapping *map; + int i,j,k,n,n2; + int zero_channel[256]; + int really_zero_channel[256]; + +// WINDOWING + + STBV_NOTUSED(left_end); + n = f->blocksize[m->blockflag]; + map = &f->mapping[m->mapping]; + +// FLOORS + n2 = n >> 1; + + CHECK(f); + + for (i=0; i < f->channels; ++i) { + int s = map->chan[i].mux, floor; + zero_channel[i] = FALSE; + floor = map->submap_floor[s]; + if (f->floor_types[floor] == 0) { + return error(f, VORBIS_invalid_stream); + } else { + Floor1 *g = &f->floor_config[floor].floor1; + if (get_bits(f, 1)) { + short *finalY; + uint8 step2_flag[256]; + static int range_list[4] = { 256, 128, 86, 64 }; + int range = range_list[g->floor1_multiplier-1]; + int offset = 2; + finalY = f->finalY[i]; + finalY[0] = get_bits(f, ilog(range)-1); + finalY[1] = get_bits(f, ilog(range)-1); + for (j=0; j < g->partitions; ++j) { + int pclass = g->partition_class_list[j]; + int cdim = g->class_dimensions[pclass]; + int cbits = g->class_subclasses[pclass]; + int csub = (1 << cbits)-1; + int cval = 0; + if (cbits) { + Codebook *c = f->codebooks + g->class_masterbooks[pclass]; + DECODE(cval,f,c); + } + for (k=0; k < cdim; ++k) { + int book = g->subclass_books[pclass][cval & csub]; + cval = cval >> cbits; + if (book >= 0) { + int temp; + Codebook *c = f->codebooks + book; + DECODE(temp,f,c); + finalY[offset++] = temp; + } else + finalY[offset++] = 0; + } + } + if (f->valid_bits == INVALID_BITS) goto error; // behavior according to spec + step2_flag[0] = step2_flag[1] = 1; + for (j=2; j < g->values; ++j) { + int low, high, pred, highroom, lowroom, room, val; + low = g->neighbors[j][0]; + high = g->neighbors[j][1]; + //neighbors(g->Xlist, j, &low, &high); + pred = predict_point(g->Xlist[j], g->Xlist[low], g->Xlist[high], finalY[low], finalY[high]); + val = finalY[j]; + highroom = range - pred; + lowroom = pred; + if (highroom < lowroom) + room = highroom * 2; + else + room = lowroom * 2; + if (val) { + step2_flag[low] = step2_flag[high] = 1; + step2_flag[j] = 1; + if (val >= room) + if (highroom > lowroom) + finalY[j] = val - lowroom + pred; + else + finalY[j] = pred - val + highroom - 1; + else + if (val & 1) + finalY[j] = pred - ((val+1)>>1); + else + finalY[j] = pred + (val>>1); + } else { + step2_flag[j] = 0; + finalY[j] = pred; + } + } + +#ifdef STB_VORBIS_NO_DEFER_FLOOR + do_floor(f, map, i, n, f->floor_buffers[i], finalY, step2_flag); +#else + // defer final floor computation until _after_ residue + for (j=0; j < g->values; ++j) { + if (!step2_flag[j]) + finalY[j] = -1; + } +#endif + } else { + error: + zero_channel[i] = TRUE; + } + // So we just defer everything else to later + + // at this point we've decoded the floor into buffer + } + } + CHECK(f); + // at this point we've decoded all floors + + if (f->alloc.alloc_buffer) + assert(f->alloc.alloc_buffer_length_in_bytes == f->temp_offset); + + // re-enable coupled channels if necessary + memcpy(really_zero_channel, zero_channel, sizeof(really_zero_channel[0]) * f->channels); + for (i=0; i < map->coupling_steps; ++i) + if (!zero_channel[map->chan[i].magnitude] || !zero_channel[map->chan[i].angle]) { + zero_channel[map->chan[i].magnitude] = zero_channel[map->chan[i].angle] = FALSE; + } + + CHECK(f); +// RESIDUE DECODE + for (i=0; i < map->submaps; ++i) { + float *residue_buffers[STB_VORBIS_MAX_CHANNELS]; + int r; + uint8 do_not_decode[256]; + int ch = 0; + for (j=0; j < f->channels; ++j) { + if (map->chan[j].mux == i) { + if (zero_channel[j]) { + do_not_decode[ch] = TRUE; + residue_buffers[ch] = NULL; + } else { + do_not_decode[ch] = FALSE; + residue_buffers[ch] = f->channel_buffers[j]; + } + ++ch; + } + } + r = map->submap_residue[i]; + decode_residue(f, residue_buffers, ch, n2, r, do_not_decode); + } + + if (f->alloc.alloc_buffer) + assert(f->alloc.alloc_buffer_length_in_bytes == f->temp_offset); + CHECK(f); + +// INVERSE COUPLING + for (i = map->coupling_steps-1; i >= 0; --i) { + int n2 = n >> 1; + float *m = f->channel_buffers[map->chan[i].magnitude]; + float *a = f->channel_buffers[map->chan[i].angle ]; + for (j=0; j < n2; ++j) { + float a2,m2; + if (m[j] > 0) + if (a[j] > 0) + m2 = m[j], a2 = m[j] - a[j]; + else + a2 = m[j], m2 = m[j] + a[j]; + else + if (a[j] > 0) + m2 = m[j], a2 = m[j] + a[j]; + else + a2 = m[j], m2 = m[j] - a[j]; + m[j] = m2; + a[j] = a2; + } + } + CHECK(f); + + // finish decoding the floors +#ifndef STB_VORBIS_NO_DEFER_FLOOR + for (i=0; i < f->channels; ++i) { + if (really_zero_channel[i]) { + memset(f->channel_buffers[i], 0, sizeof(*f->channel_buffers[i]) * n2); + } else { + do_floor(f, map, i, n, f->channel_buffers[i], f->finalY[i], NULL); + } + } +#else + for (i=0; i < f->channels; ++i) { + if (really_zero_channel[i]) { + memset(f->channel_buffers[i], 0, sizeof(*f->channel_buffers[i]) * n2); + } else { + for (j=0; j < n2; ++j) + f->channel_buffers[i][j] *= f->floor_buffers[i][j]; + } + } +#endif + +// INVERSE MDCT + CHECK(f); + for (i=0; i < f->channels; ++i) + inverse_mdct(f->channel_buffers[i], n, f, m->blockflag); + CHECK(f); + + // this shouldn't be necessary, unless we exited on an error + // and want to flush to get to the next packet + flush_packet(f); + + if (f->first_decode) { + // assume we start so first non-discarded sample is sample 0 + // this isn't to spec, but spec would require us to read ahead + // and decode the size of all current frames--could be done, + // but presumably it's not a commonly used feature + f->current_loc = 0u - n2; // start of first frame is positioned for discard (NB this is an intentional unsigned overflow/wrap-around) + // we might have to discard samples "from" the next frame too, + // if we're lapping a large block then a small at the start? + f->discard_samples_deferred = n - right_end; + f->current_loc_valid = TRUE; + f->first_decode = FALSE; + } else if (f->discard_samples_deferred) { + if (f->discard_samples_deferred >= right_start - left_start) { + f->discard_samples_deferred -= (right_start - left_start); + left_start = right_start; + *p_left = left_start; + } else { + left_start += f->discard_samples_deferred; + *p_left = left_start; + f->discard_samples_deferred = 0; + } + } else if (f->previous_length == 0 && f->current_loc_valid) { + // we're recovering from a seek... that means we're going to discard + // the samples from this packet even though we know our position from + // the last page header, so we need to update the position based on + // the discarded samples here + // but wait, the code below is going to add this in itself even + // on a discard, so we don't need to do it here... + } + + // check if we have ogg information about the sample # for this packet + if (f->last_seg_which == f->end_seg_with_known_loc) { + // if we have a valid current loc, and this is final: + if (f->current_loc_valid && (f->page_flag & PAGEFLAG_last_page)) { + uint32 current_end = f->known_loc_for_packet; + // then let's infer the size of the (probably) short final frame + if (current_end < f->current_loc + (right_end-left_start)) { + if (current_end < f->current_loc) { + // negative truncation, that's impossible! + *len = 0; + } else { + *len = current_end - f->current_loc; + } + *len += left_start; // this doesn't seem right, but has no ill effect on my test files + if (*len > right_end) *len = right_end; // this should never happen + f->current_loc += *len; + return TRUE; + } + } + // otherwise, just set our sample loc + // guess that the ogg granule pos refers to the _middle_ of the + // last frame? + // set f->current_loc to the position of left_start + f->current_loc = f->known_loc_for_packet - (n2-left_start); + f->current_loc_valid = TRUE; + } + if (f->current_loc_valid) + f->current_loc += (right_start - left_start); + + if (f->alloc.alloc_buffer) + assert(f->alloc.alloc_buffer_length_in_bytes == f->temp_offset); + *len = right_end; // ignore samples after the window goes to 0 + CHECK(f); + + return TRUE; +} + +static int vorbis_decode_packet(vorb *f, int *len, int *p_left, int *p_right) +{ + int mode, left_end, right_end; + if (!vorbis_decode_initial(f, p_left, &left_end, p_right, &right_end, &mode)) return 0; + return vorbis_decode_packet_rest(f, len, f->mode_config + mode, *p_left, left_end, *p_right, right_end, p_left); +} + +static int vorbis_finish_frame(stb_vorbis *f, int len, int left, int right) +{ + int prev,i,j; + // we use right&left (the start of the right- and left-window sin()-regions) + // to determine how much to return, rather than inferring from the rules + // (same result, clearer code); 'left' indicates where our sin() window + // starts, therefore where the previous window's right edge starts, and + // therefore where to start mixing from the previous buffer. 'right' + // indicates where our sin() ending-window starts, therefore that's where + // we start saving, and where our returned-data ends. + + // mixin from previous window + if (f->previous_length) { + int i,j, n = f->previous_length; + float *w = get_window(f, n); + if (w == NULL) return 0; + for (i=0; i < f->channels; ++i) { + for (j=0; j < n; ++j) + f->channel_buffers[i][left+j] = + f->channel_buffers[i][left+j]*w[ j] + + f->previous_window[i][ j]*w[n-1-j]; + } + } + + prev = f->previous_length; + + // last half of this data becomes previous window + f->previous_length = len - right; + + // @OPTIMIZE: could avoid this copy by double-buffering the + // output (flipping previous_window with channel_buffers), but + // then previous_window would have to be 2x as large, and + // channel_buffers couldn't be temp mem (although they're NOT + // currently temp mem, they could be (unless we want to level + // performance by spreading out the computation)) + for (i=0; i < f->channels; ++i) + for (j=0; right+j < len; ++j) + f->previous_window[i][j] = f->channel_buffers[i][right+j]; + + if (!prev) + // there was no previous packet, so this data isn't valid... + // this isn't entirely true, only the would-have-overlapped data + // isn't valid, but this seems to be what the spec requires + return 0; + + // truncate a short frame + if (len < right) right = len; + + f->samples_output += right-left; + + return right - left; +} + +static int vorbis_pump_first_frame(stb_vorbis *f) +{ + int len, right, left, res; + res = vorbis_decode_packet(f, &len, &left, &right); + if (res) + vorbis_finish_frame(f, len, left, right); + return res; +} + +#ifndef STB_VORBIS_NO_PUSHDATA_API +static int is_whole_packet_present(stb_vorbis *f) +{ + // make sure that we have the packet available before continuing... + // this requires a full ogg parse, but we know we can fetch from f->stream + + // instead of coding this out explicitly, we could save the current read state, + // read the next packet with get8() until end-of-packet, check f->eof, then + // reset the state? but that would be slower, esp. since we'd have over 256 bytes + // of state to restore (primarily the page segment table) + + int s = f->next_seg, first = TRUE; + uint8 *p = f->stream; + + if (s != -1) { // if we're not starting the packet with a 'continue on next page' flag + for (; s < f->segment_count; ++s) { + p += f->segments[s]; + if (f->segments[s] < 255) // stop at first short segment + break; + } + // either this continues, or it ends it... + if (s == f->segment_count) + s = -1; // set 'crosses page' flag + if (p > f->stream_end) return error(f, VORBIS_need_more_data); + first = FALSE; + } + for (; s == -1;) { + uint8 *q; + int n; + + // check that we have the page header ready + if (p + 26 >= f->stream_end) return error(f, VORBIS_need_more_data); + // validate the page + if (memcmp(p, ogg_page_header, 4)) return error(f, VORBIS_invalid_stream); + if (p[4] != 0) return error(f, VORBIS_invalid_stream); + if (first) { // the first segment must NOT have 'continued_packet', later ones MUST + if (f->previous_length) + if ((p[5] & PAGEFLAG_continued_packet)) return error(f, VORBIS_invalid_stream); + // if no previous length, we're resynching, so we can come in on a continued-packet, + // which we'll just drop + } else { + if (!(p[5] & PAGEFLAG_continued_packet)) return error(f, VORBIS_invalid_stream); + } + n = p[26]; // segment counts + q = p+27; // q points to segment table + p = q + n; // advance past header + // make sure we've read the segment table + if (p > f->stream_end) return error(f, VORBIS_need_more_data); + for (s=0; s < n; ++s) { + p += q[s]; + if (q[s] < 255) + break; + } + if (s == n) + s = -1; // set 'crosses page' flag + if (p > f->stream_end) return error(f, VORBIS_need_more_data); + first = FALSE; + } + return TRUE; +} +#endif // !STB_VORBIS_NO_PUSHDATA_API + +static int start_decoder(vorb *f) +{ + uint8 header[6], x,y; + int len,i,j,k, max_submaps = 0; + int longest_floorlist=0; + + // first page, first packet + f->first_decode = TRUE; + + if (!start_page(f)) return FALSE; + // validate page flag + if (!(f->page_flag & PAGEFLAG_first_page)) return error(f, VORBIS_invalid_first_page); + if (f->page_flag & PAGEFLAG_last_page) return error(f, VORBIS_invalid_first_page); + if (f->page_flag & PAGEFLAG_continued_packet) return error(f, VORBIS_invalid_first_page); + // check for expected packet length + if (f->segment_count != 1) return error(f, VORBIS_invalid_first_page); + if (f->segments[0] != 30) { + // check for the Ogg skeleton fishead identifying header to refine our error + if (f->segments[0] == 64 && + getn(f, header, 6) && + header[0] == 'f' && + header[1] == 'i' && + header[2] == 's' && + header[3] == 'h' && + header[4] == 'e' && + header[5] == 'a' && + get8(f) == 'd' && + get8(f) == '\0') return error(f, VORBIS_ogg_skeleton_not_supported); + else + return error(f, VORBIS_invalid_first_page); + } + + // read packet + // check packet header + if (get8(f) != VORBIS_packet_id) return error(f, VORBIS_invalid_first_page); + if (!getn(f, header, 6)) return error(f, VORBIS_unexpected_eof); + if (!vorbis_validate(header)) return error(f, VORBIS_invalid_first_page); + // vorbis_version + if (get32(f) != 0) return error(f, VORBIS_invalid_first_page); + f->channels = get8(f); if (!f->channels) return error(f, VORBIS_invalid_first_page); + if (f->channels > STB_VORBIS_MAX_CHANNELS) return error(f, VORBIS_too_many_channels); + f->sample_rate = get32(f); if (!f->sample_rate) return error(f, VORBIS_invalid_first_page); + get32(f); // bitrate_maximum + get32(f); // bitrate_nominal + get32(f); // bitrate_minimum + x = get8(f); + { + int log0,log1; + log0 = x & 15; + log1 = x >> 4; + f->blocksize_0 = 1 << log0; + f->blocksize_1 = 1 << log1; + if (log0 < 6 || log0 > 13) return error(f, VORBIS_invalid_setup); + if (log1 < 6 || log1 > 13) return error(f, VORBIS_invalid_setup); + if (log0 > log1) return error(f, VORBIS_invalid_setup); + } + + // framing_flag + x = get8(f); + if (!(x & 1)) return error(f, VORBIS_invalid_first_page); + + // second packet! + if (!start_page(f)) return FALSE; + + if (!start_packet(f)) return FALSE; + + if (!next_segment(f)) return FALSE; + + if (get8_packet(f) != VORBIS_packet_comment) return error(f, VORBIS_invalid_setup); + for (i=0; i < 6; ++i) header[i] = get8_packet(f); + if (!vorbis_validate(header)) return error(f, VORBIS_invalid_setup); + //file vendor + len = get32_packet(f); + f->vendor = (char*)setup_malloc(f, sizeof(char) * (len+1)); + if (f->vendor == NULL) return error(f, VORBIS_outofmem); + for(i=0; i < len; ++i) { + f->vendor[i] = get8_packet(f); + } + f->vendor[len] = (char)'\0'; + //user comments + f->comment_list_length = get32_packet(f); + f->comment_list = NULL; + if (f->comment_list_length > 0) + { + f->comment_list = (char**) setup_malloc(f, sizeof(char*) * (f->comment_list_length)); + if (f->comment_list == NULL) return error(f, VORBIS_outofmem); + } + + for(i=0; i < f->comment_list_length; ++i) { + len = get32_packet(f); + f->comment_list[i] = (char*)setup_malloc(f, sizeof(char) * (len+1)); + if (f->comment_list[i] == NULL) return error(f, VORBIS_outofmem); + + for(j=0; j < len; ++j) { + f->comment_list[i][j] = get8_packet(f); + } + f->comment_list[i][len] = (char)'\0'; + } + + // framing_flag + x = get8_packet(f); + if (!(x & 1)) return error(f, VORBIS_invalid_setup); + + + skip(f, f->bytes_in_seg); + f->bytes_in_seg = 0; + + do { + len = next_segment(f); + skip(f, len); + f->bytes_in_seg = 0; + } while (len); + + // third packet! + if (!start_packet(f)) return FALSE; + + #ifndef STB_VORBIS_NO_PUSHDATA_API + if (IS_PUSH_MODE(f)) { + if (!is_whole_packet_present(f)) { + // convert error in ogg header to write type + if (f->error == VORBIS_invalid_stream) + f->error = VORBIS_invalid_setup; + return FALSE; + } + } + #endif + + crc32_init(); // always init it, to avoid multithread race conditions + + if (get8_packet(f) != VORBIS_packet_setup) return error(f, VORBIS_invalid_setup); + for (i=0; i < 6; ++i) header[i] = get8_packet(f); + if (!vorbis_validate(header)) return error(f, VORBIS_invalid_setup); + + // codebooks + + f->codebook_count = get_bits(f,8) + 1; + f->codebooks = (Codebook *) setup_malloc(f, sizeof(*f->codebooks) * f->codebook_count); + if (f->codebooks == NULL) return error(f, VORBIS_outofmem); + memset(f->codebooks, 0, sizeof(*f->codebooks) * f->codebook_count); + for (i=0; i < f->codebook_count; ++i) { + uint32 *values; + int ordered, sorted_count; + int total=0; + uint8 *lengths; + Codebook *c = f->codebooks+i; + CHECK(f); + x = get_bits(f, 8); if (x != 0x42) return error(f, VORBIS_invalid_setup); + x = get_bits(f, 8); if (x != 0x43) return error(f, VORBIS_invalid_setup); + x = get_bits(f, 8); if (x != 0x56) return error(f, VORBIS_invalid_setup); + x = get_bits(f, 8); + c->dimensions = (get_bits(f, 8)<<8) + x; + x = get_bits(f, 8); + y = get_bits(f, 8); + c->entries = (get_bits(f, 8)<<16) + (y<<8) + x; + ordered = get_bits(f,1); + c->sparse = ordered ? 0 : get_bits(f,1); + + if (c->dimensions == 0 && c->entries != 0) return error(f, VORBIS_invalid_setup); + + if (c->sparse) + lengths = (uint8 *) setup_temp_malloc(f, c->entries); + else + lengths = c->codeword_lengths = (uint8 *) setup_malloc(f, c->entries); + + if (!lengths) return error(f, VORBIS_outofmem); + + if (ordered) { + int current_entry = 0; + int current_length = get_bits(f,5) + 1; + while (current_entry < c->entries) { + int limit = c->entries - current_entry; + int n = get_bits(f, ilog(limit)); + if (current_length >= 32) return error(f, VORBIS_invalid_setup); + if (current_entry + n > (int) c->entries) { return error(f, VORBIS_invalid_setup); } + memset(lengths + current_entry, current_length, n); + current_entry += n; + ++current_length; + } + } else { + for (j=0; j < c->entries; ++j) { + int present = c->sparse ? get_bits(f,1) : 1; + if (present) { + lengths[j] = get_bits(f, 5) + 1; + ++total; + if (lengths[j] == 32) + return error(f, VORBIS_invalid_setup); + } else { + lengths[j] = NO_CODE; + } + } + } + + if (c->sparse && total >= c->entries >> 2) { + // convert sparse items to non-sparse! + if (c->entries > (int) f->setup_temp_memory_required) + f->setup_temp_memory_required = c->entries; + + c->codeword_lengths = (uint8 *) setup_malloc(f, c->entries); + if (c->codeword_lengths == NULL) return error(f, VORBIS_outofmem); + memcpy(c->codeword_lengths, lengths, c->entries); + setup_temp_free(f, lengths, c->entries); // note this is only safe if there have been no intervening temp mallocs! + lengths = c->codeword_lengths; + c->sparse = 0; + } + + // compute the size of the sorted tables + if (c->sparse) { + sorted_count = total; + } else { + sorted_count = 0; + #ifndef STB_VORBIS_NO_HUFFMAN_BINARY_SEARCH + for (j=0; j < c->entries; ++j) + if (lengths[j] > STB_VORBIS_FAST_HUFFMAN_LENGTH && lengths[j] != NO_CODE) + ++sorted_count; + #endif + } + + c->sorted_entries = sorted_count; + values = NULL; + + CHECK(f); + if (!c->sparse) { + c->codewords = (uint32 *) setup_malloc(f, sizeof(c->codewords[0]) * c->entries); + if (!c->codewords) return error(f, VORBIS_outofmem); + } else { + unsigned int size; + if (c->sorted_entries) { + c->codeword_lengths = (uint8 *) setup_malloc(f, c->sorted_entries); + if (!c->codeword_lengths) return error(f, VORBIS_outofmem); + c->codewords = (uint32 *) setup_temp_malloc(f, sizeof(*c->codewords) * c->sorted_entries); + if (!c->codewords) return error(f, VORBIS_outofmem); + values = (uint32 *) setup_temp_malloc(f, sizeof(*values) * c->sorted_entries); + if (!values) return error(f, VORBIS_outofmem); + } + size = c->entries + (sizeof(*c->codewords) + sizeof(*values)) * c->sorted_entries; + if (size > f->setup_temp_memory_required) + f->setup_temp_memory_required = size; + } + + if (!compute_codewords(c, lengths, c->entries, values)) { + if (c->sparse) setup_temp_free(f, values, 0); + return error(f, VORBIS_invalid_setup); + } + + if (c->sorted_entries) { + // allocate an extra slot for sentinels + c->sorted_codewords = (uint32 *) setup_malloc(f, sizeof(*c->sorted_codewords) * (c->sorted_entries+1)); + if (c->sorted_codewords == NULL) return error(f, VORBIS_outofmem); + // allocate an extra slot at the front so that c->sorted_values[-1] is defined + // so that we can catch that case without an extra if + c->sorted_values = ( int *) setup_malloc(f, sizeof(*c->sorted_values ) * (c->sorted_entries+1)); + if (c->sorted_values == NULL) return error(f, VORBIS_outofmem); + ++c->sorted_values; + c->sorted_values[-1] = -1; + compute_sorted_huffman(c, lengths, values); + } + + if (c->sparse) { + setup_temp_free(f, values, sizeof(*values)*c->sorted_entries); + setup_temp_free(f, c->codewords, sizeof(*c->codewords)*c->sorted_entries); + setup_temp_free(f, lengths, c->entries); + c->codewords = NULL; + } + + compute_accelerated_huffman(c); + + CHECK(f); + c->lookup_type = get_bits(f, 4); + if (c->lookup_type > 2) return error(f, VORBIS_invalid_setup); + if (c->lookup_type > 0) { + uint16 *mults; + c->minimum_value = float32_unpack(get_bits(f, 32)); + c->delta_value = float32_unpack(get_bits(f, 32)); + c->value_bits = get_bits(f, 4)+1; + c->sequence_p = get_bits(f,1); + if (c->lookup_type == 1) { + int values = lookup1_values(c->entries, c->dimensions); + if (values < 0) return error(f, VORBIS_invalid_setup); + c->lookup_values = (uint32) values; + } else { + c->lookup_values = c->entries * c->dimensions; + } + if (c->lookup_values == 0) return error(f, VORBIS_invalid_setup); + mults = (uint16 *) setup_temp_malloc(f, sizeof(mults[0]) * c->lookup_values); + if (mults == NULL) return error(f, VORBIS_outofmem); + for (j=0; j < (int) c->lookup_values; ++j) { + int q = get_bits(f, c->value_bits); + if (q == EOP) { setup_temp_free(f,mults,sizeof(mults[0])*c->lookup_values); return error(f, VORBIS_invalid_setup); } + mults[j] = q; + } + +#ifndef STB_VORBIS_DIVIDES_IN_CODEBOOK + if (c->lookup_type == 1) { + int len, sparse = c->sparse; + float last=0; + // pre-expand the lookup1-style multiplicands, to avoid a divide in the inner loop + if (sparse) { + if (c->sorted_entries == 0) goto skip; + c->multiplicands = (codetype *) setup_malloc(f, sizeof(c->multiplicands[0]) * c->sorted_entries * c->dimensions); + } else + c->multiplicands = (codetype *) setup_malloc(f, sizeof(c->multiplicands[0]) * c->entries * c->dimensions); + if (c->multiplicands == NULL) { setup_temp_free(f,mults,sizeof(mults[0])*c->lookup_values); return error(f, VORBIS_outofmem); } + len = sparse ? c->sorted_entries : c->entries; + for (j=0; j < len; ++j) { + unsigned int z = sparse ? c->sorted_values[j] : j; + unsigned int div=1; + for (k=0; k < c->dimensions; ++k) { + int off = (z / div) % c->lookup_values; + float val = mults[off]*c->delta_value + c->minimum_value + last; + c->multiplicands[j*c->dimensions + k] = val; + if (c->sequence_p) + last = val; + if (k+1 < c->dimensions) { + if (div > UINT_MAX / (unsigned int) c->lookup_values) { + setup_temp_free(f, mults,sizeof(mults[0])*c->lookup_values); + return error(f, VORBIS_invalid_setup); + } + div *= c->lookup_values; + } + } + } + c->lookup_type = 2; + } + else +#endif + { + float last=0; + CHECK(f); + c->multiplicands = (codetype *) setup_malloc(f, sizeof(c->multiplicands[0]) * c->lookup_values); + if (c->multiplicands == NULL) { setup_temp_free(f, mults,sizeof(mults[0])*c->lookup_values); return error(f, VORBIS_outofmem); } + for (j=0; j < (int) c->lookup_values; ++j) { + float val = mults[j] * c->delta_value + c->minimum_value + last; + c->multiplicands[j] = val; + if (c->sequence_p) + last = val; + } + } +#ifndef STB_VORBIS_DIVIDES_IN_CODEBOOK + skip:; +#endif + setup_temp_free(f, mults, sizeof(mults[0])*c->lookup_values); + + CHECK(f); + } + CHECK(f); + } + + // time domain transfers (notused) + + x = get_bits(f, 6) + 1; + for (i=0; i < x; ++i) { + uint32 z = get_bits(f, 16); + if (z != 0) return error(f, VORBIS_invalid_setup); + } + + // Floors + f->floor_count = get_bits(f, 6)+1; + f->floor_config = (Floor *) setup_malloc(f, f->floor_count * sizeof(*f->floor_config)); + if (f->floor_config == NULL) return error(f, VORBIS_outofmem); + for (i=0; i < f->floor_count; ++i) { + f->floor_types[i] = get_bits(f, 16); + if (f->floor_types[i] > 1) return error(f, VORBIS_invalid_setup); + if (f->floor_types[i] == 0) { + Floor0 *g = &f->floor_config[i].floor0; + g->order = get_bits(f,8); + g->rate = get_bits(f,16); + g->bark_map_size = get_bits(f,16); + g->amplitude_bits = get_bits(f,6); + g->amplitude_offset = get_bits(f,8); + g->number_of_books = get_bits(f,4) + 1; + for (j=0; j < g->number_of_books; ++j) + g->book_list[j] = get_bits(f,8); + return error(f, VORBIS_feature_not_supported); + } else { + stbv__floor_ordering p[31*8+2]; + Floor1 *g = &f->floor_config[i].floor1; + int max_class = -1; + g->partitions = get_bits(f, 5); + for (j=0; j < g->partitions; ++j) { + g->partition_class_list[j] = get_bits(f, 4); + if (g->partition_class_list[j] > max_class) + max_class = g->partition_class_list[j]; + } + for (j=0; j <= max_class; ++j) { + g->class_dimensions[j] = get_bits(f, 3)+1; + g->class_subclasses[j] = get_bits(f, 2); + if (g->class_subclasses[j]) { + g->class_masterbooks[j] = get_bits(f, 8); + if (g->class_masterbooks[j] >= f->codebook_count) return error(f, VORBIS_invalid_setup); + } + for (k=0; k < 1 << g->class_subclasses[j]; ++k) { + g->subclass_books[j][k] = (int16)get_bits(f,8)-1; + if (g->subclass_books[j][k] >= f->codebook_count) return error(f, VORBIS_invalid_setup); + } + } + g->floor1_multiplier = get_bits(f,2)+1; + g->rangebits = get_bits(f,4); + g->Xlist[0] = 0; + g->Xlist[1] = 1 << g->rangebits; + g->values = 2; + for (j=0; j < g->partitions; ++j) { + int c = g->partition_class_list[j]; + for (k=0; k < g->class_dimensions[c]; ++k) { + g->Xlist[g->values] = get_bits(f, g->rangebits); + ++g->values; + } + } + // precompute the sorting + for (j=0; j < g->values; ++j) { + p[j].x = g->Xlist[j]; + p[j].id = j; + } + qsort(p, g->values, sizeof(p[0]), point_compare); + for (j=0; j < g->values-1; ++j) + if (p[j].x == p[j+1].x) + return error(f, VORBIS_invalid_setup); + for (j=0; j < g->values; ++j) + g->sorted_order[j] = (uint8) p[j].id; + // precompute the neighbors + for (j=2; j < g->values; ++j) { + int low = 0,hi = 0; + neighbors(g->Xlist, j, &low,&hi); + g->neighbors[j][0] = low; + g->neighbors[j][1] = hi; + } + + if (g->values > longest_floorlist) + longest_floorlist = g->values; + } + } + + // Residue + f->residue_count = get_bits(f, 6)+1; + f->residue_config = (Residue *) setup_malloc(f, f->residue_count * sizeof(f->residue_config[0])); + if (f->residue_config == NULL) return error(f, VORBIS_outofmem); + memset(f->residue_config, 0, f->residue_count * sizeof(f->residue_config[0])); + for (i=0; i < f->residue_count; ++i) { + uint8 residue_cascade[64]; + Residue *r = f->residue_config+i; + f->residue_types[i] = get_bits(f, 16); + if (f->residue_types[i] > 2) return error(f, VORBIS_invalid_setup); + r->begin = get_bits(f, 24); + r->end = get_bits(f, 24); + if (r->end < r->begin) return error(f, VORBIS_invalid_setup); + r->part_size = get_bits(f,24)+1; + r->classifications = get_bits(f,6)+1; + r->classbook = get_bits(f,8); + if (r->classbook >= f->codebook_count) return error(f, VORBIS_invalid_setup); + for (j=0; j < r->classifications; ++j) { + uint8 high_bits=0; + uint8 low_bits=get_bits(f,3); + if (get_bits(f,1)) + high_bits = get_bits(f,5); + residue_cascade[j] = high_bits*8 + low_bits; + } + r->residue_books = (short (*)[8]) setup_malloc(f, sizeof(r->residue_books[0]) * r->classifications); + if (r->residue_books == NULL) return error(f, VORBIS_outofmem); + for (j=0; j < r->classifications; ++j) { + for (k=0; k < 8; ++k) { + if (residue_cascade[j] & (1 << k)) { + r->residue_books[j][k] = get_bits(f, 8); + if (r->residue_books[j][k] >= f->codebook_count) return error(f, VORBIS_invalid_setup); + } else { + r->residue_books[j][k] = -1; + } + } + } + // precompute the classifications[] array to avoid inner-loop mod/divide + // call it 'classdata' since we already have r->classifications + r->classdata = (uint8 **) setup_malloc(f, sizeof(*r->classdata) * f->codebooks[r->classbook].entries); + if (!r->classdata) return error(f, VORBIS_outofmem); + memset(r->classdata, 0, sizeof(*r->classdata) * f->codebooks[r->classbook].entries); + for (j=0; j < f->codebooks[r->classbook].entries; ++j) { + int classwords = f->codebooks[r->classbook].dimensions; + int temp = j; + r->classdata[j] = (uint8 *) setup_malloc(f, sizeof(r->classdata[j][0]) * classwords); + if (r->classdata[j] == NULL) return error(f, VORBIS_outofmem); + for (k=classwords-1; k >= 0; --k) { + r->classdata[j][k] = temp % r->classifications; + temp /= r->classifications; + } + } + } + + f->mapping_count = get_bits(f,6)+1; + f->mapping = (Mapping *) setup_malloc(f, f->mapping_count * sizeof(*f->mapping)); + if (f->mapping == NULL) return error(f, VORBIS_outofmem); + memset(f->mapping, 0, f->mapping_count * sizeof(*f->mapping)); + for (i=0; i < f->mapping_count; ++i) { + Mapping *m = f->mapping + i; + int mapping_type = get_bits(f,16); + if (mapping_type != 0) return error(f, VORBIS_invalid_setup); + m->chan = (MappingChannel *) setup_malloc(f, f->channels * sizeof(*m->chan)); + if (m->chan == NULL) return error(f, VORBIS_outofmem); + if (get_bits(f,1)) + m->submaps = get_bits(f,4)+1; + else + m->submaps = 1; + if (m->submaps > max_submaps) + max_submaps = m->submaps; + if (get_bits(f,1)) { + m->coupling_steps = get_bits(f,8)+1; + if (m->coupling_steps > f->channels) return error(f, VORBIS_invalid_setup); + for (k=0; k < m->coupling_steps; ++k) { + m->chan[k].magnitude = get_bits(f, ilog(f->channels-1)); + m->chan[k].angle = get_bits(f, ilog(f->channels-1)); + if (m->chan[k].magnitude >= f->channels) return error(f, VORBIS_invalid_setup); + if (m->chan[k].angle >= f->channels) return error(f, VORBIS_invalid_setup); + if (m->chan[k].magnitude == m->chan[k].angle) return error(f, VORBIS_invalid_setup); + } + } else + m->coupling_steps = 0; + + // reserved field + if (get_bits(f,2)) return error(f, VORBIS_invalid_setup); + if (m->submaps > 1) { + for (j=0; j < f->channels; ++j) { + m->chan[j].mux = get_bits(f, 4); + if (m->chan[j].mux >= m->submaps) return error(f, VORBIS_invalid_setup); + } + } else + // @SPECIFICATION: this case is missing from the spec + for (j=0; j < f->channels; ++j) + m->chan[j].mux = 0; + + for (j=0; j < m->submaps; ++j) { + get_bits(f,8); // discard + m->submap_floor[j] = get_bits(f,8); + m->submap_residue[j] = get_bits(f,8); + if (m->submap_floor[j] >= f->floor_count) return error(f, VORBIS_invalid_setup); + if (m->submap_residue[j] >= f->residue_count) return error(f, VORBIS_invalid_setup); + } + } + + // Modes + f->mode_count = get_bits(f, 6)+1; + for (i=0; i < f->mode_count; ++i) { + Mode *m = f->mode_config+i; + m->blockflag = get_bits(f,1); + m->windowtype = get_bits(f,16); + m->transformtype = get_bits(f,16); + m->mapping = get_bits(f,8); + if (m->windowtype != 0) return error(f, VORBIS_invalid_setup); + if (m->transformtype != 0) return error(f, VORBIS_invalid_setup); + if (m->mapping >= f->mapping_count) return error(f, VORBIS_invalid_setup); + } + + flush_packet(f); + + f->previous_length = 0; + + for (i=0; i < f->channels; ++i) { + f->channel_buffers[i] = (float *) setup_malloc(f, sizeof(float) * f->blocksize_1); + f->previous_window[i] = (float *) setup_malloc(f, sizeof(float) * f->blocksize_1/2); + f->finalY[i] = (int16 *) setup_malloc(f, sizeof(int16) * longest_floorlist); + if (f->channel_buffers[i] == NULL || f->previous_window[i] == NULL || f->finalY[i] == NULL) return error(f, VORBIS_outofmem); + memset(f->channel_buffers[i], 0, sizeof(float) * f->blocksize_1); + #ifdef STB_VORBIS_NO_DEFER_FLOOR + f->floor_buffers[i] = (float *) setup_malloc(f, sizeof(float) * f->blocksize_1/2); + if (f->floor_buffers[i] == NULL) return error(f, VORBIS_outofmem); + #endif + } + + if (!init_blocksize(f, 0, f->blocksize_0)) return FALSE; + if (!init_blocksize(f, 1, f->blocksize_1)) return FALSE; + f->blocksize[0] = f->blocksize_0; + f->blocksize[1] = f->blocksize_1; + +#ifdef STB_VORBIS_DIVIDE_TABLE + if (integer_divide_table[1][1]==0) + for (i=0; i < DIVTAB_NUMER; ++i) + for (j=1; j < DIVTAB_DENOM; ++j) + integer_divide_table[i][j] = i / j; +#endif + + // compute how much temporary memory is needed + + // 1. + { + uint32 imdct_mem = (f->blocksize_1 * sizeof(float) >> 1); + uint32 classify_mem; + int i,max_part_read=0; + for (i=0; i < f->residue_count; ++i) { + Residue *r = f->residue_config + i; + unsigned int actual_size = f->blocksize_1 / 2; + unsigned int limit_r_begin = r->begin < actual_size ? r->begin : actual_size; + unsigned int limit_r_end = r->end < actual_size ? r->end : actual_size; + int n_read = limit_r_end - limit_r_begin; + int part_read = n_read / r->part_size; + if (part_read > max_part_read) + max_part_read = part_read; + } + #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE + classify_mem = f->channels * (sizeof(void*) + max_part_read * sizeof(uint8 *)); + #else + classify_mem = f->channels * (sizeof(void*) + max_part_read * sizeof(int *)); + #endif + + // maximum reasonable partition size is f->blocksize_1 + + f->temp_memory_required = classify_mem; + if (imdct_mem > f->temp_memory_required) + f->temp_memory_required = imdct_mem; + } + + + if (f->alloc.alloc_buffer) { + assert(f->temp_offset == f->alloc.alloc_buffer_length_in_bytes); + // check if there's enough temp memory so we don't error later + if (f->setup_offset + sizeof(*f) + f->temp_memory_required > (unsigned) f->temp_offset) + return error(f, VORBIS_outofmem); + } + + // @TODO: stb_vorbis_seek_start expects first_audio_page_offset to point to a page + // without PAGEFLAG_continued_packet, so this either points to the first page, or + // the page after the end of the headers. It might be cleaner to point to a page + // in the middle of the headers, when that's the page where the first audio packet + // starts, but we'd have to also correctly skip the end of any continued packet in + // stb_vorbis_seek_start. + if (f->next_seg == -1) { + f->first_audio_page_offset = stb_vorbis_get_file_offset(f); + } else { + f->first_audio_page_offset = 0; + } + + return TRUE; +} + +static void vorbis_deinit(stb_vorbis *p) +{ + int i,j; + + setup_free(p, p->vendor); + for (i=0; i < p->comment_list_length; ++i) { + setup_free(p, p->comment_list[i]); + } + setup_free(p, p->comment_list); + + if (p->residue_config) { + for (i=0; i < p->residue_count; ++i) { + Residue *r = p->residue_config+i; + if (r->classdata) { + for (j=0; j < p->codebooks[r->classbook].entries; ++j) + setup_free(p, r->classdata[j]); + setup_free(p, r->classdata); + } + setup_free(p, r->residue_books); + } + } + + if (p->codebooks) { + CHECK(p); + for (i=0; i < p->codebook_count; ++i) { + Codebook *c = p->codebooks + i; + setup_free(p, c->codeword_lengths); + setup_free(p, c->multiplicands); + setup_free(p, c->codewords); + setup_free(p, c->sorted_codewords); + // c->sorted_values[-1] is the first entry in the array + setup_free(p, c->sorted_values ? c->sorted_values-1 : NULL); + } + setup_free(p, p->codebooks); + } + setup_free(p, p->floor_config); + setup_free(p, p->residue_config); + if (p->mapping) { + for (i=0; i < p->mapping_count; ++i) + setup_free(p, p->mapping[i].chan); + setup_free(p, p->mapping); + } + CHECK(p); + for (i=0; i < p->channels && i < STB_VORBIS_MAX_CHANNELS; ++i) { + setup_free(p, p->channel_buffers[i]); + setup_free(p, p->previous_window[i]); + #ifdef STB_VORBIS_NO_DEFER_FLOOR + setup_free(p, p->floor_buffers[i]); + #endif + setup_free(p, p->finalY[i]); + } + for (i=0; i < 2; ++i) { + setup_free(p, p->A[i]); + setup_free(p, p->B[i]); + setup_free(p, p->C[i]); + setup_free(p, p->window[i]); + setup_free(p, p->bit_reverse[i]); + } + #ifndef STB_VORBIS_NO_STDIO + if (p->close_on_free) fclose(p->f); + #endif +} + +void stb_vorbis_close(stb_vorbis *p) +{ + if (p == NULL) return; + vorbis_deinit(p); + setup_free(p,p); +} + +static void vorbis_init(stb_vorbis *p, const stb_vorbis_alloc *z) +{ + memset(p, 0, sizeof(*p)); // NULL out all malloc'd pointers to start + if (z) { + p->alloc = *z; + p->alloc.alloc_buffer_length_in_bytes &= ~7; + p->temp_offset = p->alloc.alloc_buffer_length_in_bytes; + } + p->eof = 0; + p->error = VORBIS__no_error; + p->stream = NULL; + p->codebooks = NULL; + p->page_crc_tests = -1; + #ifndef STB_VORBIS_NO_STDIO + p->close_on_free = FALSE; + p->f = NULL; + #endif +} + +int stb_vorbis_get_sample_offset(stb_vorbis *f) +{ + if (f->current_loc_valid) + return f->current_loc; + else + return -1; +} + +stb_vorbis_info stb_vorbis_get_info(stb_vorbis *f) +{ + stb_vorbis_info d; + d.channels = f->channels; + d.sample_rate = f->sample_rate; + d.setup_memory_required = f->setup_memory_required; + d.setup_temp_memory_required = f->setup_temp_memory_required; + d.temp_memory_required = f->temp_memory_required; + d.max_frame_size = f->blocksize_1 >> 1; + return d; +} + +stb_vorbis_comment stb_vorbis_get_comment(stb_vorbis *f) +{ + stb_vorbis_comment d; + d.vendor = f->vendor; + d.comment_list_length = f->comment_list_length; + d.comment_list = f->comment_list; + return d; +} + +int stb_vorbis_get_error(stb_vorbis *f) +{ + int e = f->error; + f->error = VORBIS__no_error; + return e; +} + +static stb_vorbis * vorbis_alloc(stb_vorbis *f) +{ + stb_vorbis *p = (stb_vorbis *) setup_malloc(f, sizeof(*p)); + return p; +} + +#ifndef STB_VORBIS_NO_PUSHDATA_API + +void stb_vorbis_flush_pushdata(stb_vorbis *f) +{ + f->previous_length = 0; + f->page_crc_tests = 0; + f->discard_samples_deferred = 0; + f->current_loc_valid = FALSE; + f->first_decode = FALSE; + f->samples_output = 0; + f->channel_buffer_start = 0; + f->channel_buffer_end = 0; +} + +static int vorbis_search_for_page_pushdata(vorb *f, uint8 *data, int data_len) +{ + int i,n; + for (i=0; i < f->page_crc_tests; ++i) + f->scan[i].bytes_done = 0; + + // if we have room for more scans, search for them first, because + // they may cause us to stop early if their header is incomplete + if (f->page_crc_tests < STB_VORBIS_PUSHDATA_CRC_COUNT) { + if (data_len < 4) return 0; + data_len -= 3; // need to look for 4-byte sequence, so don't miss + // one that straddles a boundary + for (i=0; i < data_len; ++i) { + if (data[i] == 0x4f) { + if (0==memcmp(data+i, ogg_page_header, 4)) { + int j,len; + uint32 crc; + // make sure we have the whole page header + if (i+26 >= data_len || i+27+data[i+26] >= data_len) { + // only read up to this page start, so hopefully we'll + // have the whole page header start next time + data_len = i; + break; + } + // ok, we have it all; compute the length of the page + len = 27 + data[i+26]; + for (j=0; j < data[i+26]; ++j) + len += data[i+27+j]; + // scan everything up to the embedded crc (which we must 0) + crc = 0; + for (j=0; j < 22; ++j) + crc = crc32_update(crc, data[i+j]); + // now process 4 0-bytes + for ( ; j < 26; ++j) + crc = crc32_update(crc, 0); + // len is the total number of bytes we need to scan + n = f->page_crc_tests++; + f->scan[n].bytes_left = len-j; + f->scan[n].crc_so_far = crc; + f->scan[n].goal_crc = data[i+22] + (data[i+23] << 8) + (data[i+24]<<16) + (data[i+25]<<24); + // if the last frame on a page is continued to the next, then + // we can't recover the sample_loc immediately + if (data[i+27+data[i+26]-1] == 255) + f->scan[n].sample_loc = ~0; + else + f->scan[n].sample_loc = data[i+6] + (data[i+7] << 8) + (data[i+ 8]<<16) + (data[i+ 9]<<24); + f->scan[n].bytes_done = i+j; + if (f->page_crc_tests == STB_VORBIS_PUSHDATA_CRC_COUNT) + break; + // keep going if we still have room for more + } + } + } + } + + for (i=0; i < f->page_crc_tests;) { + uint32 crc; + int j; + int n = f->scan[i].bytes_done; + int m = f->scan[i].bytes_left; + if (m > data_len - n) m = data_len - n; + // m is the bytes to scan in the current chunk + crc = f->scan[i].crc_so_far; + for (j=0; j < m; ++j) + crc = crc32_update(crc, data[n+j]); + f->scan[i].bytes_left -= m; + f->scan[i].crc_so_far = crc; + if (f->scan[i].bytes_left == 0) { + // does it match? + if (f->scan[i].crc_so_far == f->scan[i].goal_crc) { + // Houston, we have page + data_len = n+m; // consumption amount is wherever that scan ended + f->page_crc_tests = -1; // drop out of page scan mode + f->previous_length = 0; // decode-but-don't-output one frame + f->next_seg = -1; // start a new page + f->current_loc = f->scan[i].sample_loc; // set the current sample location + // to the amount we'd have decoded had we decoded this page + f->current_loc_valid = f->current_loc != ~0U; + return data_len; + } + // delete entry + f->scan[i] = f->scan[--f->page_crc_tests]; + } else { + ++i; + } + } + + return data_len; +} + +// return value: number of bytes we used +int stb_vorbis_decode_frame_pushdata( + stb_vorbis *f, // the file we're decoding + const uint8 *data, int data_len, // the memory available for decoding + int *channels, // place to write number of float * buffers + float ***output, // place to write float ** array of float * buffers + int *samples // place to write number of output samples + ) +{ + int i; + int len,right,left; + + if (!IS_PUSH_MODE(f)) return error(f, VORBIS_invalid_api_mixing); + + if (f->page_crc_tests >= 0) { + *samples = 0; + return vorbis_search_for_page_pushdata(f, (uint8 *) data, data_len); + } + + f->stream = (uint8 *) data; + f->stream_end = (uint8 *) data + data_len; + f->error = VORBIS__no_error; + + // check that we have the entire packet in memory + if (!is_whole_packet_present(f)) { + *samples = 0; + return 0; + } + + if (!vorbis_decode_packet(f, &len, &left, &right)) { + // save the actual error we encountered + enum STBVorbisError error = f->error; + if (error == VORBIS_bad_packet_type) { + // flush and resynch + f->error = VORBIS__no_error; + while (get8_packet(f) != EOP) + if (f->eof) break; + *samples = 0; + return (int) (f->stream - data); + } + if (error == VORBIS_continued_packet_flag_invalid) { + if (f->previous_length == 0) { + // we may be resynching, in which case it's ok to hit one + // of these; just discard the packet + f->error = VORBIS__no_error; + while (get8_packet(f) != EOP) + if (f->eof) break; + *samples = 0; + return (int) (f->stream - data); + } + } + // if we get an error while parsing, what to do? + // well, it DEFINITELY won't work to continue from where we are! + stb_vorbis_flush_pushdata(f); + // restore the error that actually made us bail + f->error = error; + *samples = 0; + return 1; + } + + // success! + len = vorbis_finish_frame(f, len, left, right); + for (i=0; i < f->channels; ++i) + f->outputs[i] = f->channel_buffers[i] + left; + + if (channels) *channels = f->channels; + *samples = len; + *output = f->outputs; + return (int) (f->stream - data); +} + +stb_vorbis *stb_vorbis_open_pushdata( + const unsigned char *data, int data_len, // the memory available for decoding + int *data_used, // only defined if result is not NULL + int *error, const stb_vorbis_alloc *alloc) +{ + stb_vorbis *f, p; + vorbis_init(&p, alloc); + p.stream = (uint8 *) data; + p.stream_end = (uint8 *) data + data_len; + p.push_mode = TRUE; + if (!start_decoder(&p)) { + if (p.eof) + *error = VORBIS_need_more_data; + else + *error = p.error; + vorbis_deinit(&p); + return NULL; + } + f = vorbis_alloc(&p); + if (f) { + *f = p; + *data_used = (int) (f->stream - data); + *error = 0; + return f; + } else { + vorbis_deinit(&p); + return NULL; + } +} +#endif // STB_VORBIS_NO_PUSHDATA_API + +unsigned int stb_vorbis_get_file_offset(stb_vorbis *f) +{ + #ifndef STB_VORBIS_NO_PUSHDATA_API + if (f->push_mode) return 0; + #endif + if (USE_MEMORY(f)) return (unsigned int) (f->stream - f->stream_start); + #ifndef STB_VORBIS_NO_STDIO + return (unsigned int) (ftell(f->f) - f->f_start); + #endif +} + +#ifndef STB_VORBIS_NO_PULLDATA_API +// +// DATA-PULLING API +// + +static uint32 vorbis_find_page(stb_vorbis *f, uint32 *end, uint32 *last) +{ + for(;;) { + int n; + if (f->eof) return 0; + n = get8(f); + if (n == 0x4f) { // page header candidate + unsigned int retry_loc = stb_vorbis_get_file_offset(f); + int i; + // check if we're off the end of a file_section stream + if (retry_loc - 25 > f->stream_len) + return 0; + // check the rest of the header + for (i=1; i < 4; ++i) + if (get8(f) != ogg_page_header[i]) + break; + if (f->eof) return 0; + if (i == 4) { + uint8 header[27]; + uint32 i, crc, goal, len; + for (i=0; i < 4; ++i) + header[i] = ogg_page_header[i]; + for (; i < 27; ++i) + header[i] = get8(f); + if (f->eof) return 0; + if (header[4] != 0) goto invalid; + goal = header[22] + (header[23] << 8) + (header[24]<<16) + ((uint32)header[25]<<24); + for (i=22; i < 26; ++i) + header[i] = 0; + crc = 0; + for (i=0; i < 27; ++i) + crc = crc32_update(crc, header[i]); + len = 0; + for (i=0; i < header[26]; ++i) { + int s = get8(f); + crc = crc32_update(crc, s); + len += s; + } + if (len && f->eof) return 0; + for (i=0; i < len; ++i) + crc = crc32_update(crc, get8(f)); + // finished parsing probable page + if (crc == goal) { + // we could now check that it's either got the last + // page flag set, OR it's followed by the capture + // pattern, but I guess TECHNICALLY you could have + // a file with garbage between each ogg page and recover + // from it automatically? So even though that paranoia + // might decrease the chance of an invalid decode by + // another 2^32, not worth it since it would hose those + // invalid-but-useful files? + if (end) + *end = stb_vorbis_get_file_offset(f); + if (last) { + if (header[5] & 0x04) + *last = 1; + else + *last = 0; + } + set_file_offset(f, retry_loc-1); + return 1; + } + } + invalid: + // not a valid page, so rewind and look for next one + set_file_offset(f, retry_loc); + } + } +} + + +#define SAMPLE_unknown 0xffffffff + +// seeking is implemented with a binary search, which narrows down the range to +// 64K, before using a linear search (because finding the synchronization +// pattern can be expensive, and the chance we'd find the end page again is +// relatively high for small ranges) +// +// two initial interpolation-style probes are used at the start of the search +// to try to bound either side of the binary search sensibly, while still +// working in O(log n) time if they fail. + +static int get_seek_page_info(stb_vorbis *f, ProbedPage *z) +{ + uint8 header[27], lacing[255]; + int i,len; + + // record where the page starts + z->page_start = stb_vorbis_get_file_offset(f); + + // parse the header + getn(f, header, 27); + if (header[0] != 'O' || header[1] != 'g' || header[2] != 'g' || header[3] != 'S') + return 0; + getn(f, lacing, header[26]); + + // determine the length of the payload + len = 0; + for (i=0; i < header[26]; ++i) + len += lacing[i]; + + // this implies where the page ends + z->page_end = z->page_start + 27 + header[26] + len; + + // read the last-decoded sample out of the data + z->last_decoded_sample = header[6] + (header[7] << 8) + (header[8] << 16) + (header[9] << 24); + + // restore file state to where we were + set_file_offset(f, z->page_start); + return 1; +} + +// rarely used function to seek back to the preceding page while finding the +// start of a packet +static int go_to_page_before(stb_vorbis *f, unsigned int limit_offset) +{ + unsigned int previous_safe, end; + + // now we want to seek back 64K from the limit + if (limit_offset >= 65536 && limit_offset-65536 >= f->first_audio_page_offset) + previous_safe = limit_offset - 65536; + else + previous_safe = f->first_audio_page_offset; + + set_file_offset(f, previous_safe); + + while (vorbis_find_page(f, &end, NULL)) { + if (end >= limit_offset && stb_vorbis_get_file_offset(f) < limit_offset) + return 1; + set_file_offset(f, end); + } + + return 0; +} + +// implements the search logic for finding a page and starting decoding. if +// the function succeeds, current_loc_valid will be true and current_loc will +// be less than or equal to the provided sample number (the closer the +// better). +static int seek_to_sample_coarse(stb_vorbis *f, uint32 sample_number) +{ + ProbedPage left, right, mid; + int i, start_seg_with_known_loc, end_pos, page_start; + uint32 delta, stream_length, padding, last_sample_limit; + double offset = 0.0, bytes_per_sample = 0.0; + int probe = 0; + + // find the last page and validate the target sample + stream_length = stb_vorbis_stream_length_in_samples(f); + if (stream_length == 0) return error(f, VORBIS_seek_without_length); + if (sample_number > stream_length) return error(f, VORBIS_seek_invalid); + + // this is the maximum difference between the window-center (which is the + // actual granule position value), and the right-start (which the spec + // indicates should be the granule position (give or take one)). + padding = ((f->blocksize_1 - f->blocksize_0) >> 2); + if (sample_number < padding) + last_sample_limit = 0; + else + last_sample_limit = sample_number - padding; + + left = f->p_first; + while (left.last_decoded_sample == ~0U) { + // (untested) the first page does not have a 'last_decoded_sample' + set_file_offset(f, left.page_end); + if (!get_seek_page_info(f, &left)) goto error; + } + + right = f->p_last; + assert(right.last_decoded_sample != ~0U); + + // starting from the start is handled differently + if (last_sample_limit <= left.last_decoded_sample) { + if (stb_vorbis_seek_start(f)) { + if (f->current_loc > sample_number) + return error(f, VORBIS_seek_failed); + return 1; + } + return 0; + } + + while (left.page_end != right.page_start) { + assert(left.page_end < right.page_start); + // search range in bytes + delta = right.page_start - left.page_end; + if (delta <= 65536) { + // there's only 64K left to search - handle it linearly + set_file_offset(f, left.page_end); + } else { + if (probe < 2) { + if (probe == 0) { + // first probe (interpolate) + double data_bytes = right.page_end - left.page_start; + bytes_per_sample = data_bytes / right.last_decoded_sample; + offset = left.page_start + bytes_per_sample * (last_sample_limit - left.last_decoded_sample); + } else { + // second probe (try to bound the other side) + double error = ((double) last_sample_limit - mid.last_decoded_sample) * bytes_per_sample; + if (error >= 0 && error < 8000) error = 8000; + if (error < 0 && error > -8000) error = -8000; + offset += error * 2; + } + + // ensure the offset is valid + if (offset < left.page_end) + offset = left.page_end; + if (offset > right.page_start - 65536) + offset = right.page_start - 65536; + + set_file_offset(f, (unsigned int) offset); + } else { + // binary search for large ranges (offset by 32K to ensure + // we don't hit the right page) + set_file_offset(f, left.page_end + (delta / 2) - 32768); + } + + if (!vorbis_find_page(f, NULL, NULL)) goto error; + } + + for (;;) { + if (!get_seek_page_info(f, &mid)) goto error; + if (mid.last_decoded_sample != ~0U) break; + // (untested) no frames end on this page + set_file_offset(f, mid.page_end); + assert(mid.page_start < right.page_start); + } + + // if we've just found the last page again then we're in a tricky file, + // and we're close enough (if it wasn't an interpolation probe). + if (mid.page_start == right.page_start) { + if (probe >= 2 || delta <= 65536) + break; + } else { + if (last_sample_limit < mid.last_decoded_sample) + right = mid; + else + left = mid; + } + + ++probe; + } + + // seek back to start of the last packet + page_start = left.page_start; + set_file_offset(f, page_start); + if (!start_page(f)) return error(f, VORBIS_seek_failed); + end_pos = f->end_seg_with_known_loc; + assert(end_pos >= 0); + + for (;;) { + for (i = end_pos; i > 0; --i) + if (f->segments[i-1] != 255) + break; + + start_seg_with_known_loc = i; + + if (start_seg_with_known_loc > 0 || !(f->page_flag & PAGEFLAG_continued_packet)) + break; + + // (untested) the final packet begins on an earlier page + if (!go_to_page_before(f, page_start)) + goto error; + + page_start = stb_vorbis_get_file_offset(f); + if (!start_page(f)) goto error; + end_pos = f->segment_count - 1; + } + + // prepare to start decoding + f->current_loc_valid = FALSE; + f->last_seg = FALSE; + f->valid_bits = 0; + f->packet_bytes = 0; + f->bytes_in_seg = 0; + f->previous_length = 0; + f->next_seg = start_seg_with_known_loc; + + for (i = 0; i < start_seg_with_known_loc; i++) + skip(f, f->segments[i]); + + // start decoding (optimizable - this frame is generally discarded) + if (!vorbis_pump_first_frame(f)) + return 0; + if (f->current_loc > sample_number) + return error(f, VORBIS_seek_failed); + return 1; + +error: + // try to restore the file to a valid state + stb_vorbis_seek_start(f); + return error(f, VORBIS_seek_failed); +} + +// the same as vorbis_decode_initial, but without advancing +static int peek_decode_initial(vorb *f, int *p_left_start, int *p_left_end, int *p_right_start, int *p_right_end, int *mode) +{ + int bits_read, bytes_read; + + if (!vorbis_decode_initial(f, p_left_start, p_left_end, p_right_start, p_right_end, mode)) + return 0; + + // either 1 or 2 bytes were read, figure out which so we can rewind + bits_read = 1 + ilog(f->mode_count-1); + if (f->mode_config[*mode].blockflag) + bits_read += 2; + bytes_read = (bits_read + 7) / 8; + + f->bytes_in_seg += bytes_read; + f->packet_bytes -= bytes_read; + skip(f, -bytes_read); + if (f->next_seg == -1) + f->next_seg = f->segment_count - 1; + else + f->next_seg--; + f->valid_bits = 0; + + return 1; +} + +int stb_vorbis_seek_frame(stb_vorbis *f, unsigned int sample_number) +{ + uint32 max_frame_samples; + + if (IS_PUSH_MODE(f)) return error(f, VORBIS_invalid_api_mixing); + + // fast page-level search + if (!seek_to_sample_coarse(f, sample_number)) + return 0; + + assert(f->current_loc_valid); + assert(f->current_loc <= sample_number); + + // linear search for the relevant packet + max_frame_samples = (f->blocksize_1*3 - f->blocksize_0) >> 2; + while (f->current_loc < sample_number) { + int left_start, left_end, right_start, right_end, mode, frame_samples; + if (!peek_decode_initial(f, &left_start, &left_end, &right_start, &right_end, &mode)) + return error(f, VORBIS_seek_failed); + // calculate the number of samples returned by the next frame + frame_samples = right_start - left_start; + if (f->current_loc + frame_samples > sample_number) { + return 1; // the next frame will contain the sample + } else if (f->current_loc + frame_samples + max_frame_samples > sample_number) { + // there's a chance the frame after this could contain the sample + vorbis_pump_first_frame(f); + } else { + // this frame is too early to be relevant + f->current_loc += frame_samples; + f->previous_length = 0; + maybe_start_packet(f); + flush_packet(f); + } + } + // the next frame should start with the sample + if (f->current_loc != sample_number) return error(f, VORBIS_seek_failed); + return 1; +} + +int stb_vorbis_seek(stb_vorbis *f, unsigned int sample_number) +{ + if (!stb_vorbis_seek_frame(f, sample_number)) + return 0; + + if (sample_number != f->current_loc) { + int n; + uint32 frame_start = f->current_loc; + stb_vorbis_get_frame_float(f, &n, NULL); + assert(sample_number > frame_start); + assert(f->channel_buffer_start + (int) (sample_number-frame_start) <= f->channel_buffer_end); + f->channel_buffer_start += (sample_number - frame_start); + } + + return 1; +} + +int stb_vorbis_seek_start(stb_vorbis *f) +{ + if (IS_PUSH_MODE(f)) { return error(f, VORBIS_invalid_api_mixing); } + set_file_offset(f, f->first_audio_page_offset); + f->previous_length = 0; + f->first_decode = TRUE; + f->next_seg = -1; + return vorbis_pump_first_frame(f); +} + +unsigned int stb_vorbis_stream_length_in_samples(stb_vorbis *f) +{ + unsigned int restore_offset, previous_safe; + unsigned int end, last_page_loc; + + if (IS_PUSH_MODE(f)) return error(f, VORBIS_invalid_api_mixing); + if (!f->total_samples) { + unsigned int last; + uint32 lo,hi; + char header[6]; + + // first, store the current decode position so we can restore it + restore_offset = stb_vorbis_get_file_offset(f); + + // now we want to seek back 64K from the end (the last page must + // be at most a little less than 64K, but let's allow a little slop) + if (f->stream_len >= 65536 && f->stream_len-65536 >= f->first_audio_page_offset) + previous_safe = f->stream_len - 65536; + else + previous_safe = f->first_audio_page_offset; + + set_file_offset(f, previous_safe); + // previous_safe is now our candidate 'earliest known place that seeking + // to will lead to the final page' + + if (!vorbis_find_page(f, &end, &last)) { + // if we can't find a page, we're hosed! + f->error = VORBIS_cant_find_last_page; + f->total_samples = 0xffffffff; + goto done; + } + + // check if there are more pages + last_page_loc = stb_vorbis_get_file_offset(f); + + // stop when the last_page flag is set, not when we reach eof; + // this allows us to stop short of a 'file_section' end without + // explicitly checking the length of the section + while (!last) { + set_file_offset(f, end); + if (!vorbis_find_page(f, &end, &last)) { + // the last page we found didn't have the 'last page' flag + // set. whoops! + break; + } + //previous_safe = last_page_loc+1; // NOTE: not used after this point, but note for debugging + last_page_loc = stb_vorbis_get_file_offset(f); + } + + set_file_offset(f, last_page_loc); + + // parse the header + getn(f, (unsigned char *)header, 6); + // extract the absolute granule position + lo = get32(f); + hi = get32(f); + if (lo == 0xffffffff && hi == 0xffffffff) { + f->error = VORBIS_cant_find_last_page; + f->total_samples = SAMPLE_unknown; + goto done; + } + if (hi) + lo = 0xfffffffe; // saturate + f->total_samples = lo; + + f->p_last.page_start = last_page_loc; + f->p_last.page_end = end; + f->p_last.last_decoded_sample = lo; + + done: + set_file_offset(f, restore_offset); + } + return f->total_samples == SAMPLE_unknown ? 0 : f->total_samples; +} + +float stb_vorbis_stream_length_in_seconds(stb_vorbis *f) +{ + return stb_vorbis_stream_length_in_samples(f) / (float) f->sample_rate; +} + + + +int stb_vorbis_get_frame_float(stb_vorbis *f, int *channels, float ***output) +{ + int len, right,left,i; + if (IS_PUSH_MODE(f)) return error(f, VORBIS_invalid_api_mixing); + + if (!vorbis_decode_packet(f, &len, &left, &right)) { + f->channel_buffer_start = f->channel_buffer_end = 0; + return 0; + } + + len = vorbis_finish_frame(f, len, left, right); + for (i=0; i < f->channels; ++i) + f->outputs[i] = f->channel_buffers[i] + left; + + f->channel_buffer_start = left; + f->channel_buffer_end = left+len; + + if (channels) *channels = f->channels; + if (output) *output = f->outputs; + return len; +} + +#ifndef STB_VORBIS_NO_STDIO + +stb_vorbis * stb_vorbis_open_file_section(FILE *file, int close_on_free, int *error, const stb_vorbis_alloc *alloc, unsigned int length) +{ + stb_vorbis *f, p; + vorbis_init(&p, alloc); + p.f = file; + p.f_start = (uint32) ftell(file); + p.stream_len = length; + p.close_on_free = close_on_free; + if (start_decoder(&p)) { + f = vorbis_alloc(&p); + if (f) { + *f = p; + vorbis_pump_first_frame(f); + return f; + } + } + if (error) *error = p.error; + vorbis_deinit(&p); + return NULL; +} + +stb_vorbis * stb_vorbis_open_file(FILE *file, int close_on_free, int *error, const stb_vorbis_alloc *alloc) +{ + unsigned int len, start; + start = (unsigned int) ftell(file); + fseek(file, 0, SEEK_END); + len = (unsigned int) (ftell(file) - start); + fseek(file, start, SEEK_SET); + return stb_vorbis_open_file_section(file, close_on_free, error, alloc, len); +} + +stb_vorbis * stb_vorbis_open_filename(const char *filename, int *error, const stb_vorbis_alloc *alloc) +{ + FILE *f; +#if defined(_WIN32) && defined(__STDC_WANT_SECURE_LIB__) + if (0 != fopen_s(&f, filename, "rb")) + f = NULL; +#else + f = fopen(filename, "rb"); +#endif + if (f) + return stb_vorbis_open_file(f, TRUE, error, alloc); + if (error) *error = VORBIS_file_open_failure; + return NULL; +} +#endif // STB_VORBIS_NO_STDIO + +stb_vorbis * stb_vorbis_open_memory(const unsigned char *data, int len, int *error, const stb_vorbis_alloc *alloc) +{ + stb_vorbis *f, p; + if (!data) { + if (error) *error = VORBIS_unexpected_eof; + return NULL; + } + vorbis_init(&p, alloc); + p.stream = (uint8 *) data; + p.stream_end = (uint8 *) data + len; + p.stream_start = (uint8 *) p.stream; + p.stream_len = len; + p.push_mode = FALSE; + if (start_decoder(&p)) { + f = vorbis_alloc(&p); + if (f) { + *f = p; + vorbis_pump_first_frame(f); + if (error) *error = VORBIS__no_error; + return f; + } + } + if (error) *error = p.error; + vorbis_deinit(&p); + return NULL; +} + +#ifndef STB_VORBIS_NO_INTEGER_CONVERSION +#define PLAYBACK_MONO 1 +#define PLAYBACK_LEFT 2 +#define PLAYBACK_RIGHT 4 + +#define L (PLAYBACK_LEFT | PLAYBACK_MONO) +#define C (PLAYBACK_LEFT | PLAYBACK_RIGHT | PLAYBACK_MONO) +#define R (PLAYBACK_RIGHT | PLAYBACK_MONO) + +static int8 channel_position[7][6] = +{ + { 0 }, + { C }, + { L, R }, + { L, C, R }, + { L, R, L, R }, + { L, C, R, L, R }, + { L, C, R, L, R, C }, +}; + + +#ifndef STB_VORBIS_NO_FAST_SCALED_FLOAT + typedef union { + float f; + int i; + } float_conv; + typedef char stb_vorbis_float_size_test[sizeof(float)==4 && sizeof(int) == 4]; + #define FASTDEF(x) float_conv x + // add (1<<23) to convert to int, then divide by 2^SHIFT, then add 0.5/2^SHIFT to round + #define MAGIC(SHIFT) (1.5f * (1 << (23-SHIFT)) + 0.5f/(1 << SHIFT)) + #define ADDEND(SHIFT) (((150-SHIFT) << 23) + (1 << 22)) + #define FAST_SCALED_FLOAT_TO_INT(temp,x,s) (temp.f = (x) + MAGIC(s), temp.i - ADDEND(s)) + #define check_endianness() +#else + #define FAST_SCALED_FLOAT_TO_INT(temp,x,s) ((int) ((x) * (1 << (s)))) + #define check_endianness() + #define FASTDEF(x) +#endif + +static void copy_samples(short *dest, float *src, int len) +{ + int i; + check_endianness(); + for (i=0; i < len; ++i) { + FASTDEF(temp); + int v = FAST_SCALED_FLOAT_TO_INT(temp, src[i],15); + if ((unsigned int) (v + 32768) > 65535) + v = v < 0 ? -32768 : 32767; + dest[i] = v; + } +} + +static void compute_samples(int mask, short *output, int num_c, float **data, int d_offset, int len) +{ + #define STB_BUFFER_SIZE 32 + float buffer[STB_BUFFER_SIZE]; + int i,j,o,n = STB_BUFFER_SIZE; + check_endianness(); + for (o = 0; o < len; o += STB_BUFFER_SIZE) { + memset(buffer, 0, sizeof(buffer)); + if (o + n > len) n = len - o; + for (j=0; j < num_c; ++j) { + if (channel_position[num_c][j] & mask) { + for (i=0; i < n; ++i) + buffer[i] += data[j][d_offset+o+i]; + } + } + for (i=0; i < n; ++i) { + FASTDEF(temp); + int v = FAST_SCALED_FLOAT_TO_INT(temp,buffer[i],15); + if ((unsigned int) (v + 32768) > 65535) + v = v < 0 ? -32768 : 32767; + output[o+i] = v; + } + } + #undef STB_BUFFER_SIZE +} + +static void compute_stereo_samples(short *output, int num_c, float **data, int d_offset, int len) +{ + #define STB_BUFFER_SIZE 32 + float buffer[STB_BUFFER_SIZE]; + int i,j,o,n = STB_BUFFER_SIZE >> 1; + // o is the offset in the source data + check_endianness(); + for (o = 0; o < len; o += STB_BUFFER_SIZE >> 1) { + // o2 is the offset in the output data + int o2 = o << 1; + memset(buffer, 0, sizeof(buffer)); + if (o + n > len) n = len - o; + for (j=0; j < num_c; ++j) { + int m = channel_position[num_c][j] & (PLAYBACK_LEFT | PLAYBACK_RIGHT); + if (m == (PLAYBACK_LEFT | PLAYBACK_RIGHT)) { + for (i=0; i < n; ++i) { + buffer[i*2+0] += data[j][d_offset+o+i]; + buffer[i*2+1] += data[j][d_offset+o+i]; + } + } else if (m == PLAYBACK_LEFT) { + for (i=0; i < n; ++i) { + buffer[i*2+0] += data[j][d_offset+o+i]; + } + } else if (m == PLAYBACK_RIGHT) { + for (i=0; i < n; ++i) { + buffer[i*2+1] += data[j][d_offset+o+i]; + } + } + } + for (i=0; i < (n<<1); ++i) { + FASTDEF(temp); + int v = FAST_SCALED_FLOAT_TO_INT(temp,buffer[i],15); + if ((unsigned int) (v + 32768) > 65535) + v = v < 0 ? -32768 : 32767; + output[o2+i] = v; + } + } + #undef STB_BUFFER_SIZE +} + +static void convert_samples_short(int buf_c, short **buffer, int b_offset, int data_c, float **data, int d_offset, int samples) +{ + int i; + if (buf_c != data_c && buf_c <= 2 && data_c <= 6) { + static int channel_selector[3][2] = { {0}, {PLAYBACK_MONO}, {PLAYBACK_LEFT, PLAYBACK_RIGHT} }; + for (i=0; i < buf_c; ++i) + compute_samples(channel_selector[buf_c][i], buffer[i]+b_offset, data_c, data, d_offset, samples); + } else { + int limit = buf_c < data_c ? buf_c : data_c; + for (i=0; i < limit; ++i) + copy_samples(buffer[i]+b_offset, data[i]+d_offset, samples); + for ( ; i < buf_c; ++i) + memset(buffer[i]+b_offset, 0, sizeof(short) * samples); + } +} + +int stb_vorbis_get_frame_short(stb_vorbis *f, int num_c, short **buffer, int num_samples) +{ + float **output = NULL; + int len = stb_vorbis_get_frame_float(f, NULL, &output); + if (len > num_samples) len = num_samples; + if (len) + convert_samples_short(num_c, buffer, 0, f->channels, output, 0, len); + return len; +} + +static void convert_channels_short_interleaved(int buf_c, short *buffer, int data_c, float **data, int d_offset, int len) +{ + int i; + check_endianness(); + if (buf_c != data_c && buf_c <= 2 && data_c <= 6) { + assert(buf_c == 2); + for (i=0; i < buf_c; ++i) + compute_stereo_samples(buffer, data_c, data, d_offset, len); + } else { + int limit = buf_c < data_c ? buf_c : data_c; + int j; + for (j=0; j < len; ++j) { + for (i=0; i < limit; ++i) { + FASTDEF(temp); + float f = data[i][d_offset+j]; + int v = FAST_SCALED_FLOAT_TO_INT(temp, f,15);//data[i][d_offset+j],15); + if ((unsigned int) (v + 32768) > 65535) + v = v < 0 ? -32768 : 32767; + *buffer++ = v; + } + for ( ; i < buf_c; ++i) + *buffer++ = 0; + } + } +} + +int stb_vorbis_get_frame_short_interleaved(stb_vorbis *f, int num_c, short *buffer, int num_shorts) +{ + float **output; + int len; + if (num_c == 1) return stb_vorbis_get_frame_short(f,num_c,&buffer, num_shorts); + len = stb_vorbis_get_frame_float(f, NULL, &output); + if (len) { + if (len*num_c > num_shorts) len = num_shorts / num_c; + convert_channels_short_interleaved(num_c, buffer, f->channels, output, 0, len); + } + return len; +} + +int stb_vorbis_get_samples_short_interleaved(stb_vorbis *f, int channels, short *buffer, int num_shorts) +{ + float **outputs; + int len = num_shorts / channels; + int n=0; + while (n < len) { + int k = f->channel_buffer_end - f->channel_buffer_start; + if (n+k >= len) k = len - n; + if (k) + convert_channels_short_interleaved(channels, buffer, f->channels, f->channel_buffers, f->channel_buffer_start, k); + buffer += k*channels; + n += k; + f->channel_buffer_start += k; + if (n == len) break; + if (!stb_vorbis_get_frame_float(f, NULL, &outputs)) break; + } + return n; +} + +int stb_vorbis_get_samples_short(stb_vorbis *f, int channels, short **buffer, int len) +{ + float **outputs; + int n=0; + while (n < len) { + int k = f->channel_buffer_end - f->channel_buffer_start; + if (n+k >= len) k = len - n; + if (k) + convert_samples_short(channels, buffer, n, f->channels, f->channel_buffers, f->channel_buffer_start, k); + n += k; + f->channel_buffer_start += k; + if (n == len) break; + if (!stb_vorbis_get_frame_float(f, NULL, &outputs)) break; + } + return n; +} + +#ifndef STB_VORBIS_NO_STDIO +int stb_vorbis_decode_filename(const char *filename, int *channels, int *sample_rate, short **output) +{ + int data_len, offset, total, limit, error; + short *data; + stb_vorbis *v = stb_vorbis_open_filename(filename, &error, NULL); + if (v == NULL) return -1; + limit = v->channels * 4096; + *channels = v->channels; + if (sample_rate) + *sample_rate = v->sample_rate; + offset = data_len = 0; + total = limit; + data = (short *) malloc(total * sizeof(*data)); + if (data == NULL) { + stb_vorbis_close(v); + return -2; + } + for (;;) { + int n = stb_vorbis_get_frame_short_interleaved(v, v->channels, data+offset, total-offset); + if (n == 0) break; + data_len += n; + offset += n * v->channels; + if (offset + limit > total) { + short *data2; + total *= 2; + data2 = (short *) realloc(data, total * sizeof(*data)); + if (data2 == NULL) { + free(data); + stb_vorbis_close(v); + return -2; + } + data = data2; + } + } + *output = data; + stb_vorbis_close(v); + return data_len; +} +#endif // NO_STDIO + +int stb_vorbis_decode_memory(const uint8 *mem, int len, int *channels, int *sample_rate, short **output) +{ + int data_len, offset, total, limit, error; + short *data; + stb_vorbis *v = stb_vorbis_open_memory(mem, len, &error, NULL); + if (v == NULL) return -1; + limit = v->channels * 4096; + *channels = v->channels; + if (sample_rate) + *sample_rate = v->sample_rate; + offset = data_len = 0; + total = limit; + data = (short *) malloc(total * sizeof(*data)); + if (data == NULL) { + stb_vorbis_close(v); + return -2; + } + for (;;) { + int n = stb_vorbis_get_frame_short_interleaved(v, v->channels, data+offset, total-offset); + if (n == 0) break; + data_len += n; + offset += n * v->channels; + if (offset + limit > total) { + short *data2; + total *= 2; + data2 = (short *) realloc(data, total * sizeof(*data)); + if (data2 == NULL) { + free(data); + stb_vorbis_close(v); + return -2; + } + data = data2; + } + } + *output = data; + stb_vorbis_close(v); + return data_len; +} +#endif // STB_VORBIS_NO_INTEGER_CONVERSION + +int stb_vorbis_get_samples_float_interleaved(stb_vorbis *f, int channels, float *buffer, int num_floats) +{ + float **outputs; + int len = num_floats / channels; + int n=0; + int z = f->channels; + if (z > channels) z = channels; + while (n < len) { + int i,j; + int k = f->channel_buffer_end - f->channel_buffer_start; + if (n+k >= len) k = len - n; + for (j=0; j < k; ++j) { + for (i=0; i < z; ++i) + *buffer++ = f->channel_buffers[i][f->channel_buffer_start+j]; + for ( ; i < channels; ++i) + *buffer++ = 0; + } + n += k; + f->channel_buffer_start += k; + if (n == len) + break; + if (!stb_vorbis_get_frame_float(f, NULL, &outputs)) + break; + } + return n; +} + +int stb_vorbis_get_samples_float(stb_vorbis *f, int channels, float **buffer, int num_samples) +{ + float **outputs; + int n=0; + int z = f->channels; + if (z > channels) z = channels; + while (n < num_samples) { + int i; + int k = f->channel_buffer_end - f->channel_buffer_start; + if (n+k >= num_samples) k = num_samples - n; + if (k) { + for (i=0; i < z; ++i) + memcpy(buffer[i]+n, f->channel_buffers[i]+f->channel_buffer_start, sizeof(float)*k); + for ( ; i < channels; ++i) + memset(buffer[i]+n, 0, sizeof(float) * k); + } + n += k; + f->channel_buffer_start += k; + if (n == num_samples) + break; + if (!stb_vorbis_get_frame_float(f, NULL, &outputs)) + break; + } + return n; +} +#endif // STB_VORBIS_NO_PULLDATA_API + +/* Version history + 1.17 - 2019-07-08 - fix CVE-2019-13217, -13218, -13219, -13220, -13221, -13222, -13223 + found with Mayhem by ForAllSecure + 1.16 - 2019-03-04 - fix warnings + 1.15 - 2019-02-07 - explicit failure if Ogg Skeleton data is found + 1.14 - 2018-02-11 - delete bogus dealloca usage + 1.13 - 2018-01-29 - fix truncation of last frame (hopefully) + 1.12 - 2017-11-21 - limit residue begin/end to blocksize/2 to avoid large temp allocs in bad/corrupt files + 1.11 - 2017-07-23 - fix MinGW compilation + 1.10 - 2017-03-03 - more robust seeking; fix negative ilog(); clear error in open_memory + 1.09 - 2016-04-04 - back out 'avoid discarding last frame' fix from previous version + 1.08 - 2016-04-02 - fixed multiple warnings; fix setup memory leaks; + avoid discarding last frame of audio data + 1.07 - 2015-01-16 - fixed some warnings, fix mingw, const-correct API + some more crash fixes when out of memory or with corrupt files + 1.06 - 2015-08-31 - full, correct support for seeking API (Dougall Johnson) + some crash fixes when out of memory or with corrupt files + 1.05 - 2015-04-19 - don't define __forceinline if it's redundant + 1.04 - 2014-08-27 - fix missing const-correct case in API + 1.03 - 2014-08-07 - Warning fixes + 1.02 - 2014-07-09 - Declare qsort compare function _cdecl on windows + 1.01 - 2014-06-18 - fix stb_vorbis_get_samples_float + 1.0 - 2014-05-26 - fix memory leaks; fix warnings; fix bugs in multichannel + (API change) report sample rate for decode-full-file funcs + 0.99996 - bracket #include for macintosh compilation by Laurent Gomila + 0.99995 - use union instead of pointer-cast for fast-float-to-int to avoid alias-optimization problem + 0.99994 - change fast-float-to-int to work in single-precision FPU mode, remove endian-dependence + 0.99993 - remove assert that fired on legal files with empty tables + 0.99992 - rewind-to-start + 0.99991 - bugfix to stb_vorbis_get_samples_short by Bernhard Wodo + 0.9999 - (should have been 0.99990) fix no-CRT support, compiling as C++ + 0.9998 - add a full-decode function with a memory source + 0.9997 - fix a bug in the read-from-FILE case in 0.9996 addition + 0.9996 - query length of vorbis stream in samples/seconds + 0.9995 - bugfix to another optimization that only happened in certain files + 0.9994 - bugfix to one of the optimizations that caused significant (but inaudible?) errors + 0.9993 - performance improvements; runs in 99% to 104% of time of reference implementation + 0.9992 - performance improvement of IMDCT; now performs close to reference implementation + 0.9991 - performance improvement of IMDCT + 0.999 - (should have been 0.9990) performance improvement of IMDCT + 0.998 - no-CRT support from Casey Muratori + 0.997 - bugfixes for bugs found by Terje Mathisen + 0.996 - bugfix: fast-huffman decode initialized incorrectly for sparse codebooks; fixing gives 10% speedup - found by Terje Mathisen + 0.995 - bugfix: fix to 'effective' overrun detection - found by Terje Mathisen + 0.994 - bugfix: garbage decode on final VQ symbol of a non-multiple - found by Terje Mathisen + 0.993 - bugfix: pushdata API required 1 extra byte for empty page (failed to consume final page if empty) - found by Terje Mathisen + 0.992 - fixes for MinGW warning + 0.991 - turn fast-float-conversion on by default + 0.990 - fix push-mode seek recovery if you seek into the headers + 0.98b - fix to bad release of 0.98 + 0.98 - fix push-mode seek recovery; robustify float-to-int and support non-fast mode + 0.97 - builds under c++ (typecasting, don't use 'class' keyword) + 0.96 - somehow MY 0.95 was right, but the web one was wrong, so here's my 0.95 rereleased as 0.96, fixes a typo in the clamping code + 0.95 - clamping code for 16-bit functions + 0.94 - not publically released + 0.93 - fixed all-zero-floor case (was decoding garbage) + 0.92 - fixed a memory leak + 0.91 - conditional compiles to omit parts of the API and the infrastructure to support them: STB_VORBIS_NO_PULLDATA_API, STB_VORBIS_NO_PUSHDATA_API, STB_VORBIS_NO_STDIO, STB_VORBIS_NO_INTEGER_CONVERSION + 0.90 - first public release +*/ + +#endif // STB_VORBIS_HEADER_ONLY + + +/* +------------------------------------------------------------------------------ +This software is available under 2 licenses -- choose whichever you prefer. +------------------------------------------------------------------------------ +ALTERNATIVE A - MIT License +Copyright (c) 2017 Sean Barrett +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is furnished to do +so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +------------------------------------------------------------------------------ +ALTERNATIVE B - Public Domain (www.unlicense.org) +This is free and unencumbered software released into the public domain. +Anyone is free to copy, modify, publish, use, compile, sell, or distribute this +software, either in source code form or as a compiled binary, for any purpose, +commercial or non-commercial, and by any means. +In jurisdictions that recognize copyright laws, the author or authors of this +software dedicate any and all copyright interest in the software to the public +domain. We make this dedication for the benefit of the public at large and to +the detriment of our heirs and successors. We intend this dedication to be an +overt act of relinquishment in perpetuity of all present and future rights to +this software under copyright law. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN +ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +------------------------------------------------------------------------------ +*/ diff --git a/tests/data/c/stb/stb_voxel_render.h b/tests/data/c/stb/stb_voxel_render.h new file mode 100644 index 000000000..2e7a372f8 --- /dev/null +++ b/tests/data/c/stb/stb_voxel_render.h @@ -0,0 +1,3807 @@ +// stb_voxel_render.h - v0.89 - Sean Barrett, 2015 - public domain +// +// This library helps render large-scale "voxel" worlds for games, +// in this case, one with blocks that can have textures and that +// can also be a few shapes other than cubes. +// +// Video introduction: +// http://www.youtube.com/watch?v=2vnTtiLrV1w +// +// Minecraft-viewer sample app (not very simple though): +// http://github.com/nothings/stb/tree/master/tests/caveview +// +// It works by creating triangle meshes. The library includes +// +// - converter from dense 3D arrays of block info to vertex mesh +// - vertex & fragment shaders for the vertex mesh +// - assistance in setting up shader state +// +// For portability, none of the library code actually accesses +// the 3D graphics API. (At the moment, it's not actually portable +// since the shaders are GLSL only, but patches are welcome.) +// +// You have to do all the caching and tracking of vertex buffers +// yourself. However, you could also try making a game with +// a small enough world that it's fully loaded rather than +// streaming. Currently the preferred vertex format is 20 bytes +// per quad. There are designs to allow much more compact formats +// with a slight reduction in shader features, but no roadmap +// for actually implementing them. +// +// +// USAGE +// +// #define the symbol STB_VOXEL_RENDER_IMPLEMENTATION in *one* +// C/C++ file before the #include of this file; the implementation +// will be generated in that file. +// +// If you define the symbols STB_VOXEL_RENDER_STATIC, then the +// implementation will be private to that file. +// +// +// FEATURES +// +// - you can choose textured blocks with the features below, +// or colored voxels with 2^24 colors and no textures. +// +// - voxels are mostly just cubes, but there's support for +// half-height cubes and diagonal slopes, half-height +// diagonals, and even odder shapes especially for doing +// more-continuous "ground". +// +// - texture coordinates are projections along one of the major +// axes, with the per-texture scaling. +// +// - a number of aspects of the shader and the vertex format +// are configurable; the library generally takes care of +// coordinating the vertex format with the mesh for you. +// +// +// FEATURES (SHADER PERSPECTIVE) +// +// - vertices aligned on integer lattice, z on multiples of 0.5 +// - per-vertex "lighting" or "ambient occlusion" value (6 bits) +// - per-vertex texture crossfade (3 bits) +// +// - per-face texture #1 id (8-bit index into array texture) +// - per-face texture #2 id (8-bit index into second array texture) +// - per-face color (6-bit palette index, 2 bits of per-texture boolean enable) +// - per-face 5-bit normal for lighting calculations & texture coord computation +// - per-face 2-bit texture matrix rotation to rotate faces +// +// - indexed-by-texture-id scale factor (separate for texture #1 and texture #2) +// - indexed-by-texture-#2-id blend mode (alpha composite or modulate/multiply); +// the first is good for decals, the second for detail textures, "light maps", +// etc; both modes are controlled by texture #2's alpha, scaled by the +// per-vertex texture crossfade and the per-face color (if enabled on texture #2); +// modulate/multiply multiplies by an extra factor of 2.0 so that if you +// make detail maps whose average brightness is 0.5 everything works nicely. +// +// - ambient lighting: half-lambert directional plus constant, all scaled by vertex ao +// - face can be fullbright (emissive), controlled by per-face color +// - installable lighting, with default single-point-light +// - installable fog, with default hacked smoothstep +// +// Note that all the variations of lighting selection and texture +// blending are run-time conditions in the shader, so they can be +// intermixed in a single mesh. +// +// +// INTEGRATION ARC +// +// The way to get this library to work from scratch is to do the following: +// +// Step 1. define STBVOX_CONFIG_MODE to 0 +// +// This mode uses only vertex attributes and uniforms, and is easiest +// to get working. It requires 32 bytes per quad and limits the +// size of some tables to avoid hitting uniform limits. +// +// Step 2. define STBVOX_CONFIG_MODE to 1 +// +// This requires using a texture buffer to store the quad data, +// reducing the size to 20 bytes per quad. +// +// Step 3: define STBVOX_CONFIG_PREFER_TEXBUFFER +// +// This causes some uniforms to be stored as texture buffers +// instead. This increases the size of some of those tables, +// and avoids a potential slow path (gathering non-uniform +// data from uniforms) on some hardware. +// +// In the future I might add additional modes that have significantly +// smaller meshes but reduce features, down as small as 6 bytes per quad. +// See elsewhere in this file for a table of candidate modes. Switching +// to a mode will require changing some of your mesh creation code, but +// everything else should be seamless. (And I'd like to change the API +// so that mesh creation is data-driven the way the uniforms are, and +// then you wouldn't even have to change anything but the mode number.) +// +// +// IMPROVEMENTS FOR SHIP-WORTHY PROGRAMS USING THIS LIBRARY +// +// I currently tolerate a certain level of "bugginess" in this library. +// +// I'm referring to things which look a little wrong (as long as they +// don't cause holes or cracks in the output meshes), or things which +// do not produce as optimal a mesh as possible. Notable examples: +// +// - incorrect lighting on slopes +// - inefficient meshes for vheight blocks +// +// I am willing to do the work to improve these things if someone is +// going to ship a substantial program that would be improved by them. +// (It need not be commercial, nor need it be a game.) I just didn't +// want to do the work up front if it might never be leveraged. So just +// submit a bug report as usual (github is preferred), but add a note +// that this is for a thing that is really going to ship. (That means +// you need to be far enough into the project that it's clear you're +// committed to it; not during early exploratory development.) +// +// +// VOXEL MESH API +// +// Context +// +// To understand the API, make sure you first understand the feature set +// listed above. +// +// Because the vertices are compact, they have very limited spatial +// precision. Thus a single mesh can only contain the data for a limited +// area. To make very large voxel maps, you'll need to build multiple +// vertex buffers. (But you want this anyway for frustum culling.) +// +// Each generated mesh has three components: +// - vertex data (vertex buffer) +// - face data (optional, stored in texture buffer) +// - mesh transform (uniforms) +// +// Once you've generated the mesh with this library, it's up to you +// to upload it to the GPU, to keep track of the state, and to render +// it. +// +// Concept +// +// The basic design is that you pass in one or more 3D arrays; each array +// is (typically) one-byte-per-voxel and contains information about one +// or more properties of some particular voxel property. +// +// Because there is so much per-vertex and per-face data possible +// in the output, and each voxel can have 6 faces and 8 vertices, it +// would require an very large data structure to describe all +// of the possibilities, and this would cause the mesh-creation +// process to be slow. Instead, the API provides multiple ways +// to express each property, some more compact, others less so; +// each such way has some limitations on what it can express. +// +// Note that there are so many paths and combinations, not all of them +// have been tested. Just report bugs and I'll fix 'em. +// +// Details +// +// See the API documentation in the header-file section. +// +// +// CONTRIBUTORS +// +// Features Porting Bugfixes & Warnings +// Sean Barrett github:r-leyh Jesus Fernandez +// Miguel Lechon github:Arbeiterunfallversicherungsgesetz +// Thomas Frase James Hofmann +// Stephen Olsen github:guitarfreak +// +// VERSION HISTORY +// +// 0.89 (2020-02-02) bugfix in sample code +// 0.88 (2019-03-04) fix warnings +// 0.87 (2019-02-25) fix warning +// 0.86 (2019-02-07) fix typos in comments +// 0.85 (2017-03-03) add block_selector (by guitarfreak) +// 0.84 (2016-04-02) fix GLSL syntax error on glModelView path +// 0.83 (2015-09-13) remove non-constant struct initializers to support more compilers +// 0.82 (2015-08-01) added input.packed_compact to store rot, vheight & texlerp efficiently +// fix broken tex_overlay2 +// 0.81 (2015-05-28) fix broken STBVOX_CONFIG_OPTIMIZED_VHEIGHT +// 0.80 (2015-04-11) fix broken STBVOX_CONFIG_ROTATION_IN_LIGHTING refactoring +// change STBVOX_MAKE_LIGHTING to STBVOX_MAKE_LIGHTING_EXT so +// that header defs don't need to see config vars +// add STBVOX_CONFIG_VHEIGHT_IN_LIGHTING and other vheight fixes +// added documentation for vheight ("weird slopes") +// 0.79 (2015-04-01) fix the missing types from 0.78; fix string constants being const +// 0.78 (2015-04-02) bad "#else", compile as C++ +// 0.77 (2015-04-01) documentation tweaks, rename config var to STB_VOXEL_RENDER_STATIC +// 0.76 (2015-04-01) typos, signed/unsigned shader issue, more documentation +// 0.75 (2015-04-01) initial release +// +// +// HISTORICAL FOUNDATION +// +// stb_voxel_render 20-byte quads 2015/01 +// zmc engine 32-byte quads 2013/12 +// zmc engine 96-byte quads 2011/10 +// +// +// LICENSE +// +// See end of file for license information. + +#ifndef INCLUDE_STB_VOXEL_RENDER_H +#define INCLUDE_STB_VOXEL_RENDER_H + +#include + +typedef struct stbvox_mesh_maker stbvox_mesh_maker; +typedef struct stbvox_input_description stbvox_input_description; + +#ifdef STB_VOXEL_RENDER_STATIC +#define STBVXDEC static +#else +#define STBVXDEC extern +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +////////////////////////////////////////////////////////////////////////////// +// +// CONFIGURATION MACROS +// +// #define STBVOX_CONFIG_MODE // REQUIRED +// Configures the overall behavior of stb_voxel_render. This +// can affect the shaders, the uniform info, and other things. +// (If you need more than one mode in the same app, you can +// use STB_VOXEL_RENDER_STATIC to create multiple versions +// in separate files, and then wrap them.) +// +// Mode value Meaning +// 0 Textured blocks, 32-byte quads +// 1 Textured blocks, 20-byte quads +// 20 Untextured blocks, 32-byte quads +// 21 Untextured blocks, 20-byte quads +// +// +// #define STBVOX_CONFIG_PRECISION_Z // OPTIONAL +// Defines the number of bits of fractional position for Z. +// Only 0 or 1 are valid. 1 is the default. If 0, then a +// single mesh has twice the legal Z range; e.g. in +// modes 0,1,20,21, Z in the mesh can extend to 511 instead +// of 255. However, half-height blocks cannot be used. +// +// All of the following are just #ifdef tested so need no values, and are optional. +// +// STBVOX_CONFIG_BLOCKTYPE_SHORT +// use unsigned 16-bit values for 'blocktype' in the input instead of 8-bit values +// +// STBVOX_CONFIG_OPENGL_MODELVIEW +// use the gl_ModelView matrix rather than the explicit uniform +// +// STBVOX_CONFIG_HLSL +// NOT IMPLEMENTED! Define HLSL shaders instead of GLSL shaders +// +// STBVOX_CONFIG_PREFER_TEXBUFFER +// Stores many of the uniform arrays in texture buffers instead, +// so they can be larger and may be more efficient on some hardware. +// +// STBVOX_CONFIG_LIGHTING_SIMPLE +// Creates a simple lighting engine with a single point light source +// in addition to the default half-lambert ambient light. +// +// STBVOX_CONFIG_LIGHTING +// Declares a lighting function hook; you must append a lighting function +// to the shader before compiling it: +// vec3 compute_lighting(vec3 pos, vec3 norm, vec3 albedo, vec3 ambient); +// 'ambient' is the half-lambert ambient light with vertex ambient-occlusion applied +// +// STBVOX_CONFIG_FOG_SMOOTHSTEP +// Defines a simple unrealistic fog system designed to maximize +// unobscured view distance while not looking too weird when things +// emerge from the fog. Configured using an extra array element +// in the STBVOX_UNIFORM_ambient uniform. +// +// STBVOX_CONFIG_FOG +// Defines a fog function hook; you must append a fog function to +// the shader before compiling it: +// vec3 compute_fog(vec3 color, vec3 relative_pos, float fragment_alpha); +// "color" is the incoming pre-fogged color, fragment_alpha is the alpha value, +// and relative_pos is the vector from the point to the camera in worldspace +// +// STBVOX_CONFIG_DISABLE_TEX2 +// This disables all processing of texture 2 in the shader in case +// you don't use it. Eventually this could be replaced with a mode +// that omits the unused data entirely. +// +// STBVOX_CONFIG_TEX1_EDGE_CLAMP +// STBVOX_CONFIG_TEX2_EDGE_CLAMP +// If you want to edge clamp the textures, instead of letting them wrap, +// set this flag. By default stb_voxel_render relies on texture wrapping +// to simplify texture coordinate generation. This flag forces it to do +// it correctly, although there can still be minor artifacts. +// +// STBVOX_CONFIG_ROTATION_IN_LIGHTING +// Changes the meaning of the 'lighting' mesher input variable to also +// store the rotation; see later discussion. +// +// STBVOX_CONFIG_VHEIGHT_IN_LIGHTING +// Changes the meaning of the 'lighting' mesher input variable to also +// store the vheight; see later discussion. Cannot use both this and +// the previous variable. +// +// STBVOX_CONFIG_PREMULTIPLIED_ALPHA +// Adjusts the shader calculations on the assumption that tex1.rgba, +// tex2.rgba, and color.rgba all use premultiplied values, and that +// the output of the fragment shader should be premultiplied. +// +// STBVOX_CONFIG_UNPREMULTIPLY +// Only meaningful if STBVOX_CONFIG_PREMULTIPLIED_ALPHA is defined. +// Changes the behavior described above so that the inputs are +// still premultiplied alpha, but the output of the fragment +// shader is not premultiplied alpha. This is needed when allowing +// non-unit alpha values but not doing alpha-blending (for example +// when alpha testing). +// + +////////////////////////////////////////////////////////////////////////////// +// +// MESHING +// +// A mesh represents a (typically) small chunk of a larger world. +// Meshes encode coordinates using small integers, so those +// coordinates must be relative to some base location. +// All of the coordinates in the functions below use +// these relative coordinates unless explicitly stated +// otherwise. +// +// Input to the meshing step is documented further down + +STBVXDEC void stbvox_init_mesh_maker(stbvox_mesh_maker *mm); +// Call this function to initialize a mesh-maker context structure +// used to build meshes. You should have one context per thread +// that's building meshes. + +STBVXDEC void stbvox_set_buffer(stbvox_mesh_maker *mm, int mesh, int slot, void *buffer, size_t len); +// Call this to set the buffer into which stbvox will write the mesh +// it creates. It can build more than one mesh in parallel (distinguished +// by the 'mesh' parameter), and each mesh can be made up of more than +// one buffer (distinguished by the 'slot' parameter). +// +// Multiple meshes are under your control; use the 'selector' input +// variable to choose which mesh each voxel's vertices are written to. +// For example, you can use this to generate separate meshes for opaque +// and transparent data. +// +// You can query the number of slots by calling stbvox_get_buffer_count +// described below. The meaning of the buffer for each slot depends +// on STBVOX_CONFIG_MODE. +// +// In mode 0 & mode 20, there is only one slot. The mesh data for that +// slot is two interleaved vertex attributes: attr_vertex, a single +// 32-bit uint, and attr_face, a single 32-bit uint. +// +// In mode 1 & mode 21, there are two slots. The first buffer should +// be four times as large as the second buffer. The first buffer +// contains a single vertex attribute: 'attr_vertex', a single 32-bit uint. +// The second buffer contains texture buffer data (an array of 32-bit uints) +// that will be accessed through the sampler identified by STBVOX_UNIFORM_face_data. + +STBVXDEC int stbvox_get_buffer_count(stbvox_mesh_maker *mm); +// Returns the number of buffers needed per mesh as described above. + +STBVXDEC int stbvox_get_buffer_size_per_quad(stbvox_mesh_maker *mm, int slot); +// Returns how much of a given buffer will get used per quad. This +// allows you to choose correct relative sizes for each buffer, although +// the values are fixed based on the configuration you've selected at +// compile time, and the details are described in stbvox_set_buffer. + +STBVXDEC void stbvox_set_default_mesh(stbvox_mesh_maker *mm, int mesh); +// Selects which mesh the mesher will output to (see previous function) +// if the input doesn't specify a per-voxel selector. (I doubt this is +// useful, but it's here just in case.) + +STBVXDEC stbvox_input_description *stbvox_get_input_description(stbvox_mesh_maker *mm); +// This function call returns a pointer to the stbvox_input_description part +// of stbvox_mesh_maker (which you should otherwise treat as opaque). You +// zero this structure, then fill out the relevant pointers to the data +// describing your voxel object/world. +// +// See further documentation at the description of stbvox_input_description below. + +STBVXDEC void stbvox_set_input_stride(stbvox_mesh_maker *mm, int x_stride_in_elements, int y_stride_in_elements); +// This sets the stride between successive elements of the 3D arrays +// in the stbvox_input_description. Z values are always stored consecutively. +// (The preferred coordinate system for stbvox is X right, Y forwards, Z up.) + +STBVXDEC void stbvox_set_input_range(stbvox_mesh_maker *mm, int x0, int y0, int z0, int x1, int y1, int z1); +// This sets the range of values in the 3D array for the voxels that +// the mesh generator will convert. The lower values are inclusive, +// the higher values are exclusive, so (0,0,0) to (16,16,16) generates +// mesh data associated with voxels up to (15,15,15) but no higher. +// +// The mesh generate generates faces at the boundary between open space +// and solid space but associates them with the solid space, so if (15,0,0) +// is open and (16,0,0) is solid, then the mesh will contain the boundary +// between them if x0 <= 16 and x1 > 16. +// +// Note that the mesh generator will access array elements 1 beyond the +// limits set in these parameters. For example, if you set the limits +// to be (0,0,0) and (16,16,16), then the generator will access all of +// the voxels between (-1,-1,-1) and (16,16,16), including (16,16,16). +// You may have to do pointer arithmetic to make it work. +// +// For example, caveview processes mesh chunks that are 32x32x16, but it +// does this using input buffers that are 34x34x18. +// +// The lower limits are x0 >= 0, y0 >= 0, and z0 >= 0. +// +// The upper limits are mode dependent, but all the current methods are +// limited to x1 < 127, y1 < 127, z1 < 255. Note that these are not +// powers of two; if you want to use power-of-two chunks (to make +// it efficient to decide which chunk a coordinate falls in), you're +// limited to at most x1=64, y1=64, z1=128. For classic Minecraft-style +// worlds with limited vertical extent, I recommend using a single +// chunk for the entire height, which limits the height to 255 blocks +// (one less than Minecraft), and only chunk the map in X & Y. + +STBVXDEC int stbvox_make_mesh(stbvox_mesh_maker *mm); +// Call this function to create mesh data for the currently configured +// set of input data. This appends to the currently configured mesh output +// buffer. Returns 1 on success. If there is not enough room in the buffer, +// it outputs as much as it can, and returns 0; you need to switch output +// buffers (either by calling stbvox_set_buffer to set new buffers, or +// by copying the data out and calling stbvox_reset_buffers), and then +// call this function again without changing any of the input parameters. +// +// Note that this function appends; you can call it multiple times to +// build a single mesh. For example, caveview uses chunks that are +// 32x32x255, but builds the mesh for it by processing 32x32x16 at atime +// (this is faster as it is reuses the same 34x34x18 input buffers rather +// than needing 34x34x257 input buffers). + +// Once you're done creating a mesh into a given buffer, +// consider the following functions: + +STBVXDEC int stbvox_get_quad_count(stbvox_mesh_maker *mm, int mesh); +// Returns the number of quads in the mesh currently generated by mm. +// This is the sum of all consecutive stbvox_make_mesh runs appending +// to the same buffer. 'mesh' distinguishes between the multiple user +// meshes available via 'selector' or stbvox_set_default_mesh. +// +// Typically you use this function when you're done building the mesh +// and want to record how to draw it. +// +// Note that there are no index buffers; the data stored in the buffers +// should be drawn as quads (e.g. with GL_QUAD); if your API does not +// support quads, you can create a single index buffer large enough to +// draw your largest vertex buffer, and reuse it for every rendering. +// (Note that if you use 32-bit indices, you'll use 24 bytes of bandwidth +// per quad, more than the 20 bytes for the vertex/face mesh data.) + +STBVXDEC void stbvox_set_mesh_coordinates(stbvox_mesh_maker *mm, int x, int y, int z); +// Sets the global coordinates for this chunk, such that (0,0,0) relative +// coordinates will be at (x,y,z) in global coordinates. + +STBVXDEC void stbvox_get_bounds(stbvox_mesh_maker *mm, float bounds[2][3]); +// Returns the bounds for the mesh in global coordinates. Use this +// for e.g. frustum culling the mesh. @BUG: this just uses the +// values from stbvox_set_input_range(), so if you build by +// appending multiple values, this will be wrong, and you need to +// set stbvox_set_input_range() to the full size. Someday this +// will switch to tracking the actual bounds of the *mesh*, though. + +STBVXDEC void stbvox_get_transform(stbvox_mesh_maker *mm, float transform[3][3]); +// Returns the 'transform' data for the shader uniforms. It is your +// job to set this to the shader before drawing the mesh. It is the +// only uniform that needs to change per-mesh. Note that it is not +// a 3x3 matrix, but rather a scale to decode fixed point numbers as +// floats, a translate from relative to global space, and a special +// translation for texture coordinate generation that avoids +// floating-point precision issues. @TODO: currently we add the +// global translation to the vertex, than multiply by modelview, +// but this means if camera location and vertex are far from the +// origin, we lose precision. Need to make a special modelview with +// the translation (or some of it) factored out to avoid this. + +STBVXDEC void stbvox_reset_buffers(stbvox_mesh_maker *mm); +// Call this function if you're done with the current output buffer +// but want to reuse it (e.g. you're done appending with +// stbvox_make_mesh and you've copied the data out to your graphics API +// so can reuse the buffer). + +////////////////////////////////////////////////////////////////////////////// +// +// RENDERING +// + +STBVXDEC char *stbvox_get_vertex_shader(void); +// Returns the (currently GLSL-only) vertex shader. + +STBVXDEC char *stbvox_get_fragment_shader(void); +// Returns the (currently GLSL-only) fragment shader. +// You can override the lighting and fogging calculations +// by appending data to the end of these; see the #define +// documentation for more information. + +STBVXDEC char *stbvox_get_fragment_shader_alpha_only(void); +// Returns a slightly cheaper fragment shader that computes +// alpha but not color. This is useful for e.g. a depth-only +// pass when using alpha test. + +typedef struct stbvox_uniform_info stbvox_uniform_info; + +STBVXDEC int stbvox_get_uniform_info(stbvox_uniform_info *info, int uniform); +// Gets the information about a uniform necessary for you to +// set up each uniform with a minimal amount of explicit code. +// See the sample code after the structure definition for stbvox_uniform_info, +// further down in this header section. +// +// "uniform" is from the list immediately following. For many +// of these, default values are provided which you can set. +// Most values are shared for most draw calls; e.g. for stateful +// APIs you can set most of the state only once. Only +// STBVOX_UNIFORM_transform needs to change per draw call. +// +// STBVOX_UNIFORM_texscale +// 64- or 128-long vec4 array. (128 only if STBVOX_CONFIG_PREFER_TEXBUFFER) +// x: scale factor to apply to texture #1. must be a power of two. 1.0 means 'face-sized' +// y: scale factor to apply to texture #2. must be a power of two. 1.0 means 'face-sized' +// z: blend mode indexed by texture #2. 0.0 is alpha compositing; 1.0 is multiplication. +// w: unused currently. @TODO use to support texture animation? +// +// Texscale is indexed by the bottom 6 or 7 bits of the texture id; thus for +// example the texture at index 0 in the array and the texture in index 128 of +// the array must be scaled the same. This means that if you only have 64 or 128 +// unique textures, they all get distinct values anyway; otherwise you have +// to group them in pairs or sets of four. +// +// STBVOX_UNIFORM_ambient +// 4-long vec4 array: +// ambient[0].xyz - negative of direction of a directional light for half-lambert +// ambient[1].rgb - color of light scaled by NdotL (can be negative) +// ambient[2].rgb - constant light added to above calculation; +// effectively light ranges from ambient[2]-ambient[1] to ambient[2]+ambient[1] +// ambient[3].rgb - fog color for STBVOX_CONFIG_FOG_SMOOTHSTEP +// ambient[3].a - reciprocal of squared distance of farthest fog point (viewing distance) + + + // +----- has a default value + // | +-- you should always use the default value +enum // V V +{ // ------------------------------------------------ + STBVOX_UNIFORM_face_data, // n the sampler with the face texture buffer + STBVOX_UNIFORM_transform, // n the transform data from stbvox_get_transform + STBVOX_UNIFORM_tex_array, // n an array of two texture samplers containing the two texture arrays + STBVOX_UNIFORM_texscale, // Y a table of texture properties, see above + STBVOX_UNIFORM_color_table, // Y 64 vec4 RGBA values; a default palette is provided; if A > 1.0, fullbright + STBVOX_UNIFORM_normals, // Y Y table of normals, internal-only + STBVOX_UNIFORM_texgen, // Y Y table of texgen vectors, internal-only + STBVOX_UNIFORM_ambient, // n lighting & fog info, see above + STBVOX_UNIFORM_camera_pos, // Y camera position in global voxel space (for lighting & fog) + + STBVOX_UNIFORM_count, +}; + +enum +{ + STBVOX_UNIFORM_TYPE_none, + STBVOX_UNIFORM_TYPE_sampler, + STBVOX_UNIFORM_TYPE_vec2, + STBVOX_UNIFORM_TYPE_vec3, + STBVOX_UNIFORM_TYPE_vec4, +}; + +struct stbvox_uniform_info +{ + int type; // which type of uniform + int bytes_per_element; // the size of each uniform array element (e.g. vec3 = 12 bytes) + int array_length; // length of the uniform array + char *name; // name in the shader @TODO use numeric binding + float *default_value; // if not NULL, you can use this as the uniform pointer + int use_tex_buffer; // if true, then the uniform is a sampler but the data can come from default_value +}; + +////////////////////////////////////////////////////////////////////////////// +// +// Uniform sample code +// + +#if 0 +// Run this once per frame before drawing all the meshes. +// You still need to separately set the 'transform' uniform for every mesh. +void setup_uniforms(GLuint shader, float camera_pos[4], GLuint tex1, GLuint tex2) +{ + int i; + glUseProgram(shader); // so uniform binding works + for (i=0; i < STBVOX_UNIFORM_count; ++i) { + stbvox_uniform_info sui; + if (stbvox_get_uniform_info(&sui, i)) { + GLint loc = glGetUniformLocation(shader, sui.name); + if (loc != -1) { + switch (i) { + case STBVOX_UNIFORM_camera_pos: // only needed for fog + glUniform4fv(loc, sui.array_length, camera_pos); + break; + + case STBVOX_UNIFORM_tex_array: { + GLuint tex_unit[2] = { 0, 1 }; // your choice of samplers + glUniform1iv(loc, 2, tex_unit); + + glActiveTexture(GL_TEXTURE0 + tex_unit[0]); glBindTexture(GL_TEXTURE_2D_ARRAY, tex1); + glActiveTexture(GL_TEXTURE0 + tex_unit[1]); glBindTexture(GL_TEXTURE_2D_ARRAY, tex2); + glActiveTexture(GL_TEXTURE0); // reset to default + break; + } + + case STBVOX_UNIFORM_face_data: + glUniform1i(loc, SAMPLER_YOU_WILL_BIND_PER_MESH_FACE_DATA_TO); + break; + + case STBVOX_UNIFORM_ambient: // you definitely want to override this + case STBVOX_UNIFORM_color_table: // you might want to override this + case STBVOX_UNIFORM_texscale: // you may want to override this + glUniform4fv(loc, sui.array_length, sui.default_value); + break; + + case STBVOX_UNIFORM_normals: // you never want to override this + case STBVOX_UNIFORM_texgen: // you never want to override this + glUniform3fv(loc, sui.array_length, sui.default_value); + break; + } + } + } + } +} +#endif + +#ifdef __cplusplus +} +#endif + +////////////////////////////////////////////////////////////////////////////// +// +// INPUT TO MESHING +// + +// Shapes of blocks that aren't always cubes +enum +{ + STBVOX_GEOM_empty, + STBVOX_GEOM_knockout, // creates a hole in the mesh + STBVOX_GEOM_solid, + STBVOX_GEOM_transp, // solid geometry, but transparent contents so neighbors generate normally, unless same blocktype + + // following 4 can be represented by vheight as well + STBVOX_GEOM_slab_upper, + STBVOX_GEOM_slab_lower, + STBVOX_GEOM_floor_slope_north_is_top, + STBVOX_GEOM_ceil_slope_north_is_bottom, + + STBVOX_GEOM_floor_slope_north_is_top_as_wall_UNIMPLEMENTED, // same as floor_slope above, but uses wall's texture & texture projection + STBVOX_GEOM_ceil_slope_north_is_bottom_as_wall_UNIMPLEMENTED, + STBVOX_GEOM_crossed_pair, // corner-to-corner pairs, with normal vector bumped upwards + STBVOX_GEOM_force, // like GEOM_transp, but faces visible even if neighbor is same type, e.g. minecraft fancy leaves + + // these access vheight input + STBVOX_GEOM_floor_vheight_03 = 12, // diagonal is SW-NE + STBVOX_GEOM_floor_vheight_12, // diagonal is SE-NW + STBVOX_GEOM_ceil_vheight_03, + STBVOX_GEOM_ceil_vheight_12, + + STBVOX_GEOM_count, // number of geom cases +}; + +enum +{ + STBVOX_FACE_east, + STBVOX_FACE_north, + STBVOX_FACE_west, + STBVOX_FACE_south, + STBVOX_FACE_up, + STBVOX_FACE_down, + + STBVOX_FACE_count, +}; + +#ifdef STBVOX_CONFIG_BLOCKTYPE_SHORT +typedef unsigned short stbvox_block_type; +#else +typedef unsigned char stbvox_block_type; +#endif + +// 24-bit color +typedef struct +{ + unsigned char r,g,b; +} stbvox_rgb; + +#define STBVOX_COLOR_TEX1_ENABLE 64 +#define STBVOX_COLOR_TEX2_ENABLE 128 + +// This is the data structure you fill out. Most of the arrays can be +// NULL, except when one is required to get the value to index another. +// +// The compass system used in the following descriptions is: +// east means increasing x +// north means increasing y +// up means increasing z +struct stbvox_input_description +{ + unsigned char lighting_at_vertices; + // The default is lighting values (i.e. ambient occlusion) are at block + // center, and the vertex light is gathered from those adjacent block + // centers that the vertex is facing. This makes smooth lighting + // consistent across adjacent faces with the same orientation. + // + // Setting this flag to non-zero gives you explicit control + // of light at each vertex, but now the lighting/ao will be + // shared by all vertices at the same point, even if they + // have different normals. + + // these are mostly 3D maps you use to define your voxel world, using x_stride and y_stride + // note that for cache efficiency, you want to use the block_foo palettes as much as possible instead + + stbvox_rgb *rgb; + // Indexed by 3D coordinate. + // 24-bit voxel color for STBVOX_CONFIG_MODE = 20 or 21 only + + unsigned char *lighting; + // Indexed by 3D coordinate. The lighting value / ambient occlusion + // value that is used to define the vertex lighting values. + // The raw lighting values are defined at the center of blocks + // (or at vertex if 'lighting_at_vertices' is true). + // + // If the macro STBVOX_CONFIG_ROTATION_IN_LIGHTING is defined, + // then an additional 2-bit block rotation value is stored + // in this field as well. + // + // Encode with STBVOX_MAKE_LIGHTING_EXT(lighting,rot)--here + // 'lighting' should still be 8 bits, as the macro will + // discard the bottom bits automatically. Similarly, if + // using STBVOX_CONFIG_VHEIGHT_IN_LIGHTING, encode with + // STBVOX_MAKE_LIGHTING_EXT(lighting,vheight). + // + // (Rationale: rotation needs to be independent of blocktype, + // but is only 2 bits so doesn't want to be its own array. + // Lighting is the one thing that was likely to already be + // in use and that I could easily steal 2 bits from.) + + stbvox_block_type *blocktype; + // Indexed by 3D coordinate. This is a core "block type" value, which is used + // to index into other arrays; essentially a "palette". This is much more + // memory-efficient and performance-friendly than storing the values explicitly, + // but only makes sense if the values are always synchronized. + // + // If a voxel's blocktype is 0, it is assumed to be empty (STBVOX_GEOM_empty), + // and no other blocktypes should be STBVOX_GEOM_empty. (Only if you do not + // have blocktypes should STBVOX_GEOM_empty ever used.) + // + // Normally it is an unsigned byte, but you can override it to be + // a short if you have too many blocktypes. + + unsigned char *geometry; + // Indexed by 3D coordinate. Contains the geometry type for the block. + // Also contains a 2-bit rotation for how the whole block is rotated. + // Also includes a 2-bit vheight value when using shared vheight values. + // See the separate vheight documentation. + // Encode with STBVOX_MAKE_GEOMETRY(geom, rot, vheight) + + unsigned char *block_geometry; + // Array indexed by blocktype containing the geometry for this block, plus + // a 2-bit "simple rotation". Note rotation has limited use since it's not + // independent of blocktype. + // + // Encode with STBVOX_MAKE_GEOMETRY(geom,simple_rot,0) + + unsigned char *block_tex1; + // Array indexed by blocktype containing the texture id for texture #1. + + unsigned char (*block_tex1_face)[6]; + // Array indexed by blocktype and face containing the texture id for texture #1. + // The N/E/S/W face choices can be rotated by one of the rotation selectors; + // The top & bottom face textures will rotate to match. + // Note that it only makes sense to use one of block_tex1 or block_tex1_face; + // this pattern repeats throughout and this notice is not repeated. + + unsigned char *tex2; + // Indexed by 3D coordinate. Contains the texture id for texture #2 + // to use on all faces of the block. + + unsigned char *block_tex2; + // Array indexed by blocktype containing the texture id for texture #2. + + unsigned char (*block_tex2_face)[6]; + // Array indexed by blocktype and face containing the texture id for texture #2. + // The N/E/S/W face choices can be rotated by one of the rotation selectors; + // The top & bottom face textures will rotate to match. + + unsigned char *color; + // Indexed by 3D coordinate. Contains the color for all faces of the block. + // The core color value is 0..63. + // Encode with STBVOX_MAKE_COLOR(color_number, tex1_enable, tex2_enable) + + unsigned char *block_color; + // Array indexed by blocktype containing the color value to apply to the faces. + // The core color value is 0..63. + // Encode with STBVOX_MAKE_COLOR(color_number, tex1_enable, tex2_enable) + + unsigned char (*block_color_face)[6]; + // Array indexed by blocktype and face containing the color value to apply to that face. + // The core color value is 0..63. + // Encode with STBVOX_MAKE_COLOR(color_number, tex1_enable, tex2_enable) + + unsigned char *block_texlerp; + // Array indexed by blocktype containing 3-bit scalar for texture #2 alpha + // (known throughout as 'texlerp'). This is constant over every face even + // though the property is potentially per-vertex. + + unsigned char (*block_texlerp_face)[6]; + // Array indexed by blocktype and face containing 3-bit scalar for texture #2 alpha. + // This is constant over the face even though the property is potentially per-vertex. + + unsigned char *block_vheight; + // Array indexed by blocktype containing the vheight values for the + // top or bottom face of this block. These will rotate properly if the + // block is rotated. See discussion of vheight. + // Encode with STBVOX_MAKE_VHEIGHT(sw_height, se_height, nw_height, ne_height) + + unsigned char *selector; + // Array indexed by 3D coordinates indicating which output mesh to select. + + unsigned char *block_selector; + // Array indexed by blocktype indicating which output mesh to select. + + unsigned char *side_texrot; + // Array indexed by 3D coordinates encoding 2-bit texture rotations for the + // faces on the E/N/W/S sides of the block. + // Encode with STBVOX_MAKE_SIDE_TEXROT(rot_e, rot_n, rot_w, rot_s) + + unsigned char *block_side_texrot; + // Array indexed by blocktype encoding 2-bit texture rotations for the faces + // on the E/N/W/S sides of the block. + // Encode with STBVOX_MAKE_SIDE_TEXROT(rot_e, rot_n, rot_w, rot_s) + + unsigned char *overlay; // index into palettes listed below + // Indexed by 3D coordinate. If 0, there is no overlay. If non-zero, + // it indexes into to the below arrays and overrides the values + // defined by the blocktype. + + unsigned char (*overlay_tex1)[6]; + // Array indexed by overlay value and face, containing an override value + // for the texture id for texture #1. If 0, the value defined by blocktype + // is used. + + unsigned char (*overlay_tex2)[6]; + // Array indexed by overlay value and face, containing an override value + // for the texture id for texture #2. If 0, the value defined by blocktype + // is used. + + unsigned char (*overlay_color)[6]; + // Array indexed by overlay value and face, containing an override value + // for the face color. If 0, the value defined by blocktype is used. + + unsigned char *overlay_side_texrot; + // Array indexed by overlay value, encoding 2-bit texture rotations for the faces + // on the E/N/W/S sides of the block. + // Encode with STBVOX_MAKE_SIDE_TEXROT(rot_e, rot_n, rot_w, rot_s) + + unsigned char *rotate; + // Indexed by 3D coordinate. Allows independent rotation of several + // parts of the voxel, where by rotation I mean swapping textures + // and colors between E/N/S/W faces. + // Block: rotates anything indexed by blocktype + // Overlay: rotates anything indexed by overlay + // EColor: rotates faces defined in ecolor_facemask + // Encode with STBVOX_MAKE_MATROT(block,overlay,ecolor) + + unsigned char *tex2_for_tex1; + // Array indexed by tex1 containing the texture id for texture #2. + // You can use this if the two are always/almost-always strictly + // correlated (e.g. if tex2 is a detail texture for tex1), as it + // will be more efficient (touching fewer cache lines) than using + // e.g. block_tex2_face. + + unsigned char *tex2_replace; + // Indexed by 3D coordinate. Specifies the texture id for texture #2 + // to use on a single face of the voxel, which must be E/N/W/S (not U/D). + // The texture id is limited to 6 bits unless tex2_facemask is also + // defined (see below). + // Encode with STBVOX_MAKE_TEX2_REPLACE(tex2, face) + + unsigned char *tex2_facemask; + // Indexed by 3D coordinate. Specifies which of the six faces should + // have their tex2 replaced by the value of tex2_replace. In this + // case, all 8 bits of tex2_replace are used as the texture id. + // Encode with STBVOX_MAKE_FACE_MASK(east,north,west,south,up,down) + + unsigned char *extended_color; + // Indexed by 3D coordinate. Specifies a value that indexes into + // the ecolor arrays below (both of which must be defined). + + unsigned char *ecolor_color; + // Indexed by extended_color value, specifies an optional override + // for the color value on some faces. + // Encode with STBVOX_MAKE_COLOR(color_number, tex1_enable, tex2_enable) + + unsigned char *ecolor_facemask; + // Indexed by extended_color value, this specifies which faces the + // color in ecolor_color should be applied to. The faces can be + // independently rotated by the ecolor value of 'rotate', if it exists. + // Encode with STBVOX_MAKE_FACE_MASK(e,n,w,s,u,d) + + unsigned char *color2; + // Indexed by 3D coordinates, specifies an alternative color to apply + // to some of the faces of the block. + // Encode with STBVOX_MAKE_COLOR(color_number, tex1_enable, tex2_enable) + + unsigned char *color2_facemask; + // Indexed by 3D coordinates, specifies which faces should use the + // color defined in color2. No rotation value is applied. + // Encode with STBVOX_MAKE_FACE_MASK(e,n,w,s,u,d) + + unsigned char *color3; + // Indexed by 3D coordinates, specifies an alternative color to apply + // to some of the faces of the block. + // Encode with STBVOX_MAKE_COLOR(color_number, tex1_enable, tex2_enable) + + unsigned char *color3_facemask; + // Indexed by 3D coordinates, specifies which faces should use the + // color defined in color3. No rotation value is applied. + // Encode with STBVOX_MAKE_FACE_MASK(e,n,w,s,u,d) + + unsigned char *texlerp_simple; + // Indexed by 3D coordinates, this is the smallest texlerp encoding + // that can do useful work. It consits of three values: baselerp, + // vertlerp, and face_vertlerp. Baselerp defines the value + // to use on all of the faces but one, from the STBVOX_TEXLERP_BASE + // values. face_vertlerp is one of the 6 face values (or STBVOX_FACE_NONE) + // which specifies the face should use the vertlerp values. + // Vertlerp defines a lerp value at every vertex of the mesh. + // Thus, one face can have per-vertex texlerp values, and those + // values are encoded in the space so that they will be shared + // by adjacent faces that also use vertlerp, allowing continuity + // (this is used for the "texture crossfade" bit of the release video). + // Encode with STBVOX_MAKE_TEXLERP_SIMPLE(baselerp, vertlerp, face_vertlerp) + + // The following texlerp encodings are experimental and maybe not + // that useful. + + unsigned char *texlerp; + // Indexed by 3D coordinates, this defines four values: + // vertlerp is a lerp value at every vertex of the mesh (using STBVOX_TEXLERP_BASE values). + // ud is the value to use on up and down faces, from STBVOX_TEXLERP_FACE values + // ew is the value to use on east and west faces, from STBVOX_TEXLERP_FACE values + // ns is the value to use on north and south faces, from STBVOX_TEXLERP_FACE values + // If any of ud, ew, or ns is STBVOX_TEXLERP_FACE_use_vert, then the + // vertlerp values for the vertices are gathered and used for those faces. + // Encode with STBVOX_MAKE_TEXLERP(vertlerp,ud,ew,sw) + + unsigned short *texlerp_vert3; + // Indexed by 3D coordinates, this works with texlerp and + // provides a unique texlerp value for every direction at + // every vertex. The same rules of whether faces share values + // applies. The STBVOX_TEXLERP_FACE vertlerp value defined in + // texlerp is only used for the down direction. The values at + // each vertex in other directions are defined in this array, + // and each uses the STBVOX_TEXLERP3 values (i.e. full precision + // 3-bit texlerp values). + // Encode with STBVOX_MAKE_VERT3(vertlerp_e,vertlerp_n,vertlerp_w,vertlerp_s,vertlerp_u) + + unsigned short *texlerp_face3; // e:3,n:3,w:3,s:3,u:2,d:2 + // Indexed by 3D coordinates, this provides a compact way to + // fully specify the texlerp value indepenendly for every face, + // but doesn't allow per-vertex variation. E/N/W/S values are + // encoded using STBVOX_TEXLERP3 values, whereas up and down + // use STBVOX_TEXLERP_SIMPLE values. + // Encode with STBVOX_MAKE_FACE3(face_e,face_n,face_w,face_s,face_u,face_d) + + unsigned char *vheight; // STBVOX_MAKE_VHEIGHT -- sw:2, se:2, nw:2, ne:2, doesn't rotate + // Indexed by 3D coordinates, this defines the four + // vheight values to use if the geometry is STBVOX_GEOM_vheight*. + // See the vheight discussion. + + unsigned char *packed_compact; + // Stores block rotation, vheight, and texlerp values: + // block rotation: 2 bits + // vertex vheight: 2 bits + // use_texlerp : 1 bit + // vertex texlerp: 3 bits + // If STBVOX_CONFIG_UP_TEXLERP_PACKED is defined, then 'vertex texlerp' is + // used for up faces if use_texlerp is 1. If STBVOX_CONFIG_DOWN_TEXLERP_PACKED + // is defined, then 'vertex texlerp' is used for down faces if use_texlerp is 1. + // Note if those symbols are defined but packed_compact is NULL, the normal + // texlerp default will be used. + // Encode with STBVOX_MAKE_PACKED_COMPACT(rot, vheight, texlerp, use_texlerp) +}; +// @OPTIMIZE allow specializing; build a single struct with all of the +// 3D-indexed arrays combined so it's AoS instead of SoA for better +// cache efficiency + + +////////////////////////////////////////////////////////////////////////////// +// +// VHEIGHT DOCUMENTATION +// +// "vheight" is the internal name for the special block types +// with sloped tops or bottoms. "vheight" stands for "vertex height". +// +// Note that these blocks are very flexible (there are 256 of them, +// although at least 17 of them should never be used), but they +// also have a disadvantage that they generate extra invisible +// faces; the generator does not currently detect whether adjacent +// vheight blocks hide each others sides, so those side faces are +// always generated. For a continuous ground terrain, this means +// that you may generate 5x as many quads as needed. See notes +// on "improvements for shipping products" in the introduction. + +enum +{ + STBVOX_VERTEX_HEIGHT_0, + STBVOX_VERTEX_HEIGHT_half, + STBVOX_VERTEX_HEIGHT_1, + STBVOX_VERTEX_HEIGHT_one_and_a_half, +}; +// These are the "vheight" values. Vheight stands for "vertex height". +// The idea is that for a "floor vheight" block, you take a cube and +// reposition the top-most vertices at various heights as specified by +// the vheight values. Similarly, a "ceiling vheight" block takes a +// cube and repositions the bottom-most vertices. +// +// A floor block only adjusts the top four vertices; the bottom four vertices +// remain at the bottom of the block. The height values are 2 bits, +// measured in halves of a block; so you can specify heights of 0/2, +// 1/2, 2/2, or 3/2. 0 is the bottom of the block, 1 is halfway +// up the block, 2 is the top of the block, and 3 is halfway up the +// next block (and actually outside of the block). The value 3 is +// actually legal for floor vheight (but not ceiling), and allows you to: +// +// (A) have smoother terrain by having slopes that cross blocks, +// e.g. (1,1,3,3) is a regular-seeming slope halfway between blocks +// (B) make slopes steeper than 45-degrees, e.g. (0,0,3,3) +// +// (Because only z coordinates have half-block precision, and x&y are +// limited to block corner precision, it's not possible to make these +// things "properly" out of blocks, e.g. a half-slope block on its side +// or a sloped block halfway between blocks that's made out of two blocks.) +// +// If you define STBVOX_CONFIG_OPTIMIZED_VHEIGHT, then the top face +// (or bottom face for a ceiling vheight block) will be drawn as a +// single quad even if the four vertex heights aren't planar, and a +// single normal will be used over the entire quad. If you +// don't define it, then if the top face is non-planar, it will be +// split into two triangles, each with their own normal/lighting. +// (Note that since all output from stb_voxel_render is quad meshes, +// triangles are actually rendered as degenerate quads.) In this case, +// the distinction between STBVOX_GEOM_floor_vheight_03 and +// STBVOX_GEOM_floor_vheight_12 comes into play; the former introduces +// an edge from the SW to NE corner (i.e. from <0,0,?> to <1,1,?>), +// while the latter introduces an edge from the NW to SE corner +// (i.e. from <0,1,?> to <1,0,?>.) For a "lazy mesh" look, use +// exclusively _03 or _12. For a "classic mesh" look, alternate +// _03 and _12 in a checkerboard pattern. For a "smoothest surface" +// look, choose the edge based on actual vertex heights. +// +// The four vertex heights can come from several places. The simplest +// encoding is to just use the 'vheight' parameter which stores four +// explicit vertex heights for every block. This allows total independence, +// but at the cost of the largest memory usage, 1 byte per 3D block. +// Encode this with STBVOX_MAKE_VHEIGHT(vh_sw, vh_se, vh_nw, vh_ne). +// These coordinates are absolute, not affected by block rotations. +// +// An alternative if you just want to encode some very specific block +// types, not all the possibilities--say you just want half-height slopes, +// so you want (0,0,1,1) and (1,1,2,2)--then you can use block_vheight +// to specify them. The geometry rotation will cause block_vheight values +// to be rotated (because it's as if you're just defining a type of +// block). This value is also encoded with STBVOX_MAKE_VHEIGHT. +// +// If you want to save memory and you're creating a "continuous ground" +// sort of effect, you can make each vertex of the lattice share the +// vheight value; that is, two adjacent blocks that share a vertex will +// always get the same vheight value for that vertex. Then you need to +// store two bits of vheight for every block, which you do by storing it +// as part another data structure. Store the south-west vertex's vheight +// with the block. You can either use the "geometry" mesh variable (it's +// a parameter to STBVOX_MAKE_GEOMETRY) or you can store it in the +// "lighting" mesh variable if you defined STBVOX_CONFIG_VHEIGHT_IN_LIGHTING, +// using STBVOX_MAKE_LIGHTING_EXT(lighting,vheight). +// +// Note that if you start with a 2D height map and generate vheight data from +// it, you don't necessarily store only one value per (x,y) coordinate, +// as the same value may need to be set up at multiple z heights. For +// example, if height(8,8) = 13.5, then you want the block at (8,8,13) +// to store STBVOX_VERTEX_HEIGHT_half, and this will be used by blocks +// at (7,7,13), (8,7,13), (7,8,13), and (8,8,13). However, if you're +// allowing steep slopes, it might be the case that you have a block +// at (7,7,12) which is supposed to stick up to 13.5; that means +// you also need to store STBVOX_VERTEX_HEIGHT_one_and_a_half at (8,8,12). + +enum +{ + STBVOX_TEXLERP_FACE_0, + STBVOX_TEXLERP_FACE_half, + STBVOX_TEXLERP_FACE_1, + STBVOX_TEXLERP_FACE_use_vert, +}; + +enum +{ + STBVOX_TEXLERP_BASE_0, // 0.0 + STBVOX_TEXLERP_BASE_2_7, // 2/7 + STBVOX_TEXLERP_BASE_5_7, // 4/7 + STBVOX_TEXLERP_BASE_1 // 1.0 +}; + +enum +{ + STBVOX_TEXLERP3_0_8, + STBVOX_TEXLERP3_1_8, + STBVOX_TEXLERP3_2_8, + STBVOX_TEXLERP3_3_8, + STBVOX_TEXLERP3_4_8, + STBVOX_TEXLERP3_5_8, + STBVOX_TEXLERP3_6_8, + STBVOX_TEXLERP3_7_8, +}; + +#define STBVOX_FACE_NONE 7 + +#define STBVOX_BLOCKTYPE_EMPTY 0 + +#ifdef STBVOX_BLOCKTYPE_SHORT +#define STBVOX_BLOCKTYPE_HOLE 65535 +#else +#define STBVOX_BLOCKTYPE_HOLE 255 +#endif + +#define STBVOX_MAKE_GEOMETRY(geom, rotate, vheight) ((geom) + (rotate)*16 + (vheight)*64) +#define STBVOX_MAKE_VHEIGHT(v_sw, v_se, v_nw, v_ne) ((v_sw) + (v_se)*4 + (v_nw)*16 + (v_ne)*64) +#define STBVOX_MAKE_MATROT(block, overlay, color) ((block) + (overlay)*4 + (color)*64) +#define STBVOX_MAKE_TEX2_REPLACE(tex2, tex2_replace_face) ((tex2) + ((tex2_replace_face) & 3)*64) +#define STBVOX_MAKE_TEXLERP(ns2, ew2, ud2, vert) ((ew2) + (ns2)*4 + (ud2)*16 + (vert)*64) +#define STBVOX_MAKE_TEXLERP_SIMPLE(baselerp,vert,face) ((vert)*32 + (face)*4 + (baselerp)) +#define STBVOX_MAKE_TEXLERP1(vert,e2,n2,w2,s2,u4,d2) STBVOX_MAKE_TEXLERP(s2, w2, d2, vert) +#define STBVOX_MAKE_TEXLERP2(vert,e2,n2,w2,s2,u4,d2) ((u2)*16 + (n2)*4 + (s2)) +#define STBVOX_MAKE_FACE_MASK(e,n,w,s,u,d) ((e)+(n)*2+(w)*4+(s)*8+(u)*16+(d)*32) +#define STBVOX_MAKE_SIDE_TEXROT(e,n,w,s) ((e)+(n)*4+(w)*16+(s)*64) +#define STBVOX_MAKE_COLOR(color,t1,t2) ((color)+(t1)*64+(t2)*128) +#define STBVOX_MAKE_TEXLERP_VERT3(e,n,w,s,u) ((e)+(n)*8+(w)*64+(s)*512+(u)*4096) +#define STBVOX_MAKE_TEXLERP_FACE3(e,n,w,s,u,d) ((e)+(n)*8+(w)*64+(s)*512+(u)*4096+(d)*16384) +#define STBVOX_MAKE_PACKED_COMPACT(rot, vheight, texlerp, def) ((rot)+4*(vheight)+16*(use)+32*(texlerp)) + +#define STBVOX_MAKE_LIGHTING_EXT(lighting, rot) (((lighting)&~3)+(rot)) +#define STBVOX_MAKE_LIGHTING(lighting) (lighting) + +#ifndef STBVOX_MAX_MESHES +#define STBVOX_MAX_MESHES 2 // opaque & transparent +#endif + +#define STBVOX_MAX_MESH_SLOTS 3 // one vertex & two faces, or two vertex and one face + + +// don't mess with this directly, it's just here so you can +// declare stbvox_mesh_maker on the stack or as a global +struct stbvox_mesh_maker +{ + stbvox_input_description input; + int cur_x, cur_y, cur_z; // last unprocessed voxel if it splits into multiple buffers + int x0,y0,z0,x1,y1,z1; + int x_stride_in_bytes; + int y_stride_in_bytes; + int config_dirty; + int default_mesh; + unsigned int tags; + + int cube_vertex_offset[6][4]; // this allows access per-vertex data stored block-centered (like texlerp, ambient) + int vertex_gather_offset[6][4]; + + int pos_x,pos_y,pos_z; + int full; + + // computed from user input + char *output_cur [STBVOX_MAX_MESHES][STBVOX_MAX_MESH_SLOTS]; + char *output_end [STBVOX_MAX_MESHES][STBVOX_MAX_MESH_SLOTS]; + char *output_buffer[STBVOX_MAX_MESHES][STBVOX_MAX_MESH_SLOTS]; + int output_len [STBVOX_MAX_MESHES][STBVOX_MAX_MESH_SLOTS]; + + // computed from config + int output_size [STBVOX_MAX_MESHES][STBVOX_MAX_MESH_SLOTS]; // per quad + int output_step [STBVOX_MAX_MESHES][STBVOX_MAX_MESH_SLOTS]; // per vertex or per face, depending + int num_mesh_slots; + + float default_tex_scale[128][2]; +}; + +#endif // INCLUDE_STB_VOXEL_RENDER_H + + +#ifdef STB_VOXEL_RENDER_IMPLEMENTATION + +#include +#include +#include // memset + +// have to use our own names to avoid the _MSC_VER path having conflicting type names +#ifndef _MSC_VER + #include + typedef uint16_t stbvox_uint16; + typedef uint32_t stbvox_uint32; +#else + typedef unsigned short stbvox_uint16; + typedef unsigned int stbvox_uint32; +#endif + +#ifdef _MSC_VER + #define STBVOX_NOTUSED(v) (void)(v) +#else + #define STBVOX_NOTUSED(v) (void)sizeof(v) +#endif + + + +#ifndef STBVOX_CONFIG_MODE +#error "Must defined STBVOX_CONFIG_MODE to select the mode" +#endif + +#if defined(STBVOX_CONFIG_ROTATION_IN_LIGHTING) && defined(STBVOX_CONFIG_VHEIGHT_IN_LIGHTING) +#error "Can't store both rotation and vheight in lighting" +#endif + + +// The following are candidate voxel modes. Only modes 0, 1, and 20, and 21 are +// currently implemented. Reducing the storage-per-quad further +// shouldn't improve performance, although obviously it allow you +// to create larger worlds without streaming. +// +// +// ----------- Two textures ----------- -- One texture -- ---- Color only ---- +// Mode: 0 1 2 3 4 5 6 10 11 12 20 21 22 23 24 +// ============================================================================================================ +// uses Tex Buffer n Y Y Y Y Y Y Y Y Y n Y Y Y Y +// bytes per quad 32 20 14 12 10 6 6 8 8 4 32 20 10 6 4 +// non-blocks all all some some some slabs stairs some some none all all slabs slabs none +// tex1 256 256 256 256 256 256 256 256 256 256 n n n n n +// tex2 256 256 256 256 256 256 128 n n n n n n n n +// colors 64 64 64 64 64 64 64 8 n n 2^24 2^24 2^24 2^24 256 +// vertex ao Y Y Y Y Y n n Y Y n Y Y Y n n +// vertex texlerp Y Y Y n n n n - - - - - - - - +// x&y extents 127 127 128 64 64 128 64 64 128 128 127 127 128 128 128 +// z extents 255 255 128 64? 64? 64 64 32 64 128 255 255 128 64 128 + +// not sure why I only wrote down the above "result data" and didn't preserve +// the vertex formats, but here I've tried to reconstruct the designs... +// mode # 3 is wrong, one byte too large, but they may have been an error originally + +// Mode: 0 1 2 3 4 5 6 10 11 12 20 21 22 23 24 +// ============================================================================================================= +// bytes per quad 32 20 14 12 10 6 6 8 8 4 20 10 6 4 +// +// vertex x bits 7 7 0 6 0 0 0 0 0 0 7 0 0 0 +// vertex y bits 7 7 0 0 0 0 0 0 0 0 7 0 0 0 +// vertex z bits 9 9 7 4 2 0 0 2 2 0 9 2 0 0 +// vertex ao bits 6 6 6 6 6 0 0 6 6 0 6 6 0 0 +// vertex txl bits 3 3 3 0 0 0 0 0 0 0 (3) 0 0 0 +// +// face tex1 bits (8) 8 8 8 8 8 8 8 8 8 +// face tex2 bits (8) 8 8 8 8 8 7 - - - +// face color bits (8) 8 8 8 8 8 8 3 0 0 24 24 24 8 +// face normal bits (8) 8 8 8 6 4 7 4 4 3 8 3 4 3 +// face x bits 7 0 6 7 6 6 7 7 0 7 7 7 +// face y bits 7 6 6 7 6 6 7 7 0 7 7 7 +// face z bits 2 2 6 6 6 5 6 7 0 7 6 7 + + +#if STBVOX_CONFIG_MODE==0 || STBVOX_CONFIG_MODE==1 + + #define STBVOX_ICONFIG_VERTEX_32 + #define STBVOX_ICONFIG_FACE1_1 + +#elif STBVOX_CONFIG_MODE==20 || STBVOX_CONFIG_MODE==21 + + #define STBVOX_ICONFIG_VERTEX_32 + #define STBVOX_ICONFIG_FACE1_1 + #define STBVOX_ICONFIG_UNTEXTURED + +#else +#error "Selected value of STBVOX_CONFIG_MODE is not supported" +#endif + +#if STBVOX_CONFIG_MODE==0 || STBVOX_CONFIG_MODE==20 +#define STBVOX_ICONFIG_FACE_ATTRIBUTE +#endif + +#ifndef STBVOX_CONFIG_HLSL +// the fallback if all others are exhausted is GLSL +#define STBVOX_ICONFIG_GLSL +#endif + +#ifdef STBVOX_CONFIG_OPENGL_MODELVIEW +#define STBVOX_ICONFIG_OPENGL_3_1_COMPATIBILITY +#endif + +#if defined(STBVOX_ICONFIG_VERTEX_32) + typedef stbvox_uint32 stbvox_mesh_vertex; + #define stbvox_vertex_encode(x,y,z,ao,texlerp) \ + ((stbvox_uint32) ((x)+((y)<<7)+((z)<<14)+((ao)<<23)+((texlerp)<<29))) +#elif defined(STBVOX_ICONFIG_VERTEX_16_1) // mode=2 + typedef stbvox_uint16 stbvox_mesh_vertex; + #define stbvox_vertex_encode(x,y,z,ao,texlerp) \ + ((stbvox_uint16) ((z)+((ao)<<7)+((texlerp)<<13) +#elif defined(STBVOX_ICONFIG_VERTEX_16_2) // mode=3 + typedef stbvox_uint16 stbvox_mesh_vertex; + #define stbvox_vertex_encode(x,y,z,ao,texlerp) \ + ((stbvox_uint16) ((x)+((z)<<6))+((ao)<<10)) +#elif defined(STBVOX_ICONFIG_VERTEX_8) + typedef stbvox_uint8 stbvox_mesh_vertex; + #define stbvox_vertex_encode(x,y,z,ao,texlerp) \ + ((stbvox_uint8) ((z)+((ao)<<6)) +#else + #error "internal error, no vertex type" +#endif + +#ifdef STBVOX_ICONFIG_FACE1_1 + typedef struct + { + unsigned char tex1,tex2,color,face_info; + } stbvox_mesh_face; +#else + #error "internal error, no face type" +#endif + + +// 20-byte quad format: +// +// per vertex: +// +// x:7 +// y:7 +// z:9 +// ao:6 +// tex_lerp:3 +// +// per face: +// +// tex1:8 +// tex2:8 +// face:8 +// color:8 + + +// Faces: +// +// Faces use the bottom 3 bits to choose the texgen +// mode, and all the bits to choose the normal. +// Thus the bottom 3 bits have to be: +// e, n, w, s, u, d, u, d +// +// These use compact names so tables are readable + +enum +{ + STBVF_e, + STBVF_n, + STBVF_w, + STBVF_s, + STBVF_u, + STBVF_d, + STBVF_eu, + STBVF_ed, + + STBVF_eu_wall, + STBVF_nu_wall, + STBVF_wu_wall, + STBVF_su_wall, + STBVF_ne_u, + STBVF_ne_d, + STBVF_nu, + STBVF_nd, + + STBVF_ed_wall, + STBVF_nd_wall, + STBVF_wd_wall, + STBVF_sd_wall, + STBVF_nw_u, + STBVF_nw_d, + STBVF_wu, + STBVF_wd, + + STBVF_ne_u_cross, + STBVF_nw_u_cross, + STBVF_sw_u_cross, + STBVF_se_u_cross, + STBVF_sw_u, + STBVF_sw_d, + STBVF_su, + STBVF_sd, + + // @TODO we need more than 5 bits to encode the normal to fit the following + // so for now we use the right projection but the wrong normal + STBVF_se_u = STBVF_su, + STBVF_se_d = STBVF_sd, + + STBVF_count, +}; + +///////////////////////////////////////////////////////////////////////////// +// +// tables -- i'd prefer if these were at the end of the file, but: C++ +// + +static float stbvox_default_texgen[2][32][3] = +{ + { { 0, 1,0 }, { 0, 0, 1 }, { 0,-1,0 }, { 0, 0,-1 }, + { -1, 0,0 }, { 0, 0, 1 }, { 1, 0,0 }, { 0, 0,-1 }, + { 0,-1,0 }, { 0, 0, 1 }, { 0, 1,0 }, { 0, 0,-1 }, + { 1, 0,0 }, { 0, 0, 1 }, { -1, 0,0 }, { 0, 0,-1 }, + + { 1, 0,0 }, { 0, 1, 0 }, { -1, 0,0 }, { 0,-1, 0 }, + { -1, 0,0 }, { 0,-1, 0 }, { 1, 0,0 }, { 0, 1, 0 }, + { 1, 0,0 }, { 0, 1, 0 }, { -1, 0,0 }, { 0,-1, 0 }, + { -1, 0,0 }, { 0,-1, 0 }, { 1, 0,0 }, { 0, 1, 0 }, + }, + { { 0, 0,-1 }, { 0, 1,0 }, { 0, 0, 1 }, { 0,-1,0 }, + { 0, 0,-1 }, { -1, 0,0 }, { 0, 0, 1 }, { 1, 0,0 }, + { 0, 0,-1 }, { 0,-1,0 }, { 0, 0, 1 }, { 0, 1,0 }, + { 0, 0,-1 }, { 1, 0,0 }, { 0, 0, 1 }, { -1, 0,0 }, + + { 0,-1, 0 }, { 1, 0,0 }, { 0, 1, 0 }, { -1, 0,0 }, + { 0, 1, 0 }, { -1, 0,0 }, { 0,-1, 0 }, { 1, 0,0 }, + { 0,-1, 0 }, { 1, 0,0 }, { 0, 1, 0 }, { -1, 0,0 }, + { 0, 1, 0 }, { -1, 0,0 }, { 0,-1, 0 }, { 1, 0,0 }, + }, +}; + +#define STBVOX_RSQRT2 0.7071067811865f +#define STBVOX_RSQRT3 0.5773502691896f + +static float stbvox_default_normals[32][3] = +{ + { 1,0,0 }, // east + { 0,1,0 }, // north + { -1,0,0 }, // west + { 0,-1,0 }, // south + { 0,0,1 }, // up + { 0,0,-1 }, // down + { STBVOX_RSQRT2,0, STBVOX_RSQRT2 }, // east & up + { STBVOX_RSQRT2,0, -STBVOX_RSQRT2 }, // east & down + + { STBVOX_RSQRT2,0, STBVOX_RSQRT2 }, // east & up + { 0, STBVOX_RSQRT2, STBVOX_RSQRT2 }, // north & up + { -STBVOX_RSQRT2,0, STBVOX_RSQRT2 }, // west & up + { 0,-STBVOX_RSQRT2, STBVOX_RSQRT2 }, // south & up + { STBVOX_RSQRT3, STBVOX_RSQRT3, STBVOX_RSQRT3 }, // ne & up + { STBVOX_RSQRT3, STBVOX_RSQRT3,-STBVOX_RSQRT3 }, // ne & down + { 0, STBVOX_RSQRT2, STBVOX_RSQRT2 }, // north & up + { 0, STBVOX_RSQRT2, -STBVOX_RSQRT2 }, // north & down + + { STBVOX_RSQRT2,0, -STBVOX_RSQRT2 }, // east & down + { 0, STBVOX_RSQRT2, -STBVOX_RSQRT2 }, // north & down + { -STBVOX_RSQRT2,0, -STBVOX_RSQRT2 }, // west & down + { 0,-STBVOX_RSQRT2, -STBVOX_RSQRT2 }, // south & down + { -STBVOX_RSQRT3, STBVOX_RSQRT3, STBVOX_RSQRT3 }, // NW & up + { -STBVOX_RSQRT3, STBVOX_RSQRT3,-STBVOX_RSQRT3 }, // NW & down + { -STBVOX_RSQRT2,0, STBVOX_RSQRT2 }, // west & up + { -STBVOX_RSQRT2,0, -STBVOX_RSQRT2 }, // west & down + + { STBVOX_RSQRT3, STBVOX_RSQRT3,STBVOX_RSQRT3 }, // NE & up crossed + { -STBVOX_RSQRT3, STBVOX_RSQRT3,STBVOX_RSQRT3 }, // NW & up crossed + { -STBVOX_RSQRT3,-STBVOX_RSQRT3,STBVOX_RSQRT3 }, // SW & up crossed + { STBVOX_RSQRT3,-STBVOX_RSQRT3,STBVOX_RSQRT3 }, // SE & up crossed + { -STBVOX_RSQRT3,-STBVOX_RSQRT3, STBVOX_RSQRT3 }, // SW & up + { -STBVOX_RSQRT3,-STBVOX_RSQRT3,-STBVOX_RSQRT3 }, // SW & up + { 0,-STBVOX_RSQRT2, STBVOX_RSQRT2 }, // south & up + { 0,-STBVOX_RSQRT2, -STBVOX_RSQRT2 }, // south & down +}; + +static float stbvox_default_texscale[128][4] = +{ + {1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0}, + {1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0}, + {1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0}, + {1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0}, + {1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0}, + {1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0}, + {1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0}, + {1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0}, + {1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0}, + {1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0}, + {1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0}, + {1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0}, + {1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0}, + {1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0}, + {1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0}, + {1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0},{1,1,0,0}, +}; + +static unsigned char stbvox_default_palette_compact[64][3] = +{ + { 255,255,255 }, { 238,238,238 }, { 221,221,221 }, { 204,204,204 }, + { 187,187,187 }, { 170,170,170 }, { 153,153,153 }, { 136,136,136 }, + { 119,119,119 }, { 102,102,102 }, { 85, 85, 85 }, { 68, 68, 68 }, + { 51, 51, 51 }, { 34, 34, 34 }, { 17, 17, 17 }, { 0, 0, 0 }, + { 255,240,240 }, { 255,220,220 }, { 255,160,160 }, { 255, 32, 32 }, + { 200,120,160 }, { 200, 60,150 }, { 220,100,130 }, { 255, 0,128 }, + { 240,240,255 }, { 220,220,255 }, { 160,160,255 }, { 32, 32,255 }, + { 120,160,200 }, { 60,150,200 }, { 100,130,220 }, { 0,128,255 }, + { 240,255,240 }, { 220,255,220 }, { 160,255,160 }, { 32,255, 32 }, + { 160,200,120 }, { 150,200, 60 }, { 130,220,100 }, { 128,255, 0 }, + { 255,255,240 }, { 255,255,220 }, { 220,220,180 }, { 255,255, 32 }, + { 200,160,120 }, { 200,150, 60 }, { 220,130,100 }, { 255,128, 0 }, + { 255,240,255 }, { 255,220,255 }, { 220,180,220 }, { 255, 32,255 }, + { 160,120,200 }, { 150, 60,200 }, { 130,100,220 }, { 128, 0,255 }, + { 240,255,255 }, { 220,255,255 }, { 180,220,220 }, { 32,255,255 }, + { 120,200,160 }, { 60,200,150 }, { 100,220,130 }, { 0,255,128 }, +}; + +static float stbvox_default_ambient[4][4] = +{ + { 0,0,1 ,0 }, // reversed lighting direction + { 0.5,0.5,0.5,0 }, // directional color + { 0.5,0.5,0.5,0 }, // constant color + { 0.5,0.5,0.5,1.0f/1000.0f/1000.0f }, // fog data for simple_fog +}; + +static float stbvox_default_palette[64][4]; + +static void stbvox_build_default_palette(void) +{ + int i; + for (i=0; i < 64; ++i) { + stbvox_default_palette[i][0] = stbvox_default_palette_compact[i][0] / 255.0f; + stbvox_default_palette[i][1] = stbvox_default_palette_compact[i][1] / 255.0f; + stbvox_default_palette[i][2] = stbvox_default_palette_compact[i][2] / 255.0f; + stbvox_default_palette[i][3] = 1.0f; + } +} + +////////////////////////////////////////////////////////////////////////////// +// +// Shaders +// + +#if defined(STBVOX_ICONFIG_OPENGL_3_1_COMPATIBILITY) + #define STBVOX_SHADER_VERSION "#version 150 compatibility\n" +#elif defined(STBVOX_ICONFIG_OPENGL_3_0) + #define STBVOX_SHADER_VERSION "#version 130\n" +#elif defined(STBVOX_ICONFIG_GLSL) + #define STBVOX_SHADER_VERSION "#version 150\n" +#else + #define STBVOX_SHADER_VERSION "" +#endif + +static const char *stbvox_vertex_program = +{ + STBVOX_SHADER_VERSION + + #ifdef STBVOX_ICONFIG_FACE_ATTRIBUTE // NOT TAG_face_sampled + "in uvec4 attr_face;\n" + #else + "uniform usamplerBuffer facearray;\n" + #endif + + #ifdef STBVOX_ICONFIG_FACE_ARRAY_2 + "uniform usamplerBuffer facearray2;\n" + #endif + + // vertex input data + "in uint attr_vertex;\n" + + // per-buffer data + "uniform vec3 transform[3];\n" + + // per-frame data + "uniform vec4 camera_pos;\n" // 4th value is used for arbitrary hacking + + // to simplify things, we avoid using more than 256 uniform vectors + // in fragment shader to avoid possible 1024 component limit, so + // we access this table in the fragment shader. + "uniform vec3 normal_table[32];\n" + + #ifndef STBVOX_CONFIG_OPENGL_MODELVIEW + "uniform mat4x4 model_view;\n" + #endif + + // fragment output data + "flat out uvec4 facedata;\n" + " out vec3 voxelspace_pos;\n" + " out vec3 vnormal;\n" + " out float texlerp;\n" + " out float amb_occ;\n" + + // @TODO handle the HLSL way to do this + "void main()\n" + "{\n" + #ifdef STBVOX_ICONFIG_FACE_ATTRIBUTE + " facedata = attr_face;\n" + #else + " int faceID = gl_VertexID >> 2;\n" + " facedata = texelFetch(facearray, faceID);\n" + #endif + + // extract data for vertex + " vec3 offset;\n" + " offset.x = float( (attr_vertex ) & 127u );\n" // a[0..6] + " offset.y = float( (attr_vertex >> 7u) & 127u );\n" // a[7..13] + " offset.z = float( (attr_vertex >> 14u) & 511u );\n" // a[14..22] + " amb_occ = float( (attr_vertex >> 23u) & 63u ) / 63.0;\n" // a[23..28] + " texlerp = float( (attr_vertex >> 29u) ) / 7.0;\n" // a[29..31] + + " vnormal = normal_table[(facedata.w>>2u) & 31u];\n" + " voxelspace_pos = offset * transform[0];\n" // mesh-to-object scale + " vec3 position = voxelspace_pos + transform[1];\n" // mesh-to-object translate + + #ifdef STBVOX_DEBUG_TEST_NORMALS + " if ((facedata.w & 28u) == 16u || (facedata.w & 28u) == 24u)\n" + " position += vnormal.xyz * camera_pos.w;\n" + #endif + + #ifndef STBVOX_CONFIG_OPENGL_MODELVIEW + " gl_Position = model_view * vec4(position,1.0);\n" + #else + " gl_Position = gl_ModelViewProjectionMatrix * vec4(position,1.0);\n" + #endif + + "}\n" +}; + + +static const char *stbvox_fragment_program = +{ + STBVOX_SHADER_VERSION + + // rlerp is lerp but with t on the left, like god intended + #if defined(STBVOX_ICONFIG_GLSL) + "#define rlerp(t,x,y) mix(x,y,t)\n" + #elif defined(STBVOX_CONFIG_HLSL) + "#define rlerp(t,x,y) lerp(x,y,t)\n" + #else + #error "need definition of rlerp()" + #endif + + + // vertex-shader output data + "flat in uvec4 facedata;\n" + " in vec3 voxelspace_pos;\n" + " in vec3 vnormal;\n" + " in float texlerp;\n" + " in float amb_occ;\n" + + // per-buffer data + "uniform vec3 transform[3];\n" + + // per-frame data + "uniform vec4 camera_pos;\n" // 4th value is used for arbitrary hacking + + // probably constant data + "uniform vec4 ambient[4];\n" + + #ifndef STBVOX_ICONFIG_UNTEXTURED + // generally constant data + "uniform sampler2DArray tex_array[2];\n" + + #ifdef STBVOX_CONFIG_PREFER_TEXBUFFER + "uniform samplerBuffer color_table;\n" + "uniform samplerBuffer texscale;\n" + "uniform samplerBuffer texgen;\n" + #else + "uniform vec4 color_table[64];\n" + "uniform vec4 texscale[64];\n" // instead of 128, to avoid running out of uniforms + "uniform vec3 texgen[64];\n" + #endif + #endif + + "out vec4 outcolor;\n" + + #if defined(STBVOX_CONFIG_LIGHTING) || defined(STBVOX_CONFIG_LIGHTING_SIMPLE) + "vec3 compute_lighting(vec3 pos, vec3 norm, vec3 albedo, vec3 ambient);\n" + #endif + #if defined(STBVOX_CONFIG_FOG) || defined(STBVOX_CONFIG_FOG_SMOOTHSTEP) + "vec3 compute_fog(vec3 color, vec3 relative_pos, float fragment_alpha);\n" + #endif + + "void main()\n" + "{\n" + " vec3 albedo;\n" + " float fragment_alpha;\n" + + #ifndef STBVOX_ICONFIG_UNTEXTURED + // unpack the values + " uint tex1_id = facedata.x;\n" + " uint tex2_id = facedata.y;\n" + " uint texprojid = facedata.w & 31u;\n" + " uint color_id = facedata.z;\n" + + #ifndef STBVOX_CONFIG_PREFER_TEXBUFFER + // load from uniforms / texture buffers + " vec3 texgen_s = texgen[texprojid];\n" + " vec3 texgen_t = texgen[texprojid+32u];\n" + " float tex1_scale = texscale[tex1_id & 63u].x;\n" + " vec4 color = color_table[color_id & 63u];\n" + #ifndef STBVOX_CONFIG_DISABLE_TEX2 + " vec4 tex2_props = texscale[tex2_id & 63u];\n" + #endif + #else + " vec3 texgen_s = texelFetch(texgen, int(texprojid)).xyz;\n" + " vec3 texgen_t = texelFetch(texgen, int(texprojid+32u)).xyz;\n" + " float tex1_scale = texelFetch(texscale, int(tex1_id & 127u)).x;\n" + " vec4 color = texelFetch(color_table, int(color_id & 63u));\n" + #ifndef STBVOX_CONFIG_DISABLE_TEX2 + " vec4 tex2_props = texelFetch(texscale, int(tex1_id & 127u));\n" + #endif + #endif + + #ifndef STBVOX_CONFIG_DISABLE_TEX2 + " float tex2_scale = tex2_props.y;\n" + " bool texblend_mode = tex2_props.z != 0.0;\n" + #endif + " vec2 texcoord;\n" + " vec3 texturespace_pos = voxelspace_pos + transform[2].xyz;\n" + " texcoord.s = dot(texturespace_pos, texgen_s);\n" + " texcoord.t = dot(texturespace_pos, texgen_t);\n" + + " vec2 texcoord_1 = tex1_scale * texcoord;\n" + #ifndef STBVOX_CONFIG_DISABLE_TEX2 + " vec2 texcoord_2 = tex2_scale * texcoord;\n" + #endif + + #ifdef STBVOX_CONFIG_TEX1_EDGE_CLAMP + " texcoord_1 = texcoord_1 - floor(texcoord_1);\n" + " vec4 tex1 = textureGrad(tex_array[0], vec3(texcoord_1, float(tex1_id)), dFdx(tex1_scale*texcoord), dFdy(tex1_scale*texcoord));\n" + #else + " vec4 tex1 = texture(tex_array[0], vec3(texcoord_1, float(tex1_id)));\n" + #endif + + #ifndef STBVOX_CONFIG_DISABLE_TEX2 + #ifdef STBVOX_CONFIG_TEX2_EDGE_CLAMP + " texcoord_2 = texcoord_2 - floor(texcoord_2);\n" + " vec4 tex2 = textureGrad(tex_array[0], vec3(texcoord_2, float(tex2_id)), dFdx(tex2_scale*texcoord), dFdy(tex2_scale*texcoord));\n" + #else + " vec4 tex2 = texture(tex_array[1], vec3(texcoord_2, float(tex2_id)));\n" + #endif + #endif + + " bool emissive = (color.a > 1.0);\n" + " color.a = min(color.a, 1.0);\n" + + // recolor textures + " if ((color_id & 64u) != 0u) tex1.rgba *= color.rgba;\n" + " fragment_alpha = tex1.a;\n" + #ifndef STBVOX_CONFIG_DISABLE_TEX2 + " if ((color_id & 128u) != 0u) tex2.rgba *= color.rgba;\n" + + #ifdef STBVOX_CONFIG_PREMULTIPLIED_ALPHA + " tex2.rgba *= texlerp;\n" + #else + " tex2.a *= texlerp;\n" + #endif + + " if (texblend_mode)\n" + " albedo = tex1.xyz * rlerp(tex2.a, vec3(1.0,1.0,1.0), 2.0*tex2.xyz);\n" + " else {\n" + #ifdef STBVOX_CONFIG_PREMULTIPLIED_ALPHA + " albedo = (1.0-tex2.a)*tex1.xyz + tex2.xyz;\n" + #else + " albedo = rlerp(tex2.a, tex1.xyz, tex2.xyz);\n" + #endif + " fragment_alpha = tex1.a*(1-tex2.a)+tex2.a;\n" + " }\n" + #else + " albedo = tex1.xyz;\n" + #endif + + #else // UNTEXTURED + " vec4 color;" + " color.xyz = vec3(facedata.xyz) / 255.0;\n" + " bool emissive = false;\n" + " albedo = color.xyz;\n" + " fragment_alpha = 1.0;\n" + #endif + + #ifdef STBVOX_ICONFIG_VARYING_VERTEX_NORMALS + // currently, there are no modes that trigger this path; idea is that there + // could be a couple of bits per vertex to perturb the normal to e.g. get curved look + " vec3 normal = normalize(vnormal);\n" + #else + " vec3 normal = vnormal;\n" + #endif + + " vec3 ambient_color = dot(normal, ambient[0].xyz) * ambient[1].xyz + ambient[2].xyz;\n" + + " ambient_color = clamp(ambient_color, 0.0, 1.0);" + " ambient_color *= amb_occ;\n" + + " vec3 lit_color;\n" + " if (!emissive)\n" + #if defined(STBVOX_ICONFIG_LIGHTING) || defined(STBVOX_CONFIG_LIGHTING_SIMPLE) + " lit_color = compute_lighting(voxelspace_pos + transform[1], normal, albedo, ambient_color);\n" + #else + " lit_color = albedo * ambient_color ;\n" + #endif + " else\n" + " lit_color = albedo;\n" + + #if defined(STBVOX_ICONFIG_FOG) || defined(STBVOX_CONFIG_FOG_SMOOTHSTEP) + " vec3 dist = voxelspace_pos + (transform[1] - camera_pos.xyz);\n" + " lit_color = compute_fog(lit_color, dist, fragment_alpha);\n" + #endif + + #ifdef STBVOX_CONFIG_UNPREMULTIPLY + " vec4 final_color = vec4(lit_color/fragment_alpha, fragment_alpha);\n" + #else + " vec4 final_color = vec4(lit_color, fragment_alpha);\n" + #endif + " outcolor = final_color;\n" + "}\n" + + #ifdef STBVOX_CONFIG_LIGHTING_SIMPLE + "\n" + "uniform vec3 light_source[2];\n" + "vec3 compute_lighting(vec3 pos, vec3 norm, vec3 albedo, vec3 ambient)\n" + "{\n" + " vec3 light_dir = light_source[0] - pos;\n" + " float lambert = dot(light_dir, norm) / dot(light_dir, light_dir);\n" + " vec3 diffuse = clamp(light_source[1] * clamp(lambert, 0.0, 1.0), 0.0, 1.0);\n" + " return (diffuse + ambient) * albedo;\n" + "}\n" + #endif + + #ifdef STBVOX_CONFIG_FOG_SMOOTHSTEP + "\n" + "vec3 compute_fog(vec3 color, vec3 relative_pos, float fragment_alpha)\n" + "{\n" + " float f = dot(relative_pos,relative_pos)*ambient[3].w;\n" + //" f = rlerp(f, -2,1);\n" + " f = clamp(f, 0.0, 1.0);\n" + " f = 3.0*f*f - 2.0*f*f*f;\n" // smoothstep + //" f = f*f;\n" // fade in more smoothly + #ifdef STBVOX_CONFIG_PREMULTIPLIED_ALPHA + " return rlerp(f, color.xyz, ambient[3].xyz*fragment_alpha);\n" + #else + " return rlerp(f, color.xyz, ambient[3].xyz);\n" + #endif + "}\n" + #endif +}; + + +// still requires full alpha lookups, including tex2 if texblend is enabled +static const char *stbvox_fragment_program_alpha_only = +{ + STBVOX_SHADER_VERSION + + // vertex-shader output data + "flat in uvec4 facedata;\n" + " in vec3 voxelspace_pos;\n" + " in float texlerp;\n" + + // per-buffer data + "uniform vec3 transform[3];\n" + + #ifndef STBVOX_ICONFIG_UNTEXTURED + // generally constant data + "uniform sampler2DArray tex_array[2];\n" + + #ifdef STBVOX_CONFIG_PREFER_TEXBUFFER + "uniform samplerBuffer texscale;\n" + "uniform samplerBuffer texgen;\n" + #else + "uniform vec4 texscale[64];\n" // instead of 128, to avoid running out of uniforms + "uniform vec3 texgen[64];\n" + #endif + #endif + + "out vec4 outcolor;\n" + + "void main()\n" + "{\n" + " vec3 albedo;\n" + " float fragment_alpha;\n" + + #ifndef STBVOX_ICONFIG_UNTEXTURED + // unpack the values + " uint tex1_id = facedata.x;\n" + " uint tex2_id = facedata.y;\n" + " uint texprojid = facedata.w & 31u;\n" + " uint color_id = facedata.z;\n" + + #ifndef STBVOX_CONFIG_PREFER_TEXBUFFER + // load from uniforms / texture buffers + " vec3 texgen_s = texgen[texprojid];\n" + " vec3 texgen_t = texgen[texprojid+32u];\n" + " float tex1_scale = texscale[tex1_id & 63u].x;\n" + " vec4 color = color_table[color_id & 63u];\n" + " vec4 tex2_props = texscale[tex2_id & 63u];\n" + #else + " vec3 texgen_s = texelFetch(texgen, int(texprojid)).xyz;\n" + " vec3 texgen_t = texelFetch(texgen, int(texprojid+32u)).xyz;\n" + " float tex1_scale = texelFetch(texscale, int(tex1_id & 127u)).x;\n" + " vec4 color = texelFetch(color_table, int(color_id & 63u));\n" + " vec4 tex2_props = texelFetch(texscale, int(tex2_id & 127u));\n" + #endif + + #ifndef STBVOX_CONFIG_DISABLE_TEX2 + " float tex2_scale = tex2_props.y;\n" + " bool texblend_mode = tex2_props.z &((facedata.w & 128u) != 0u);\n" + #endif + + " color.a = min(color.a, 1.0);\n" + + " vec2 texcoord;\n" + " vec3 texturespace_pos = voxelspace_pos + transform[2].xyz;\n" + " texcoord.s = dot(texturespace_pos, texgen_s);\n" + " texcoord.t = dot(texturespace_pos, texgen_t);\n" + + " vec2 texcoord_1 = tex1_scale * texcoord;\n" + " vec2 texcoord_2 = tex2_scale * texcoord;\n" + + #ifdef STBVOX_CONFIG_TEX1_EDGE_CLAMP + " texcoord_1 = texcoord_1 - floor(texcoord_1);\n" + " vec4 tex1 = textureGrad(tex_array[0], vec3(texcoord_1, float(tex1_id)), dFdx(tex1_scale*texcoord), dFdy(tex1_scale*texcoord));\n" + #else + " vec4 tex1 = texture(tex_array[0], vec3(texcoord_1, float(tex1_id)));\n" + #endif + + " if ((color_id & 64u) != 0u) tex1.a *= color.a;\n" + " fragment_alpha = tex1.a;\n" + + #ifndef STBVOX_CONFIG_DISABLE_TEX2 + " if (!texblend_mode) {\n" + #ifdef STBVOX_CONFIG_TEX2_EDGE_CLAMP + " texcoord_2 = texcoord_2 - floor(texcoord_2);\n" + " vec4 tex2 = textureGrad(tex_array[0], vec3(texcoord_2, float(tex2_id)), dFdx(tex2_scale*texcoord), dFdy(tex2_scale*texcoord));\n" + #else + " vec4 tex2 = texture(tex_array[1], vec3(texcoord_2, float(tex2_id)));\n" + #endif + + " tex2.a *= texlerp;\n" + " if ((color_id & 128u) != 0u) tex2.rgba *= color.a;\n" + " fragment_alpha = tex1.a*(1-tex2.a)+tex2.a;\n" + "}\n" + "\n" + #endif + + #else // UNTEXTURED + " fragment_alpha = 1.0;\n" + #endif + + " outcolor = vec4(0.0, 0.0, 0.0, fragment_alpha);\n" + "}\n" +}; + + +STBVXDEC char *stbvox_get_vertex_shader(void) +{ + return (char *) stbvox_vertex_program; +} + +STBVXDEC char *stbvox_get_fragment_shader(void) +{ + return (char *) stbvox_fragment_program; +} + +STBVXDEC char *stbvox_get_fragment_shader_alpha_only(void) +{ + return (char *) stbvox_fragment_program_alpha_only; +} + +static float stbvox_dummy_transform[3][3]; + +#ifdef STBVOX_CONFIG_PREFER_TEXBUFFER +#define STBVOX_TEXBUF 1 +#else +#define STBVOX_TEXBUF 0 +#endif + +static stbvox_uniform_info stbvox_uniforms[] = +{ + { STBVOX_UNIFORM_TYPE_sampler , 4, 1, (char*) "facearray" , 0 }, + { STBVOX_UNIFORM_TYPE_vec3 , 12, 3, (char*) "transform" , stbvox_dummy_transform[0] }, + { STBVOX_UNIFORM_TYPE_sampler , 4, 2, (char*) "tex_array" , 0 }, + { STBVOX_UNIFORM_TYPE_vec4 , 16, 128, (char*) "texscale" , stbvox_default_texscale[0] , STBVOX_TEXBUF }, + { STBVOX_UNIFORM_TYPE_vec4 , 16, 64, (char*) "color_table" , stbvox_default_palette[0] , STBVOX_TEXBUF }, + { STBVOX_UNIFORM_TYPE_vec3 , 12, 32, (char*) "normal_table" , stbvox_default_normals[0] }, + { STBVOX_UNIFORM_TYPE_vec3 , 12, 64, (char*) "texgen" , stbvox_default_texgen[0][0], STBVOX_TEXBUF }, + { STBVOX_UNIFORM_TYPE_vec4 , 16, 4, (char*) "ambient" , stbvox_default_ambient[0] }, + { STBVOX_UNIFORM_TYPE_vec4 , 16, 1, (char*) "camera_pos" , stbvox_dummy_transform[0] }, +}; + +STBVXDEC int stbvox_get_uniform_info(stbvox_uniform_info *info, int uniform) +{ + if (uniform < 0 || uniform >= STBVOX_UNIFORM_count) + return 0; + + *info = stbvox_uniforms[uniform]; + return 1; +} + +#define STBVOX_GET_GEO(geom_data) ((geom_data) & 15) + +typedef struct +{ + unsigned char block:2; + unsigned char overlay:2; + unsigned char facerot:2; + unsigned char ecolor:2; +} stbvox_rotate; + +typedef struct +{ + unsigned char x,y,z; +} stbvox_pos; + +static unsigned char stbvox_rotate_face[6][4] = +{ + { 0,1,2,3 }, + { 1,2,3,0 }, + { 2,3,0,1 }, + { 3,0,1,2 }, + { 4,4,4,4 }, + { 5,5,5,5 }, +}; + +#define STBVOX_ROTATE(x,r) stbvox_rotate_face[x][r] // (((x)+(r))&3) + +stbvox_mesh_face stbvox_compute_mesh_face_value(stbvox_mesh_maker *mm, stbvox_rotate rot, int face, int v_off, int normal) +{ + stbvox_mesh_face face_data = { 0 }; + stbvox_block_type bt = mm->input.blocktype[v_off]; + unsigned char bt_face = STBVOX_ROTATE(face, rot.block); + int facerot = rot.facerot; + + #ifdef STBVOX_ICONFIG_UNTEXTURED + if (mm->input.rgb) { + face_data.tex1 = mm->input.rgb[v_off].r; + face_data.tex2 = mm->input.rgb[v_off].g; + face_data.color = mm->input.rgb[v_off].b; + face_data.face_info = (normal<<2); + return face_data; + } + #else + unsigned char color_face; + + if (mm->input.color) + face_data.color = mm->input.color[v_off]; + + if (mm->input.block_tex1) + face_data.tex1 = mm->input.block_tex1[bt]; + else if (mm->input.block_tex1_face) + face_data.tex1 = mm->input.block_tex1_face[bt][bt_face]; + else + face_data.tex1 = bt; + + if (mm->input.block_tex2) + face_data.tex2 = mm->input.block_tex2[bt]; + else if (mm->input.block_tex2_face) + face_data.tex2 = mm->input.block_tex2_face[bt][bt_face]; + + if (mm->input.block_color) { + unsigned char mcol = mm->input.block_color[bt]; + if (mcol) + face_data.color = mcol; + } else if (mm->input.block_color_face) { + unsigned char mcol = mm->input.block_color_face[bt][bt_face]; + if (mcol) + face_data.color = mcol; + } + + if (face <= STBVOX_FACE_south) { + if (mm->input.side_texrot) + facerot = mm->input.side_texrot[v_off] >> (2 * face); + else if (mm->input.block_side_texrot) + facerot = mm->input.block_side_texrot[v_off] >> (2 * bt_face); + } + + if (mm->input.overlay) { + int over_face = STBVOX_ROTATE(face, rot.overlay); + unsigned char over = mm->input.overlay[v_off]; + if (over) { + if (mm->input.overlay_tex1) { + unsigned char rep1 = mm->input.overlay_tex1[over][over_face]; + if (rep1) + face_data.tex1 = rep1; + } + if (mm->input.overlay_tex2) { + unsigned char rep2 = mm->input.overlay_tex2[over][over_face]; + if (rep2) + face_data.tex2 = rep2; + } + if (mm->input.overlay_color) { + unsigned char rep3 = mm->input.overlay_color[over][over_face]; + if (rep3) + face_data.color = rep3; + } + + if (mm->input.overlay_side_texrot && face <= STBVOX_FACE_south) + facerot = mm->input.overlay_side_texrot[over] >> (2*over_face); + } + } + + if (mm->input.tex2_for_tex1) + face_data.tex2 = mm->input.tex2_for_tex1[face_data.tex1]; + if (mm->input.tex2) + face_data.tex2 = mm->input.tex2[v_off]; + if (mm->input.tex2_replace) { + if (mm->input.tex2_facemask[v_off] & (1 << face)) + face_data.tex2 = mm->input.tex2_replace[v_off]; + } + + color_face = STBVOX_ROTATE(face, rot.ecolor); + if (mm->input.extended_color) { + unsigned char ec = mm->input.extended_color[v_off]; + if (mm->input.ecolor_facemask[ec] & (1 << color_face)) + face_data.color = mm->input.ecolor_color[ec]; + } + + if (mm->input.color2) { + if (mm->input.color2_facemask[v_off] & (1 << color_face)) + face_data.color = mm->input.color2[v_off]; + if (mm->input.color3 && (mm->input.color3_facemask[v_off] & (1 << color_face))) + face_data.color = mm->input.color3[v_off]; + } + #endif + + face_data.face_info = (normal<<2) + facerot; + return face_data; +} + +// these are the types of faces each block can have +enum +{ + STBVOX_FT_none , + STBVOX_FT_upper , + STBVOX_FT_lower , + STBVOX_FT_solid , + STBVOX_FT_diag_012, + STBVOX_FT_diag_023, + STBVOX_FT_diag_013, + STBVOX_FT_diag_123, + STBVOX_FT_force , // can't be covered up, used for internal faces, also hides nothing + STBVOX_FT_partial , // only covered by solid, never covers anything else + + STBVOX_FT_count +}; + +static unsigned char stbvox_face_lerp[6] = { 0,2,0,2,4,4 }; +static unsigned char stbvox_vert3_lerp[5] = { 0,3,6,9,12 }; +static unsigned char stbvox_vert_lerp_for_face_lerp[4] = { 0, 4, 7, 7 }; +static unsigned char stbvox_face3_lerp[6] = { 0,3,6,9,12,14 }; +static unsigned char stbvox_vert_lerp_for_simple[4] = { 0,2,5,7 }; +static unsigned char stbvox_face3_updown[8] = { 0,2,5,7,0,2,5,7 }; // ignore top bit + +// vertex offsets for face vertices +static unsigned char stbvox_vertex_vector[6][4][3] = +{ + { { 1,0,1 }, { 1,1,1 }, { 1,1,0 }, { 1,0,0 } }, // east + { { 1,1,1 }, { 0,1,1 }, { 0,1,0 }, { 1,1,0 } }, // north + { { 0,1,1 }, { 0,0,1 }, { 0,0,0 }, { 0,1,0 } }, // west + { { 0,0,1 }, { 1,0,1 }, { 1,0,0 }, { 0,0,0 } }, // south + { { 0,1,1 }, { 1,1,1 }, { 1,0,1 }, { 0,0,1 } }, // up + { { 0,0,0 }, { 1,0,0 }, { 1,1,0 }, { 0,1,0 } }, // down +}; + +// stbvox_vertex_vector, but read coordinates as binary numbers, zyx +static unsigned char stbvox_vertex_selector[6][4] = +{ + { 5,7,3,1 }, + { 7,6,2,3 }, + { 6,4,0,2 }, + { 4,5,1,0 }, + { 6,7,5,4 }, + { 0,1,3,2 }, +}; + +static stbvox_mesh_vertex stbvox_vmesh_delta_normal[6][4] = +{ + { stbvox_vertex_encode(1,0,1,0,0) , + stbvox_vertex_encode(1,1,1,0,0) , + stbvox_vertex_encode(1,1,0,0,0) , + stbvox_vertex_encode(1,0,0,0,0) }, + { stbvox_vertex_encode(1,1,1,0,0) , + stbvox_vertex_encode(0,1,1,0,0) , + stbvox_vertex_encode(0,1,0,0,0) , + stbvox_vertex_encode(1,1,0,0,0) }, + { stbvox_vertex_encode(0,1,1,0,0) , + stbvox_vertex_encode(0,0,1,0,0) , + stbvox_vertex_encode(0,0,0,0,0) , + stbvox_vertex_encode(0,1,0,0,0) }, + { stbvox_vertex_encode(0,0,1,0,0) , + stbvox_vertex_encode(1,0,1,0,0) , + stbvox_vertex_encode(1,0,0,0,0) , + stbvox_vertex_encode(0,0,0,0,0) }, + { stbvox_vertex_encode(0,1,1,0,0) , + stbvox_vertex_encode(1,1,1,0,0) , + stbvox_vertex_encode(1,0,1,0,0) , + stbvox_vertex_encode(0,0,1,0,0) }, + { stbvox_vertex_encode(0,0,0,0,0) , + stbvox_vertex_encode(1,0,0,0,0) , + stbvox_vertex_encode(1,1,0,0,0) , + stbvox_vertex_encode(0,1,0,0,0) } +}; + +static stbvox_mesh_vertex stbvox_vmesh_pre_vheight[6][4] = +{ + { stbvox_vertex_encode(1,0,0,0,0) , + stbvox_vertex_encode(1,1,0,0,0) , + stbvox_vertex_encode(1,1,0,0,0) , + stbvox_vertex_encode(1,0,0,0,0) }, + { stbvox_vertex_encode(1,1,0,0,0) , + stbvox_vertex_encode(0,1,0,0,0) , + stbvox_vertex_encode(0,1,0,0,0) , + stbvox_vertex_encode(1,1,0,0,0) }, + { stbvox_vertex_encode(0,1,0,0,0) , + stbvox_vertex_encode(0,0,0,0,0) , + stbvox_vertex_encode(0,0,0,0,0) , + stbvox_vertex_encode(0,1,0,0,0) }, + { stbvox_vertex_encode(0,0,0,0,0) , + stbvox_vertex_encode(1,0,0,0,0) , + stbvox_vertex_encode(1,0,0,0,0) , + stbvox_vertex_encode(0,0,0,0,0) }, + { stbvox_vertex_encode(0,1,0,0,0) , + stbvox_vertex_encode(1,1,0,0,0) , + stbvox_vertex_encode(1,0,0,0,0) , + stbvox_vertex_encode(0,0,0,0,0) }, + { stbvox_vertex_encode(0,0,0,0,0) , + stbvox_vertex_encode(1,0,0,0,0) , + stbvox_vertex_encode(1,1,0,0,0) , + stbvox_vertex_encode(0,1,0,0,0) } +}; + +static stbvox_mesh_vertex stbvox_vmesh_delta_half_z[6][4] = +{ + { stbvox_vertex_encode(1,0,2,0,0) , + stbvox_vertex_encode(1,1,2,0,0) , + stbvox_vertex_encode(1,1,0,0,0) , + stbvox_vertex_encode(1,0,0,0,0) }, + { stbvox_vertex_encode(1,1,2,0,0) , + stbvox_vertex_encode(0,1,2,0,0) , + stbvox_vertex_encode(0,1,0,0,0) , + stbvox_vertex_encode(1,1,0,0,0) }, + { stbvox_vertex_encode(0,1,2,0,0) , + stbvox_vertex_encode(0,0,2,0,0) , + stbvox_vertex_encode(0,0,0,0,0) , + stbvox_vertex_encode(0,1,0,0,0) }, + { stbvox_vertex_encode(0,0,2,0,0) , + stbvox_vertex_encode(1,0,2,0,0) , + stbvox_vertex_encode(1,0,0,0,0) , + stbvox_vertex_encode(0,0,0,0,0) }, + { stbvox_vertex_encode(0,1,2,0,0) , + stbvox_vertex_encode(1,1,2,0,0) , + stbvox_vertex_encode(1,0,2,0,0) , + stbvox_vertex_encode(0,0,2,0,0) }, + { stbvox_vertex_encode(0,0,0,0,0) , + stbvox_vertex_encode(1,0,0,0,0) , + stbvox_vertex_encode(1,1,0,0,0) , + stbvox_vertex_encode(0,1,0,0,0) } +}; + +static stbvox_mesh_vertex stbvox_vmesh_crossed_pair[6][4] = +{ + { stbvox_vertex_encode(1,0,2,0,0) , + stbvox_vertex_encode(0,1,2,0,0) , + stbvox_vertex_encode(0,1,0,0,0) , + stbvox_vertex_encode(1,0,0,0,0) }, + { stbvox_vertex_encode(1,1,2,0,0) , + stbvox_vertex_encode(0,0,2,0,0) , + stbvox_vertex_encode(0,0,0,0,0) , + stbvox_vertex_encode(1,1,0,0,0) }, + { stbvox_vertex_encode(0,1,2,0,0) , + stbvox_vertex_encode(1,0,2,0,0) , + stbvox_vertex_encode(1,0,0,0,0) , + stbvox_vertex_encode(0,1,0,0,0) }, + { stbvox_vertex_encode(0,0,2,0,0) , + stbvox_vertex_encode(1,1,2,0,0) , + stbvox_vertex_encode(1,1,0,0,0) , + stbvox_vertex_encode(0,0,0,0,0) }, + // not used, so we leave it non-degenerate to make sure it doesn't get gen'd accidentally + { stbvox_vertex_encode(0,1,2,0,0) , + stbvox_vertex_encode(1,1,2,0,0) , + stbvox_vertex_encode(1,0,2,0,0) , + stbvox_vertex_encode(0,0,2,0,0) }, + { stbvox_vertex_encode(0,0,0,0,0) , + stbvox_vertex_encode(1,0,0,0,0) , + stbvox_vertex_encode(1,1,0,0,0) , + stbvox_vertex_encode(0,1,0,0,0) } +}; + +#define STBVOX_MAX_GEOM 16 +#define STBVOX_NUM_ROTATION 4 + +// this is used to determine if a face is ever generated at all +static unsigned char stbvox_hasface[STBVOX_MAX_GEOM][STBVOX_NUM_ROTATION] = +{ + { 0,0,0,0 }, // empty + { 0,0,0,0 }, // knockout + { 63,63,63,63 }, // solid + { 63,63,63,63 }, // transp + { 63,63,63,63 }, // slab + { 63,63,63,63 }, // slab + { 1|2|4|48, 8|1|2|48, 4|8|1|48, 2|4|8|48, }, // floor slopes + { 1|2|4|48, 8|1|2|48, 4|8|1|48, 2|4|8|48, }, // ceil slopes + { 47,47,47,47 }, // wall-projected diagonal with down face + { 31,31,31,31 }, // wall-projected diagonal with up face + { 63,63,63,63 }, // crossed-pair has special handling, but avoid early-out + { 63,63,63,63 }, // force + { 63,63,63,63 }, // vheight + { 63,63,63,63 }, // vheight + { 63,63,63,63 }, // vheight + { 63,63,63,63 }, // vheight +}; + +// this determines which face type above is visible on each side of the geometry +static unsigned char stbvox_facetype[STBVOX_GEOM_count][6] = +{ + { 0, }, // STBVOX_GEOM_empty + { STBVOX_FT_solid, STBVOX_FT_solid, STBVOX_FT_solid, STBVOX_FT_solid, STBVOX_FT_solid, STBVOX_FT_solid }, // knockout + { STBVOX_FT_solid, STBVOX_FT_solid, STBVOX_FT_solid, STBVOX_FT_solid, STBVOX_FT_solid, STBVOX_FT_solid }, // solid + { STBVOX_FT_force, STBVOX_FT_force, STBVOX_FT_force, STBVOX_FT_force, STBVOX_FT_force, STBVOX_FT_force }, // transp + + { STBVOX_FT_upper, STBVOX_FT_upper, STBVOX_FT_upper, STBVOX_FT_upper, STBVOX_FT_solid, STBVOX_FT_force }, + { STBVOX_FT_lower, STBVOX_FT_lower, STBVOX_FT_lower, STBVOX_FT_lower, STBVOX_FT_force, STBVOX_FT_solid }, + { STBVOX_FT_diag_123, STBVOX_FT_solid, STBVOX_FT_diag_023, STBVOX_FT_none, STBVOX_FT_force, STBVOX_FT_solid }, + { STBVOX_FT_diag_012, STBVOX_FT_solid, STBVOX_FT_diag_013, STBVOX_FT_none, STBVOX_FT_solid, STBVOX_FT_force }, + + { STBVOX_FT_diag_123, STBVOX_FT_solid, STBVOX_FT_diag_023, STBVOX_FT_force, STBVOX_FT_none, STBVOX_FT_solid }, + { STBVOX_FT_diag_012, STBVOX_FT_solid, STBVOX_FT_diag_013, STBVOX_FT_force, STBVOX_FT_solid, STBVOX_FT_none }, + { STBVOX_FT_force, STBVOX_FT_force, STBVOX_FT_force, STBVOX_FT_force, 0,0 }, // crossed pair + { STBVOX_FT_force, STBVOX_FT_force, STBVOX_FT_force, STBVOX_FT_force, STBVOX_FT_force, STBVOX_FT_force }, // GEOM_force + + { STBVOX_FT_partial,STBVOX_FT_partial,STBVOX_FT_partial,STBVOX_FT_partial, STBVOX_FT_force, STBVOX_FT_solid }, // floor vheight, all neighbors forced + { STBVOX_FT_partial,STBVOX_FT_partial,STBVOX_FT_partial,STBVOX_FT_partial, STBVOX_FT_force, STBVOX_FT_solid }, // floor vheight, all neighbors forced + { STBVOX_FT_partial,STBVOX_FT_partial,STBVOX_FT_partial,STBVOX_FT_partial, STBVOX_FT_solid, STBVOX_FT_force }, // ceil vheight, all neighbors forced + { STBVOX_FT_partial,STBVOX_FT_partial,STBVOX_FT_partial,STBVOX_FT_partial, STBVOX_FT_solid, STBVOX_FT_force }, // ceil vheight, all neighbors forced +}; + +// This table indicates what normal to use for the "up" face of a sloped geom +// @TODO this could be done with math given the current arrangement of the enum, but let's not require it +static unsigned char stbvox_floor_slope_for_rot[4] = +{ + STBVF_su, + STBVF_wu, // @TODO: why is this reversed from what it should be? this is a north-is-up face, so slope should be south&up + STBVF_nu, + STBVF_eu, +}; + +static unsigned char stbvox_ceil_slope_for_rot[4] = +{ + STBVF_sd, + STBVF_ed, + STBVF_nd, + STBVF_wd, +}; + +// this table indicates whether, for each pair of types above, a face is visible. +// each value indicates whether a given type is visible for all neighbor types +static unsigned short stbvox_face_visible[STBVOX_FT_count] = +{ + // we encode the table by listing which cases cause *obscuration*, and bitwise inverting that + // table is pre-shifted by 5 to save a shift when it's accessed + (unsigned short) ((~0x07ffu )<<5), // none is completely obscured by everything + (unsigned short) ((~((1u<output_cur[mesh][0]; + int step = mm->output_step[mesh][0]; + + // allocate a new quad from the mesh + vertices[0] = (stbvox_mesh_vertex *) p; p += step; + vertices[1] = (stbvox_mesh_vertex *) p; p += step; + vertices[2] = (stbvox_mesh_vertex *) p; p += step; + vertices[3] = (stbvox_mesh_vertex *) p; p += step; + mm->output_cur[mesh][0] = p; + + // output the face + #ifdef STBVOX_ICONFIG_FACE_ATTRIBUTE + // write face as interleaved vertex data + *(stbvox_mesh_face *) (vertices[0]+1) = face; + *(stbvox_mesh_face *) (vertices[1]+1) = face; + *(stbvox_mesh_face *) (vertices[2]+1) = face; + *(stbvox_mesh_face *) (vertices[3]+1) = face; + #else + *(stbvox_mesh_face *) mm->output_cur[mesh][1] = face; + mm->output_cur[mesh][1] += 4; + #endif +} + +void stbvox_make_mesh_for_face(stbvox_mesh_maker *mm, stbvox_rotate rot, int face, int v_off, stbvox_pos pos, stbvox_mesh_vertex vertbase, stbvox_mesh_vertex *face_coord, unsigned char mesh, int normal) +{ + stbvox_mesh_face face_data = stbvox_compute_mesh_face_value(mm,rot,face,v_off, normal); + + // still need to compute ao & texlerp for each vertex + + // first compute texlerp into p1 + stbvox_mesh_vertex p1[4] = { 0 }; + + #if defined(STBVOX_CONFIG_DOWN_TEXLERP_PACKED) && defined(STBVOX_CONFIG_UP_TEXLERP_PACKED) + #define STBVOX_USE_PACKED(f) ((f) == STBVOX_FACE_up || (f) == STBVOX_FACE_down) + #elif defined(STBVOX_CONFIG_UP_TEXLERP_PACKED) + #define STBVOX_USE_PACKED(f) ((f) == STBVOX_FACE_up ) + #elif defined(STBVOX_CONFIG_DOWN_TEXLERP_PACKED) + #define STBVOX_USE_PACKED(f) ( (f) == STBVOX_FACE_down) + #endif + + #if defined(STBVOX_CONFIG_DOWN_TEXLERP_PACKED) || defined(STBVOX_CONFIG_UP_TEXLERP_PACKED) + if (STBVOX_USE_PACKED(face)) { + if (!mm->input.packed_compact || 0==(mm->input.packed_compact[v_off]&16)) + goto set_default; + p1[0] = (mm->input.packed_compact[v_off + mm->cube_vertex_offset[face][0]] >> 5); + p1[1] = (mm->input.packed_compact[v_off + mm->cube_vertex_offset[face][1]] >> 5); + p1[2] = (mm->input.packed_compact[v_off + mm->cube_vertex_offset[face][2]] >> 5); + p1[3] = (mm->input.packed_compact[v_off + mm->cube_vertex_offset[face][3]] >> 5); + p1[0] = stbvox_vertex_encode(0,0,0,0,p1[0]); + p1[1] = stbvox_vertex_encode(0,0,0,0,p1[1]); + p1[2] = stbvox_vertex_encode(0,0,0,0,p1[2]); + p1[3] = stbvox_vertex_encode(0,0,0,0,p1[3]); + goto skip; + } + #endif + + if (mm->input.block_texlerp) { + stbvox_block_type bt = mm->input.blocktype[v_off]; + unsigned char val = mm->input.block_texlerp[bt]; + p1[0] = p1[1] = p1[2] = p1[3] = stbvox_vertex_encode(0,0,0,0,val); + } else if (mm->input.block_texlerp_face) { + stbvox_block_type bt = mm->input.blocktype[v_off]; + unsigned char bt_face = STBVOX_ROTATE(face, rot.block); + unsigned char val = mm->input.block_texlerp_face[bt][bt_face]; + p1[0] = p1[1] = p1[2] = p1[3] = stbvox_vertex_encode(0,0,0,0,val); + } else if (mm->input.texlerp_face3) { + unsigned char val = (mm->input.texlerp_face3[v_off] >> stbvox_face3_lerp[face]) & 7; + if (face >= STBVOX_FACE_up) + val = stbvox_face3_updown[val]; + p1[0] = p1[1] = p1[2] = p1[3] = stbvox_vertex_encode(0,0,0,0,val); + } else if (mm->input.texlerp_simple) { + unsigned char val = mm->input.texlerp_simple[v_off]; + unsigned char lerp_face = (val >> 2) & 7; + if (lerp_face == face) { + p1[0] = (mm->input.texlerp_simple[v_off + mm->cube_vertex_offset[face][0]] >> 5) & 7; + p1[1] = (mm->input.texlerp_simple[v_off + mm->cube_vertex_offset[face][1]] >> 5) & 7; + p1[2] = (mm->input.texlerp_simple[v_off + mm->cube_vertex_offset[face][2]] >> 5) & 7; + p1[3] = (mm->input.texlerp_simple[v_off + mm->cube_vertex_offset[face][3]] >> 5) & 7; + p1[0] = stbvox_vertex_encode(0,0,0,0,p1[0]); + p1[1] = stbvox_vertex_encode(0,0,0,0,p1[1]); + p1[2] = stbvox_vertex_encode(0,0,0,0,p1[2]); + p1[3] = stbvox_vertex_encode(0,0,0,0,p1[3]); + } else { + unsigned char base = stbvox_vert_lerp_for_simple[val&3]; + p1[0] = p1[1] = p1[2] = p1[3] = stbvox_vertex_encode(0,0,0,0,base); + } + } else if (mm->input.texlerp) { + unsigned char facelerp = (mm->input.texlerp[v_off] >> stbvox_face_lerp[face]) & 3; + if (facelerp == STBVOX_TEXLERP_FACE_use_vert) { + if (mm->input.texlerp_vert3 && face != STBVOX_FACE_down) { + unsigned char shift = stbvox_vert3_lerp[face]; + p1[0] = (mm->input.texlerp_vert3[mm->cube_vertex_offset[face][0]] >> shift) & 7; + p1[1] = (mm->input.texlerp_vert3[mm->cube_vertex_offset[face][1]] >> shift) & 7; + p1[2] = (mm->input.texlerp_vert3[mm->cube_vertex_offset[face][2]] >> shift) & 7; + p1[3] = (mm->input.texlerp_vert3[mm->cube_vertex_offset[face][3]] >> shift) & 7; + } else { + p1[0] = stbvox_vert_lerp_for_simple[mm->input.texlerp[mm->cube_vertex_offset[face][0]]>>6]; + p1[1] = stbvox_vert_lerp_for_simple[mm->input.texlerp[mm->cube_vertex_offset[face][1]]>>6]; + p1[2] = stbvox_vert_lerp_for_simple[mm->input.texlerp[mm->cube_vertex_offset[face][2]]>>6]; + p1[3] = stbvox_vert_lerp_for_simple[mm->input.texlerp[mm->cube_vertex_offset[face][3]]>>6]; + } + p1[0] = stbvox_vertex_encode(0,0,0,0,p1[0]); + p1[1] = stbvox_vertex_encode(0,0,0,0,p1[1]); + p1[2] = stbvox_vertex_encode(0,0,0,0,p1[2]); + p1[3] = stbvox_vertex_encode(0,0,0,0,p1[3]); + } else { + p1[0] = p1[1] = p1[2] = p1[3] = stbvox_vertex_encode(0,0,0,0,stbvox_vert_lerp_for_face_lerp[facelerp]); + } + } else { + #if defined(STBVOX_CONFIG_UP_TEXLERP_PACKED) || defined(STBVOX_CONFIG_DOWN_TEXLERP_PACKED) + set_default: + #endif + p1[0] = p1[1] = p1[2] = p1[3] = stbvox_vertex_encode(0,0,0,0,7); // @TODO make this configurable + } + + #if defined(STBVOX_CONFIG_UP_TEXLERP_PACKED) || defined(STBVOX_CONFIG_DOWN_TEXLERP_PACKED) + skip: + #endif + + // now compute lighting and store to vertices + { + stbvox_mesh_vertex *mv[4]; + stbvox_get_quad_vertex_pointer(mm, mesh, mv, face_data); + + if (mm->input.lighting) { + // @TODO: lighting at block centers, but not gathered, instead constant-per-face + if (mm->input.lighting_at_vertices) { + int i; + for (i=0; i < 4; ++i) { + *mv[i] = vertbase + face_coord[i] + + stbvox_vertex_encode(0,0,0,mm->input.lighting[v_off + mm->cube_vertex_offset[face][i]] & 63,0) + + p1[i]; + } + } else { + unsigned char *amb = &mm->input.lighting[v_off]; + int i,j; + #if defined(STBVOX_CONFIG_ROTATION_IN_LIGHTING) || defined(STBVOX_CONFIG_VHEIGHT_IN_LIGHTING) + #define STBVOX_GET_LIGHTING(light) ((light) & ~3) + #define STBVOX_LIGHTING_ROUNDOFF 8 + #else + #define STBVOX_GET_LIGHTING(light) (light) + #define STBVOX_LIGHTING_ROUNDOFF 2 + #endif + + for (i=0; i < 4; ++i) { + // for each vertex, gather from the four neighbor blocks it's facing + unsigned char *vamb = &amb[mm->cube_vertex_offset[face][i]]; + int total=0; + for (j=0; j < 4; ++j) + total += STBVOX_GET_LIGHTING(vamb[mm->vertex_gather_offset[face][j]]); + *mv[i] = vertbase + face_coord[i] + + stbvox_vertex_encode(0,0,0,(total+STBVOX_LIGHTING_ROUNDOFF)>>4,0) + + p1[i]; + // >> 4 is because: + // >> 2 to divide by 4 to get average over 4 samples + // >> 2 because input is 8 bits, output is 6 bits + } + + // @TODO: note that gathering baked *lighting* + // is different from gathering baked ao; baked ao can count + // solid blocks as 0 ao, but baked lighting wants average + // of non-blocked--not take average & treat blocked as 0. And + // we can't bake the right value into the solid blocks + // because they can have different lighting values on + // different sides. So we need to actually gather and + // then divide by 0..4 (which we can do with a table-driven + // multiply, or have an 'if' for the 3 case) + + } + } else { + vertbase += stbvox_vertex_encode(0,0,0,63,0); + *mv[0] = vertbase + face_coord[0] + p1[0]; + *mv[1] = vertbase + face_coord[1] + p1[1]; + *mv[2] = vertbase + face_coord[2] + p1[2]; + *mv[3] = vertbase + face_coord[3] + p1[3]; + } + } +} + +// get opposite-facing normal & texgen for opposite face, used to map up-facing vheight data to down-facing data +static unsigned char stbvox_reverse_face[STBVF_count] = +{ + STBVF_w, STBVF_s, STBVF_e, STBVF_n, STBVF_d , STBVF_u , STBVF_wd, STBVF_wu, + 0, 0, 0, 0, STBVF_sw_d, STBVF_sw_u, STBVF_sd, STBVF_su, + 0, 0, 0, 0, STBVF_se_d, STBVF_se_u, STBVF_ed, STBVF_eu, + 0, 0, 0, 0, STBVF_ne_d, STBVF_ne_d, STBVF_nd, STBVF_nu +}; + +#ifndef STBVOX_CONFIG_OPTIMIZED_VHEIGHT +// render non-planar quads by splitting into two triangles, rendering each as a degenerate quad +static void stbvox_make_12_split_mesh_for_face(stbvox_mesh_maker *mm, stbvox_rotate rot, int face, int v_off, stbvox_pos pos, stbvox_mesh_vertex vertbase, stbvox_mesh_vertex *face_coord, unsigned char mesh, unsigned char *ht) +{ + stbvox_mesh_vertex v[4]; + + unsigned char normal1 = stbvox_face_up_normal_012[ht[2]][ht[1]][ht[0]]; + unsigned char normal2 = stbvox_face_up_normal_123[ht[3]][ht[2]][ht[1]]; + + if (face == STBVOX_FACE_down) { + normal1 = stbvox_reverse_face[normal1]; + normal2 = stbvox_reverse_face[normal2]; + } + + // the floor side face_coord is stored in order NW,NE,SE,SW, but ht[] is stored SW,SE,NW,NE + v[0] = face_coord[2]; + v[1] = face_coord[3]; + v[2] = face_coord[0]; + v[3] = face_coord[2]; + stbvox_make_mesh_for_face(mm, rot, face, v_off, pos, vertbase, v, mesh, normal1); + v[1] = face_coord[0]; + v[2] = face_coord[1]; + stbvox_make_mesh_for_face(mm, rot, face, v_off, pos, vertbase, v, mesh, normal2); +} + +static void stbvox_make_03_split_mesh_for_face(stbvox_mesh_maker *mm, stbvox_rotate rot, int face, int v_off, stbvox_pos pos, stbvox_mesh_vertex vertbase, stbvox_mesh_vertex *face_coord, unsigned char mesh, unsigned char *ht) +{ + stbvox_mesh_vertex v[4]; + + unsigned char normal1 = stbvox_face_up_normal_013[ht[3]][ht[1]][ht[0]]; + unsigned char normal2 = stbvox_face_up_normal_023[ht[3]][ht[2]][ht[0]]; + + if (face == STBVOX_FACE_down) { + normal1 = stbvox_reverse_face[normal1]; + normal2 = stbvox_reverse_face[normal2]; + } + + v[0] = face_coord[1]; + v[1] = face_coord[2]; + v[2] = face_coord[3]; + v[3] = face_coord[1]; + stbvox_make_mesh_for_face(mm, rot, face, v_off, pos, vertbase, v, mesh, normal1); + v[1] = face_coord[3]; + v[2] = face_coord[0]; + stbvox_make_mesh_for_face(mm, rot, face, v_off, pos, vertbase, v, mesh, normal2); // this one is correct! +} +#endif + +#ifndef STBVOX_CONFIG_PRECISION_Z +#define STBVOX_CONFIG_PRECISION_Z 1 +#endif + +// simple case for mesh generation: we have only solid and empty blocks +static void stbvox_make_mesh_for_block(stbvox_mesh_maker *mm, stbvox_pos pos, int v_off, stbvox_mesh_vertex *vmesh) +{ + int ns_off = mm->y_stride_in_bytes; + int ew_off = mm->x_stride_in_bytes; + + unsigned char *blockptr = &mm->input.blocktype[v_off]; + stbvox_mesh_vertex basevert = stbvox_vertex_encode(pos.x, pos.y, pos.z << STBVOX_CONFIG_PRECISION_Z , 0,0); + + stbvox_rotate rot = { 0,0,0,0 }; + unsigned char simple_rot = 0; + + unsigned char mesh = mm->default_mesh; + + if (mm->input.selector) + mesh = mm->input.selector[v_off]; + else if (mm->input.block_selector) + mesh = mm->input.block_selector[mm->input.blocktype[v_off]]; + + // check if we're going off the end + if (mm->output_cur[mesh][0] + mm->output_size[mesh][0]*6 > mm->output_end[mesh][0]) { + mm->full = 1; + return; + } + + #ifdef STBVOX_CONFIG_ROTATION_IN_LIGHTING + simple_rot = mm->input.lighting[v_off] & 3; + #endif + + if (mm->input.packed_compact) + simple_rot = mm->input.packed_compact[v_off] & 3; + + if (blockptr[ 1]==0) { + rot.facerot = simple_rot; + stbvox_make_mesh_for_face(mm, rot, STBVOX_FACE_up , v_off, pos, basevert, vmesh+4*STBVOX_FACE_up, mesh, STBVOX_FACE_up); + } + if (blockptr[-1]==0) { + rot.facerot = (-simple_rot) & 3; + stbvox_make_mesh_for_face(mm, rot, STBVOX_FACE_down, v_off, pos, basevert, vmesh+4*STBVOX_FACE_down, mesh, STBVOX_FACE_down); + } + + if (mm->input.rotate) { + unsigned char val = mm->input.rotate[v_off]; + rot.block = (val >> 0) & 3; + rot.overlay = (val >> 2) & 3; + //rot.tex2 = (val >> 4) & 3; + rot.ecolor = (val >> 6) & 3; + } else { + rot.block = rot.overlay = rot.ecolor = simple_rot; + } + rot.facerot = 0; + + if (blockptr[ ns_off]==0) + stbvox_make_mesh_for_face(mm, rot, STBVOX_FACE_north, v_off, pos, basevert, vmesh+4*STBVOX_FACE_north, mesh, STBVOX_FACE_north); + if (blockptr[-ns_off]==0) + stbvox_make_mesh_for_face(mm, rot, STBVOX_FACE_south, v_off, pos, basevert, vmesh+4*STBVOX_FACE_south, mesh, STBVOX_FACE_south); + if (blockptr[ ew_off]==0) + stbvox_make_mesh_for_face(mm, rot, STBVOX_FACE_east , v_off, pos, basevert, vmesh+4*STBVOX_FACE_east, mesh, STBVOX_FACE_east); + if (blockptr[-ew_off]==0) + stbvox_make_mesh_for_face(mm, rot, STBVOX_FACE_west , v_off, pos, basevert, vmesh+4*STBVOX_FACE_west, mesh, STBVOX_FACE_west); +} + +// complex case for mesh generation: we have lots of different +// block types, and we don't want to generate faces of blocks +// if they're hidden by neighbors. +// +// we use lots of tables to determine this: we have a table +// which tells us what face type is generated for each type of +// geometry, and then a table that tells us whether that type +// is hidden by a neighbor. +static void stbvox_make_mesh_for_block_with_geo(stbvox_mesh_maker *mm, stbvox_pos pos, int v_off) +{ + int ns_off = mm->y_stride_in_bytes; + int ew_off = mm->x_stride_in_bytes; + int visible_faces, visible_base; + unsigned char mesh; + + // first gather the geometry info for this block and all neighbors + + unsigned char bt, nbt[6]; + unsigned char geo, ngeo[6]; + unsigned char rot, nrot[6]; + + bt = mm->input.blocktype[v_off]; + nbt[0] = mm->input.blocktype[v_off + ew_off]; + nbt[1] = mm->input.blocktype[v_off + ns_off]; + nbt[2] = mm->input.blocktype[v_off - ew_off]; + nbt[3] = mm->input.blocktype[v_off - ns_off]; + nbt[4] = mm->input.blocktype[v_off + 1]; + nbt[5] = mm->input.blocktype[v_off - 1]; + if (mm->input.geometry) { + int i; + geo = mm->input.geometry[v_off]; + ngeo[0] = mm->input.geometry[v_off + ew_off]; + ngeo[1] = mm->input.geometry[v_off + ns_off]; + ngeo[2] = mm->input.geometry[v_off - ew_off]; + ngeo[3] = mm->input.geometry[v_off - ns_off]; + ngeo[4] = mm->input.geometry[v_off + 1]; + ngeo[5] = mm->input.geometry[v_off - 1]; + + rot = (geo >> 4) & 3; + geo &= 15; + for (i=0; i < 6; ++i) { + nrot[i] = (ngeo[i] >> 4) & 3; + ngeo[i] &= 15; + } + } else { + int i; + assert(mm->input.block_geometry); + geo = mm->input.block_geometry[bt]; + for (i=0; i < 6; ++i) + ngeo[i] = mm->input.block_geometry[nbt[i]]; + if (mm->input.selector) { + #ifndef STBVOX_CONFIG_ROTATION_IN_LIGHTING + if (mm->input.packed_compact == NULL) { + rot = (mm->input.selector[v_off ] >> 4) & 3; + nrot[0] = (mm->input.selector[v_off + ew_off] >> 4) & 3; + nrot[1] = (mm->input.selector[v_off + ns_off] >> 4) & 3; + nrot[2] = (mm->input.selector[v_off - ew_off] >> 4) & 3; + nrot[3] = (mm->input.selector[v_off - ns_off] >> 4) & 3; + nrot[4] = (mm->input.selector[v_off + 1] >> 4) & 3; + nrot[5] = (mm->input.selector[v_off - 1] >> 4) & 3; + } + #endif + } else { + #ifndef STBVOX_CONFIG_ROTATION_IN_LIGHTING + if (mm->input.packed_compact == NULL) { + rot = (geo>>4)&3; + geo &= 15; + for (i=0; i < 6; ++i) { + nrot[i] = (ngeo[i]>>4)&3; + ngeo[i] &= 15; + } + } + #endif + } + } + + #ifndef STBVOX_CONFIG_ROTATION_IN_LIGHTING + if (mm->input.packed_compact) { + rot = mm->input.packed_compact[rot] & 3; + nrot[0] = mm->input.packed_compact[v_off + ew_off] & 3; + nrot[1] = mm->input.packed_compact[v_off + ns_off] & 3; + nrot[2] = mm->input.packed_compact[v_off - ew_off] & 3; + nrot[3] = mm->input.packed_compact[v_off - ns_off] & 3; + nrot[4] = mm->input.packed_compact[v_off + 1] & 3; + nrot[5] = mm->input.packed_compact[v_off - 1] & 3; + } + #else + rot = mm->input.lighting[v_off] & 3; + nrot[0] = (mm->input.lighting[v_off + ew_off]) & 3; + nrot[1] = (mm->input.lighting[v_off + ns_off]) & 3; + nrot[2] = (mm->input.lighting[v_off - ew_off]) & 3; + nrot[3] = (mm->input.lighting[v_off - ns_off]) & 3; + nrot[4] = (mm->input.lighting[v_off + 1]) & 3; + nrot[5] = (mm->input.lighting[v_off - 1]) & 3; + #endif + + if (geo == STBVOX_GEOM_transp) { + // transparency has a special rule: if the blocktype is the same, + // and the faces are compatible, then can hide them; otherwise, + // force them on + // Note that this means we don't support any transparentshapes other + // than solid blocks, since detecting them is too complicated. If + // you wanted to do something like minecraft water, you probably + // should just do that with a separate renderer anyway. (We don't + // support transparency sorting so you need to use alpha test + // anyway) + int i; + for (i=0; i < 6; ++i) + if (nbt[i] != bt) { + nbt[i] = 0; + ngeo[i] = STBVOX_GEOM_empty; + } else + ngeo[i] = STBVOX_GEOM_solid; + geo = STBVOX_GEOM_solid; + } + + // now compute the face visibility + visible_base = stbvox_hasface[geo][rot]; + // @TODO: assert(visible_base != 0); // we should have early-outted earlier in this case + visible_faces = 0; + + // now, for every face that might be visible, check if neighbor hides it + if (visible_base & (1 << STBVOX_FACE_east)) { + int type = stbvox_facetype[ geo ][(STBVOX_FACE_east+ rot )&3]; + int ntype = stbvox_facetype[ngeo[0]][(STBVOX_FACE_west+nrot[0])&3]; + visible_faces |= ((stbvox_face_visible[type]) >> (ntype + 5 - STBVOX_FACE_east)) & (1 << STBVOX_FACE_east); + } + if (visible_base & (1 << STBVOX_FACE_north)) { + int type = stbvox_facetype[ geo ][(STBVOX_FACE_north+ rot )&3]; + int ntype = stbvox_facetype[ngeo[1]][(STBVOX_FACE_south+nrot[1])&3]; + visible_faces |= ((stbvox_face_visible[type]) >> (ntype + 5 - STBVOX_FACE_north)) & (1 << STBVOX_FACE_north); + } + if (visible_base & (1 << STBVOX_FACE_west)) { + int type = stbvox_facetype[ geo ][(STBVOX_FACE_west+ rot )&3]; + int ntype = stbvox_facetype[ngeo[2]][(STBVOX_FACE_east+nrot[2])&3]; + visible_faces |= ((stbvox_face_visible[type]) >> (ntype + 5 - STBVOX_FACE_west)) & (1 << STBVOX_FACE_west); + } + if (visible_base & (1 << STBVOX_FACE_south)) { + int type = stbvox_facetype[ geo ][(STBVOX_FACE_south+ rot )&3]; + int ntype = stbvox_facetype[ngeo[3]][(STBVOX_FACE_north+nrot[3])&3]; + visible_faces |= ((stbvox_face_visible[type]) >> (ntype + 5 - STBVOX_FACE_south)) & (1 << STBVOX_FACE_south); + } + if (visible_base & (1 << STBVOX_FACE_up)) { + int type = stbvox_facetype[ geo ][STBVOX_FACE_up]; + int ntype = stbvox_facetype[ngeo[4]][STBVOX_FACE_down]; + visible_faces |= ((stbvox_face_visible[type]) >> (ntype + 5 - STBVOX_FACE_up)) & (1 << STBVOX_FACE_up); + } + if (visible_base & (1 << STBVOX_FACE_down)) { + int type = stbvox_facetype[ geo ][STBVOX_FACE_down]; + int ntype = stbvox_facetype[ngeo[5]][STBVOX_FACE_up]; + visible_faces |= ((stbvox_face_visible[type]) >> (ntype + 5 - STBVOX_FACE_down)) & (1 << STBVOX_FACE_down); + } + + if (geo == STBVOX_GEOM_force) + geo = STBVOX_GEOM_solid; + + assert((geo == STBVOX_GEOM_crossed_pair) ? (visible_faces == 15) : 1); + + // now we finally know for sure which faces are getting generated + if (visible_faces == 0) + return; + + mesh = mm->default_mesh; + if (mm->input.selector) + mesh = mm->input.selector[v_off]; + else if (mm->input.block_selector) + mesh = mm->input.block_selector[bt]; + + if (geo <= STBVOX_GEOM_ceil_slope_north_is_bottom) { + // this is the simple case, we can just use regular block gen with special vmesh calculated with vheight + stbvox_mesh_vertex basevert; + stbvox_mesh_vertex vmesh[6][4]; + stbvox_rotate rotate = { 0,0,0,0 }; + unsigned char simple_rot = rot; + int i; + // we only need to do this for the displayed faces, but it's easier + // to just do it up front; @OPTIMIZE check if it's faster to do it + // for visible faces only + for (i=0; i < 6*4; ++i) { + int vert = stbvox_vertex_selector[0][i]; + vert = stbvox_rotate_vertex[vert][rot]; + vmesh[0][i] = stbvox_vmesh_pre_vheight[0][i] + + stbvox_geometry_vheight[geo][vert]; + } + + basevert = stbvox_vertex_encode(pos.x, pos.y, pos.z << STBVOX_CONFIG_PRECISION_Z, 0,0); + if (mm->input.selector) { + mesh = mm->input.selector[v_off]; + } else if (mm->input.block_selector) + mesh = mm->input.block_selector[bt]; + + + // check if we're going off the end + if (mm->output_cur[mesh][0] + mm->output_size[mesh][0]*6 > mm->output_end[mesh][0]) { + mm->full = 1; + return; + } + + if (geo >= STBVOX_GEOM_floor_slope_north_is_top) { + if (visible_faces & (1 << STBVOX_FACE_up)) { + int normal = geo == STBVOX_GEOM_floor_slope_north_is_top ? stbvox_floor_slope_for_rot[simple_rot] : STBVOX_FACE_up; + rotate.facerot = simple_rot; + stbvox_make_mesh_for_face(mm, rotate, STBVOX_FACE_up , v_off, pos, basevert, vmesh[STBVOX_FACE_up], mesh, normal); + } + if (visible_faces & (1 << STBVOX_FACE_down)) { + int normal = geo == STBVOX_GEOM_ceil_slope_north_is_bottom ? stbvox_ceil_slope_for_rot[simple_rot] : STBVOX_FACE_down; + rotate.facerot = (-rotate.facerot) & 3; + stbvox_make_mesh_for_face(mm, rotate, STBVOX_FACE_down, v_off, pos, basevert, vmesh[STBVOX_FACE_down], mesh, normal); + } + } else { + if (visible_faces & (1 << STBVOX_FACE_up)) { + rotate.facerot = simple_rot; + stbvox_make_mesh_for_face(mm, rotate, STBVOX_FACE_up , v_off, pos, basevert, vmesh[STBVOX_FACE_up], mesh, STBVOX_FACE_up); + } + if (visible_faces & (1 << STBVOX_FACE_down)) { + rotate.facerot = (-rotate.facerot) & 3; + stbvox_make_mesh_for_face(mm, rotate, STBVOX_FACE_down, v_off, pos, basevert, vmesh[STBVOX_FACE_down], mesh, STBVOX_FACE_down); + } + } + + if (mm->input.rotate) { + unsigned char val = mm->input.rotate[v_off]; + rotate.block = (val >> 0) & 3; + rotate.overlay = (val >> 2) & 3; + //rotate.tex2 = (val >> 4) & 3; + rotate.ecolor = (val >> 6) & 3; + } else { + rotate.block = rotate.overlay = rotate.ecolor = simple_rot; + } + + rotate.facerot = 0; + + if (visible_faces & (1 << STBVOX_FACE_north)) + stbvox_make_mesh_for_face(mm, rotate, STBVOX_FACE_north, v_off, pos, basevert, vmesh[STBVOX_FACE_north], mesh, STBVOX_FACE_north); + if (visible_faces & (1 << STBVOX_FACE_south)) + stbvox_make_mesh_for_face(mm, rotate, STBVOX_FACE_south, v_off, pos, basevert, vmesh[STBVOX_FACE_south], mesh, STBVOX_FACE_south); + if (visible_faces & (1 << STBVOX_FACE_east)) + stbvox_make_mesh_for_face(mm, rotate, STBVOX_FACE_east , v_off, pos, basevert, vmesh[STBVOX_FACE_east ], mesh, STBVOX_FACE_east); + if (visible_faces & (1 << STBVOX_FACE_west)) + stbvox_make_mesh_for_face(mm, rotate, STBVOX_FACE_west , v_off, pos, basevert, vmesh[STBVOX_FACE_west ], mesh, STBVOX_FACE_west); + } + if (geo >= STBVOX_GEOM_floor_vheight_03) { + // this case can also be generated with regular block gen with special vmesh, + // except: + // if we want to generate middle diagonal for 'weird' blocks + // it's more complicated to detect neighbor matchups + stbvox_mesh_vertex vmesh[6][4]; + stbvox_mesh_vertex cube[8]; + stbvox_mesh_vertex basevert; + stbvox_rotate rotate = { 0,0,0,0 }; + unsigned char simple_rot = rot; + unsigned char ht[4]; + int extreme; + + // extract the heights + #ifdef STBVOX_CONFIG_VHEIGHT_IN_LIGHTING + ht[0] = mm->input.lighting[v_off ] & 3; + ht[1] = mm->input.lighting[v_off+ew_off ] & 3; + ht[2] = mm->input.lighting[v_off +ns_off] & 3; + ht[3] = mm->input.lighting[v_off+ew_off+ns_off] & 3; + #else + if (mm->input.vheight) { + unsigned char v = mm->input.vheight[v_off]; + ht[0] = (v >> 0) & 3; + ht[1] = (v >> 2) & 3; + ht[2] = (v >> 4) & 3; + ht[3] = (v >> 6) & 3; + } else if (mm->input.block_vheight) { + unsigned char v = mm->input.block_vheight[bt]; + unsigned char raw[4]; + int i; + + raw[0] = (v >> 0) & 3; + raw[1] = (v >> 2) & 3; + raw[2] = (v >> 4) & 3; + raw[3] = (v >> 6) & 3; + + for (i=0; i < 4; ++i) + ht[i] = raw[stbvox_rotate_vertex[i][rot]]; + } else if (mm->input.packed_compact) { + ht[0] = (mm->input.packed_compact[v_off ] >> 2) & 3; + ht[1] = (mm->input.packed_compact[v_off+ew_off ] >> 2) & 3; + ht[2] = (mm->input.packed_compact[v_off +ns_off] >> 2) & 3; + ht[3] = (mm->input.packed_compact[v_off+ew_off+ns_off] >> 2) & 3; + } else if (mm->input.geometry) { + ht[0] = mm->input.geometry[v_off ] >> 6; + ht[1] = mm->input.geometry[v_off+ew_off ] >> 6; + ht[2] = mm->input.geometry[v_off +ns_off] >> 6; + ht[3] = mm->input.geometry[v_off+ew_off+ns_off] >> 6; + } else { + assert(0); + } + #endif + + // flag whether any sides go off the top of the block, which means + // our visible_faces test was wrong + extreme = (ht[0] == 3 || ht[1] == 3 || ht[2] == 3 || ht[3] == 3); + + if (geo >= STBVOX_GEOM_ceil_vheight_03) { + cube[0] = stbvox_vertex_encode(0,0,ht[0],0,0); + cube[1] = stbvox_vertex_encode(0,0,ht[1],0,0); + cube[2] = stbvox_vertex_encode(0,0,ht[2],0,0); + cube[3] = stbvox_vertex_encode(0,0,ht[3],0,0); + cube[4] = stbvox_vertex_encode(0,0,2,0,0); + cube[5] = stbvox_vertex_encode(0,0,2,0,0); + cube[6] = stbvox_vertex_encode(0,0,2,0,0); + cube[7] = stbvox_vertex_encode(0,0,2,0,0); + } else { + cube[0] = stbvox_vertex_encode(0,0,0,0,0); + cube[1] = stbvox_vertex_encode(0,0,0,0,0); + cube[2] = stbvox_vertex_encode(0,0,0,0,0); + cube[3] = stbvox_vertex_encode(0,0,0,0,0); + cube[4] = stbvox_vertex_encode(0,0,ht[0],0,0); + cube[5] = stbvox_vertex_encode(0,0,ht[1],0,0); + cube[6] = stbvox_vertex_encode(0,0,ht[2],0,0); + cube[7] = stbvox_vertex_encode(0,0,ht[3],0,0); + } + if (!mm->input.vheight && mm->input.block_vheight) { + // @TODO: support block vheight here, I've forgotten what needs to be done specially + } + + // build vertex mesh + { + int i; + for (i=0; i < 6*4; ++i) { + int vert = stbvox_vertex_selector[0][i]; + vmesh[0][i] = stbvox_vmesh_pre_vheight[0][i] + + cube[vert]; + } + } + + basevert = stbvox_vertex_encode(pos.x, pos.y, pos.z << STBVOX_CONFIG_PRECISION_Z, 0,0); + // check if we're going off the end + if (mm->output_cur[mesh][0] + mm->output_size[mesh][0]*6 > mm->output_end[mesh][0]) { + mm->full = 1; + return; + } + + // @TODO generate split faces + if (visible_faces & (1 << STBVOX_FACE_up)) { + if (geo >= STBVOX_GEOM_ceil_vheight_03) + // flat + stbvox_make_mesh_for_face(mm, rotate, STBVOX_FACE_up , v_off, pos, basevert, vmesh[STBVOX_FACE_up], mesh, STBVOX_FACE_up); + else { + #ifndef STBVOX_CONFIG_OPTIMIZED_VHEIGHT + // check if it's non-planar + if (cube[5] + cube[6] != cube[4] + cube[7]) { + // not planar, split along diagonal and make degenerate quads + if (geo == STBVOX_GEOM_floor_vheight_03) + stbvox_make_03_split_mesh_for_face(mm, rotate, STBVOX_FACE_up, v_off, pos, basevert, vmesh[STBVOX_FACE_up], mesh, ht); + else + stbvox_make_12_split_mesh_for_face(mm, rotate, STBVOX_FACE_up, v_off, pos, basevert, vmesh[STBVOX_FACE_up], mesh, ht); + } else + stbvox_make_mesh_for_face(mm, rotate, STBVOX_FACE_up , v_off, pos, basevert, vmesh[STBVOX_FACE_up], mesh, stbvox_planar_face_up_normal[ht[2]][ht[1]][ht[0]]); + #else + stbvox_make_mesh_for_face(mm, rotate, STBVOX_FACE_up , v_off, pos, basevert, vmesh[STBVOX_FACE_up], mesh, stbvox_optimized_face_up_normal[ht[3]][ht[2]][ht[1]][ht[0]]); + #endif + } + } + if (visible_faces & (1 << STBVOX_FACE_down)) { + if (geo < STBVOX_GEOM_ceil_vheight_03) + // flat + stbvox_make_mesh_for_face(mm, rotate, STBVOX_FACE_down, v_off, pos, basevert, vmesh[STBVOX_FACE_down], mesh, STBVOX_FACE_down); + else { + #ifndef STBVOX_CONFIG_OPTIMIZED_VHEIGHT + // check if it's non-planar + if (cube[1] + cube[2] != cube[0] + cube[3]) { + // not planar, split along diagonal and make degenerate quads + if (geo == STBVOX_GEOM_ceil_vheight_03) + stbvox_make_03_split_mesh_for_face(mm, rotate, STBVOX_FACE_down, v_off, pos, basevert, vmesh[STBVOX_FACE_down], mesh, ht); + else + stbvox_make_12_split_mesh_for_face(mm, rotate, STBVOX_FACE_down, v_off, pos, basevert, vmesh[STBVOX_FACE_down], mesh, ht); + } else + stbvox_make_mesh_for_face(mm, rotate, STBVOX_FACE_down, v_off, pos, basevert, vmesh[STBVOX_FACE_down], mesh, stbvox_reverse_face[stbvox_planar_face_up_normal[ht[2]][ht[1]][ht[0]]]); + #else + stbvox_make_mesh_for_face(mm, rotate, STBVOX_FACE_down, v_off, pos, basevert, vmesh[STBVOX_FACE_down], mesh, stbvox_reverse_face[stbvox_optimized_face_up_normal[ht[3]][ht[2]][ht[1]][ht[0]]]); + #endif + } + } + + if (mm->input.rotate) { + unsigned char val = mm->input.rotate[v_off]; + rotate.block = (val >> 0) & 3; + rotate.overlay = (val >> 2) & 3; + //rotate.tex2 = (val >> 4) & 3; + rotate.ecolor = (val >> 6) & 3; + } else if (mm->input.selector) { + rotate.block = rotate.overlay = rotate.ecolor = simple_rot; + } + + if ((visible_faces & (1 << STBVOX_FACE_north)) || (extreme && (ht[2] == 3 || ht[3] == 3))) + stbvox_make_mesh_for_face(mm, rotate, STBVOX_FACE_north, v_off, pos, basevert, vmesh[STBVOX_FACE_north], mesh, STBVOX_FACE_north); + if ((visible_faces & (1 << STBVOX_FACE_south)) || (extreme && (ht[0] == 3 || ht[1] == 3))) + stbvox_make_mesh_for_face(mm, rotate, STBVOX_FACE_south, v_off, pos, basevert, vmesh[STBVOX_FACE_south], mesh, STBVOX_FACE_south); + if ((visible_faces & (1 << STBVOX_FACE_east)) || (extreme && (ht[1] == 3 || ht[3] == 3))) + stbvox_make_mesh_for_face(mm, rotate, STBVOX_FACE_east , v_off, pos, basevert, vmesh[STBVOX_FACE_east ], mesh, STBVOX_FACE_east); + if ((visible_faces & (1 << STBVOX_FACE_west)) || (extreme && (ht[0] == 3 || ht[2] == 3))) + stbvox_make_mesh_for_face(mm, rotate, STBVOX_FACE_west , v_off, pos, basevert, vmesh[STBVOX_FACE_west ], mesh, STBVOX_FACE_west); + } + + if (geo == STBVOX_GEOM_crossed_pair) { + // this can be generated with a special vmesh + stbvox_mesh_vertex basevert = stbvox_vertex_encode(pos.x, pos.y, pos.z << STBVOX_CONFIG_PRECISION_Z , 0,0); + unsigned char simple_rot=0; + stbvox_rotate rot = { 0,0,0,0 }; + unsigned char mesh = mm->default_mesh; + if (mm->input.selector) { + mesh = mm->input.selector[v_off]; + simple_rot = mesh >> 4; + mesh &= 15; + } + if (mm->input.block_selector) { + mesh = mm->input.block_selector[bt]; + } + + // check if we're going off the end + if (mm->output_cur[mesh][0] + mm->output_size[mesh][0]*4 > mm->output_end[mesh][0]) { + mm->full = 1; + return; + } + + if (mm->input.rotate) { + unsigned char val = mm->input.rotate[v_off]; + rot.block = (val >> 0) & 3; + rot.overlay = (val >> 2) & 3; + //rot.tex2 = (val >> 4) & 3; + rot.ecolor = (val >> 6) & 3; + } else if (mm->input.selector) { + rot.block = rot.overlay = rot.ecolor = simple_rot; + } + rot.facerot = 0; + + stbvox_make_mesh_for_face(mm, rot, STBVOX_FACE_north, v_off, pos, basevert, stbvox_vmesh_crossed_pair[STBVOX_FACE_north], mesh, STBVF_ne_u_cross); + stbvox_make_mesh_for_face(mm, rot, STBVOX_FACE_south, v_off, pos, basevert, stbvox_vmesh_crossed_pair[STBVOX_FACE_south], mesh, STBVF_sw_u_cross); + stbvox_make_mesh_for_face(mm, rot, STBVOX_FACE_east , v_off, pos, basevert, stbvox_vmesh_crossed_pair[STBVOX_FACE_east ], mesh, STBVF_se_u_cross); + stbvox_make_mesh_for_face(mm, rot, STBVOX_FACE_west , v_off, pos, basevert, stbvox_vmesh_crossed_pair[STBVOX_FACE_west ], mesh, STBVF_nw_u_cross); + } + + + // @TODO + // STBVOX_GEOM_floor_slope_north_is_top_as_wall, + // STBVOX_GEOM_ceil_slope_north_is_bottom_as_wall, +} + +static void stbvox_make_mesh_for_column(stbvox_mesh_maker *mm, int x, int y, int z0) +{ + stbvox_pos pos; + int v_off = x * mm->x_stride_in_bytes + y * mm->y_stride_in_bytes; + int ns_off = mm->y_stride_in_bytes; + int ew_off = mm->x_stride_in_bytes; + pos.x = x; + pos.y = y; + pos.z = 0; + if (mm->input.geometry) { + unsigned char *bt = mm->input.blocktype + v_off; + unsigned char *geo = mm->input.geometry + v_off; + int z; + for (z=z0; z < mm->z1; ++z) { + if (bt[z] && ( !bt[z+ns_off] || !STBVOX_GET_GEO(geo[z+ns_off]) || !bt[z-ns_off] || !STBVOX_GET_GEO(geo[z-ns_off]) + || !bt[z+ew_off] || !STBVOX_GET_GEO(geo[z+ew_off]) || !bt[z-ew_off] || !STBVOX_GET_GEO(geo[z-ew_off]) + || !bt[z-1] || !STBVOX_GET_GEO(geo[z-1]) || !bt[z+1] || !STBVOX_GET_GEO(geo[z+1]))) + { // TODO check up and down + pos.z = z; + stbvox_make_mesh_for_block_with_geo(mm, pos, v_off+z); + if (mm->full) { + mm->cur_z = z; + return; + } + } + } + } else if (mm->input.block_geometry) { + int z; + unsigned char *bt = mm->input.blocktype + v_off; + unsigned char *geo = mm->input.block_geometry; + for (z=z0; z < mm->z1; ++z) { + if (bt[z] && ( geo[bt[z+ns_off]] != STBVOX_GEOM_solid + || geo[bt[z-ns_off]] != STBVOX_GEOM_solid + || geo[bt[z+ew_off]] != STBVOX_GEOM_solid + || geo[bt[z-ew_off]] != STBVOX_GEOM_solid + || geo[bt[z-1]] != STBVOX_GEOM_solid + || geo[bt[z+1]] != STBVOX_GEOM_solid)) + { + pos.z = z; + stbvox_make_mesh_for_block_with_geo(mm, pos, v_off+z); + if (mm->full) { + mm->cur_z = z; + return; + } + } + } + } else { + unsigned char *bt = mm->input.blocktype + v_off; + int z; + #if STBVOX_CONFIG_PRECISION_Z == 1 + stbvox_mesh_vertex *vmesh = stbvox_vmesh_delta_half_z[0]; + #else + stbvox_mesh_vertex *vmesh = stbvox_vmesh_delta_normal[0]; + #endif + for (z=z0; z < mm->z1; ++z) { + // if it's solid and at least one neighbor isn't solid + if (bt[z] && (!bt[z+ns_off] || !bt[z-ns_off] || !bt[z+ew_off] || !bt[z-ew_off] || !bt[z-1] || !bt[z+1])) { + pos.z = z; + stbvox_make_mesh_for_block(mm, pos, v_off+z, vmesh); + if (mm->full) { + mm->cur_z = z; + return; + } + } + } + } +} + +static void stbvox_bring_up_to_date(stbvox_mesh_maker *mm) +{ + if (mm->config_dirty) { + int i; + #ifdef STBVOX_ICONFIG_FACE_ATTRIBUTE + mm->num_mesh_slots = 1; + for (i=0; i < STBVOX_MAX_MESHES; ++i) { + mm->output_size[i][0] = 32; + mm->output_step[i][0] = 8; + } + #else + mm->num_mesh_slots = 2; + for (i=0; i < STBVOX_MAX_MESHES; ++i) { + mm->output_size[i][0] = 16; + mm->output_step[i][0] = 4; + mm->output_size[i][1] = 4; + mm->output_step[i][1] = 4; + } + #endif + + mm->config_dirty = 0; + } +} + +int stbvox_make_mesh(stbvox_mesh_maker *mm) +{ + int x,y; + stbvox_bring_up_to_date(mm); + mm->full = 0; + if (mm->cur_x > mm->x0 || mm->cur_y > mm->y0 || mm->cur_z > mm->z0) { + stbvox_make_mesh_for_column(mm, mm->cur_x, mm->cur_y, mm->cur_z); + if (mm->full) + return 0; + ++mm->cur_y; + while (mm->cur_y < mm->y1 && !mm->full) { + stbvox_make_mesh_for_column(mm, mm->cur_x, mm->cur_y, mm->z0); + if (mm->full) + return 0; + ++mm->cur_y; + } + ++mm->cur_x; + } + for (x=mm->cur_x; x < mm->x1; ++x) { + for (y=mm->y0; y < mm->y1; ++y) { + stbvox_make_mesh_for_column(mm, x, y, mm->z0); + if (mm->full) { + mm->cur_x = x; + mm->cur_y = y; + return 0; + } + } + } + return 1; +} + +void stbvox_init_mesh_maker(stbvox_mesh_maker *mm) +{ + memset(mm, 0, sizeof(*mm)); + stbvox_build_default_palette(); + + mm->config_dirty = 1; + mm->default_mesh = 0; +} + +int stbvox_get_buffer_count(stbvox_mesh_maker *mm) +{ + stbvox_bring_up_to_date(mm); + return mm->num_mesh_slots; +} + +int stbvox_get_buffer_size_per_quad(stbvox_mesh_maker *mm, int n) +{ + return mm->output_size[0][n]; +} + +void stbvox_reset_buffers(stbvox_mesh_maker *mm) +{ + int i; + for (i=0; i < STBVOX_MAX_MESHES*STBVOX_MAX_MESH_SLOTS; ++i) { + mm->output_cur[0][i] = 0; + mm->output_buffer[0][i] = 0; + } +} + +void stbvox_set_buffer(stbvox_mesh_maker *mm, int mesh, int slot, void *buffer, size_t len) +{ + int i; + stbvox_bring_up_to_date(mm); + mm->output_buffer[mesh][slot] = (char *) buffer; + mm->output_cur [mesh][slot] = (char *) buffer; + mm->output_len [mesh][slot] = (int) len; + mm->output_end [mesh][slot] = (char *) buffer + len; + for (i=0; i < STBVOX_MAX_MESH_SLOTS; ++i) { + if (mm->output_buffer[mesh][i]) { + assert(mm->output_len[mesh][i] / mm->output_size[mesh][i] == mm->output_len[mesh][slot] / mm->output_size[mesh][slot]); + } + } +} + +void stbvox_set_default_mesh(stbvox_mesh_maker *mm, int mesh) +{ + mm->default_mesh = mesh; +} + +int stbvox_get_quad_count(stbvox_mesh_maker *mm, int mesh) +{ + return (int) ((mm->output_cur[mesh][0] - mm->output_buffer[mesh][0]) / mm->output_size[mesh][0]); +} + +stbvox_input_description *stbvox_get_input_description(stbvox_mesh_maker *mm) +{ + return &mm->input; +} + +void stbvox_set_input_range(stbvox_mesh_maker *mm, int x0, int y0, int z0, int x1, int y1, int z1) +{ + mm->x0 = x0; + mm->y0 = y0; + mm->z0 = z0; + + mm->x1 = x1; + mm->y1 = y1; + mm->z1 = z1; + + mm->cur_x = x0; + mm->cur_y = y0; + mm->cur_z = z0; + + // @TODO validate that this range is representable in this mode +} + +void stbvox_get_transform(stbvox_mesh_maker *mm, float transform[3][3]) +{ + // scale + transform[0][0] = 1.0; + transform[0][1] = 1.0; + #if STBVOX_CONFIG_PRECISION_Z==1 + transform[0][2] = 0.5f; + #else + transform[0][2] = 1.0f; + #endif + // translation + transform[1][0] = (float) (mm->pos_x); + transform[1][1] = (float) (mm->pos_y); + transform[1][2] = (float) (mm->pos_z); + // texture coordinate projection translation + transform[2][0] = (float) (mm->pos_x & 255); // @TODO depends on max texture scale + transform[2][1] = (float) (mm->pos_y & 255); + transform[2][2] = (float) (mm->pos_z & 255); +} + +void stbvox_get_bounds(stbvox_mesh_maker *mm, float bounds[2][3]) +{ + bounds[0][0] = (float) (mm->pos_x + mm->x0); + bounds[0][1] = (float) (mm->pos_y + mm->y0); + bounds[0][2] = (float) (mm->pos_z + mm->z0); + bounds[1][0] = (float) (mm->pos_x + mm->x1); + bounds[1][1] = (float) (mm->pos_y + mm->y1); + bounds[1][2] = (float) (mm->pos_z + mm->z1); +} + +void stbvox_set_mesh_coordinates(stbvox_mesh_maker *mm, int x, int y, int z) +{ + mm->pos_x = x; + mm->pos_y = y; + mm->pos_z = z; +} + +void stbvox_set_input_stride(stbvox_mesh_maker *mm, int x_stride_in_bytes, int y_stride_in_bytes) +{ + int f,v; + mm->x_stride_in_bytes = x_stride_in_bytes; + mm->y_stride_in_bytes = y_stride_in_bytes; + for (f=0; f < 6; ++f) { + for (v=0; v < 4; ++v) { + mm->cube_vertex_offset[f][v] = stbvox_vertex_vector[f][v][0] * mm->x_stride_in_bytes + + stbvox_vertex_vector[f][v][1] * mm->y_stride_in_bytes + + stbvox_vertex_vector[f][v][2] ; + mm->vertex_gather_offset[f][v] = (stbvox_vertex_vector[f][v][0]-1) * mm->x_stride_in_bytes + + (stbvox_vertex_vector[f][v][1]-1) * mm->y_stride_in_bytes + + (stbvox_vertex_vector[f][v][2]-1) ; + } + } +} + +///////////////////////////////////////////////////////////////////////////// +// +// offline computation of tables +// + +#if 0 +// compute optimized vheight table +static char *normal_names[32] = +{ + 0,0,0,0,"u ",0, "eu ",0, + 0,0,0,0,"ne_u",0, "nu ",0, + 0,0,0,0,"nw_u",0, "wu ",0, + 0,0,0,0,"sw_u",0, "su ",0, +}; + +static char *find_best_normal(float x, float y, float z) +{ + int best_slot = 4; + float best_dot = 0; + int i; + for (i=0; i < 32; ++i) { + if (normal_names[i]) { + float dot = x * stbvox_default_normals[i][0] + y * stbvox_default_normals[i][1] + z * stbvox_default_normals[i][2]; + if (dot > best_dot) { + best_dot = dot; + best_slot = i; + } + } + } + return normal_names[best_slot]; +} + +int main(int argc, char **argv) +{ + int sw,se,nw,ne; + for (ne=0; ne < 4; ++ne) { + for (nw=0; nw < 4; ++nw) { + for (se=0; se < 4; ++se) { + printf(" { "); + for (sw=0; sw < 4; ++sw) { + float x = (float) (nw + sw - ne - se); + float y = (float) (sw + se - nw - ne); + float z = 2; + printf("STBVF_%s, ", find_best_normal(x,y,z)); + } + printf("},\n"); + } + } + } + return 0; +} +#endif + +// @TODO +// +// - test API for texture rotation on side faces +// - API for texture rotation on top & bottom +// - better culling of vheight faces with vheight neighbors +// - better culling of non-vheight faces with vheight neighbors +// - gather vertex lighting from slopes correctly +// - better support texture edge_clamp: currently if you fall +// exactly on 1.0 you get wrapped incorrectly; this is rare, but +// can avoid: compute texcoords in vertex shader, offset towards +// center before modding, need 2 bits per vertex to know offset direction) +// - other mesh modes (10,6,4-byte quads) +// +// +// With TexBuffer for the fixed vertex data, we can actually do +// minecrafty non-blocks like stairs -- we still probably only +// want 256 or so, so we can't do the equivalent of all the vheight +// combos, but that's ok. The 256 includes baked rotations, but only +// some of them need it, and lots of block types share some faces. +// +// mode 5 (6 bytes): mode 6 (6 bytes) +// x:7 x:6 +// y:7 y:6 +// z:6 z:6 +// tex1:8 tex1:8 +// tex2:8 tex2:7 +// color:8 color:8 +// face:4 face:7 +// +// +// side faces (all x4) top&bottom faces (2x) internal faces (1x) +// 1 regular 1 regular +// 2 slabs 2 +// 8 stairs 4 stairs 16 +// 4 diag side 8 +// 4 upper diag side 8 +// 4 lower diag side 8 +// 4 crossed pairs +// +// 23*4 + 5*4 + 46 +// == 92 + 20 + 46 = 158 +// +// Must drop 30 of them to fit in 7 bits: +// ceiling half diagonals: 16+8 = 24 +// Need to get rid of 6 more. +// ceiling diagonals: 8+4 = 12 +// This brings it to 122, so can add a crossed-pair variant. +// (diagonal and non-diagonal, or randomly offset) +// Or carpet, which would be 5 more. +// +// +// Mode 4 (10 bytes): +// v: z:2,light:6 +// f: x:6,y:6,z:7, t1:8,t2:8,c:8,f:5 +// +// Mode ? (10 bytes) +// v: xyz:5 (27 values), light:3 +// f: x:7,y:7,z:6, t1:8,t2:8,c:8,f:4 +// (v: x:2,y:2,z:2,light:2) + +#endif // STB_VOXEL_RENDER_IMPLEMENTATION + +/* +------------------------------------------------------------------------------ +This software is available under 2 licenses -- choose whichever you prefer. +------------------------------------------------------------------------------ +ALTERNATIVE A - MIT License +Copyright (c) 2017 Sean Barrett +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is furnished to do +so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +------------------------------------------------------------------------------ +ALTERNATIVE B - Public Domain (www.unlicense.org) +This is free and unencumbered software released into the public domain. +Anyone is free to copy, modify, publish, use, compile, sell, or distribute this +software, either in source code form or as a compiled binary, for any purpose, +commercial or non-commercial, and by any means. +In jurisdictions that recognize copyright laws, the author or authors of this +software dedicate any and all copyright interest in the software to the public +domain. We make this dedication for the benefit of the public at large and to +the detriment of our heirs and successors. We intend this dedication to be an +overt act of relinquishment in perpetuity of all present and future rights to +this software under copyright law. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN +ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +------------------------------------------------------------------------------ +*/ diff --git a/tests/data/c/tinyexpr/tinyexpr.c b/tests/data/c/tinyexpr/tinyexpr.c new file mode 100644 index 000000000..812583a18 --- /dev/null +++ b/tests/data/c/tinyexpr/tinyexpr.c @@ -0,0 +1,735 @@ +// SPDX-License-Identifier: Zlib +/* + * TINYEXPR - Tiny recursive descent parser and evaluation engine in C + * + * Copyright (c) 2015-2020 Lewis Van Winkle + * + * http://CodePlea.com + * + * This software is provided 'as-is', without any express or implied + * warranty. In no event will the authors be held liable for any damages + * arising from the use of this software. + * + * Permission is granted to anyone to use this software for any purpose, + * including commercial applications, and to alter it and redistribute it + * freely, subject to the following restrictions: + * + * 1. The origin of this software must not be misrepresented; you must not + * claim that you wrote the original software. If you use this software + * in a product, an acknowledgement in the product documentation would be + * appreciated but is not required. + * 2. Altered source versions must be plainly marked as such, and must not be + * misrepresented as being the original software. + * 3. This notice may not be removed or altered from any source distribution. + */ + +/* COMPILE TIME OPTIONS */ + +/* Exponentiation associativity: +For a^b^c = (a^b)^c and -a^b = (-a)^b do nothing. +For a^b^c = a^(b^c) and -a^b = -(a^b) uncomment the next line.*/ +/* #define TE_POW_FROM_RIGHT */ + +/* Logarithms +For log = base 10 log do nothing +For log = natural log uncomment the next line. */ +/* #define TE_NAT_LOG */ + +#include "tinyexpr.h" +#include +#include +#include +#include +#include +#include + +#ifndef NAN +#define NAN (0.0/0.0) +#endif + +#ifndef INFINITY +#define INFINITY (1.0/0.0) +#endif + + +typedef double (*te_fun2)(double, double); + +enum { + TOK_NULL = TE_CLOSURE7+1, TOK_ERROR, TOK_END, TOK_SEP, + TOK_OPEN, TOK_CLOSE, TOK_NUMBER, TOK_VARIABLE, TOK_INFIX +}; + + +enum {TE_CONSTANT = 1}; + + +typedef struct state { + const char *start; + const char *next; + int type; + union {double value; const double *bound; const void *function;}; + void *context; + + const te_variable *lookup; + int lookup_len; +} state; + + +#define TYPE_MASK(TYPE) ((TYPE)&0x0000001F) + +#define IS_PURE(TYPE) (((TYPE) & TE_FLAG_PURE) != 0) +#define IS_FUNCTION(TYPE) (((TYPE) & TE_FUNCTION0) != 0) +#define IS_CLOSURE(TYPE) (((TYPE) & TE_CLOSURE0) != 0) +#define ARITY(TYPE) ( ((TYPE) & (TE_FUNCTION0 | TE_CLOSURE0)) ? ((TYPE) & 0x00000007) : 0 ) +#define NEW_EXPR(type, ...) new_expr((type), (const te_expr*[]){__VA_ARGS__}) +#define CHECK_NULL(ptr, ...) if ((ptr) == NULL) { __VA_ARGS__; return NULL; } + +static te_expr *new_expr(const int type, const te_expr *parameters[]) { + const int arity = ARITY(type); + const int psize = sizeof(void*) * arity; + const int size = (sizeof(te_expr) - sizeof(void*)) + psize + (IS_CLOSURE(type) ? sizeof(void*) : 0); + te_expr *ret = malloc(size); + CHECK_NULL(ret); + + memset(ret, 0, size); + if (arity && parameters) { + memcpy(ret->parameters, parameters, psize); + } + ret->type = type; + ret->bound = 0; + return ret; +} + + +void te_free_parameters(te_expr *n) { + if (!n) return; + switch (TYPE_MASK(n->type)) { + case TE_FUNCTION7: case TE_CLOSURE7: te_free(n->parameters[6]); /* Falls through. */ + case TE_FUNCTION6: case TE_CLOSURE6: te_free(n->parameters[5]); /* Falls through. */ + case TE_FUNCTION5: case TE_CLOSURE5: te_free(n->parameters[4]); /* Falls through. */ + case TE_FUNCTION4: case TE_CLOSURE4: te_free(n->parameters[3]); /* Falls through. */ + case TE_FUNCTION3: case TE_CLOSURE3: te_free(n->parameters[2]); /* Falls through. */ + case TE_FUNCTION2: case TE_CLOSURE2: te_free(n->parameters[1]); /* Falls through. */ + case TE_FUNCTION1: case TE_CLOSURE1: te_free(n->parameters[0]); + } +} + + +void te_free(te_expr *n) { + if (!n) return; + te_free_parameters(n); + free(n); +} + + +static double pi(void) {return 3.14159265358979323846;} +static double e(void) {return 2.71828182845904523536;} +static double fac(double a) {/* simplest version of fac */ + if (a < 0.0) + return NAN; + if (a > UINT_MAX) + return INFINITY; + unsigned int ua = (unsigned int)(a); + unsigned long int result = 1, i; + for (i = 1; i <= ua; i++) { + if (i > ULONG_MAX / result) + return INFINITY; + result *= i; + } + return (double)result; +} +static double ncr(double n, double r) { + if (n < 0.0 || r < 0.0 || n < r) return NAN; + if (n > UINT_MAX || r > UINT_MAX) return INFINITY; + unsigned long int un = (unsigned int)(n), ur = (unsigned int)(r), i; + unsigned long int result = 1; + if (ur > un / 2) ur = un - ur; + for (i = 1; i <= ur; i++) { + if (result > ULONG_MAX / (un - ur + i)) + return INFINITY; + result *= un - ur + i; + result /= i; + } + return result; +} +static double npr(double n, double r) {return ncr(n, r) * fac(r);} + +#ifdef _MSC_VER +#pragma function (ceil) +#pragma function (floor) +#endif + +static const te_variable functions[] = { + /* must be in alphabetical order */ + {"abs", fabs, TE_FUNCTION1 | TE_FLAG_PURE, 0}, + {"acos", acos, TE_FUNCTION1 | TE_FLAG_PURE, 0}, + {"asin", asin, TE_FUNCTION1 | TE_FLAG_PURE, 0}, + {"atan", atan, TE_FUNCTION1 | TE_FLAG_PURE, 0}, + {"atan2", atan2, TE_FUNCTION2 | TE_FLAG_PURE, 0}, + {"ceil", ceil, TE_FUNCTION1 | TE_FLAG_PURE, 0}, + {"cos", cos, TE_FUNCTION1 | TE_FLAG_PURE, 0}, + {"cosh", cosh, TE_FUNCTION1 | TE_FLAG_PURE, 0}, + {"e", e, TE_FUNCTION0 | TE_FLAG_PURE, 0}, + {"exp", exp, TE_FUNCTION1 | TE_FLAG_PURE, 0}, + {"fac", fac, TE_FUNCTION1 | TE_FLAG_PURE, 0}, + {"floor", floor, TE_FUNCTION1 | TE_FLAG_PURE, 0}, + {"ln", log, TE_FUNCTION1 | TE_FLAG_PURE, 0}, +#ifdef TE_NAT_LOG + {"log", log, TE_FUNCTION1 | TE_FLAG_PURE, 0}, +#else + {"log", log10, TE_FUNCTION1 | TE_FLAG_PURE, 0}, +#endif + {"log10", log10, TE_FUNCTION1 | TE_FLAG_PURE, 0}, + {"ncr", ncr, TE_FUNCTION2 | TE_FLAG_PURE, 0}, + {"npr", npr, TE_FUNCTION2 | TE_FLAG_PURE, 0}, + {"pi", pi, TE_FUNCTION0 | TE_FLAG_PURE, 0}, + {"pow", pow, TE_FUNCTION2 | TE_FLAG_PURE, 0}, + {"sin", sin, TE_FUNCTION1 | TE_FLAG_PURE, 0}, + {"sinh", sinh, TE_FUNCTION1 | TE_FLAG_PURE, 0}, + {"sqrt", sqrt, TE_FUNCTION1 | TE_FLAG_PURE, 0}, + {"tan", tan, TE_FUNCTION1 | TE_FLAG_PURE, 0}, + {"tanh", tanh, TE_FUNCTION1 | TE_FLAG_PURE, 0}, + {0, 0, 0, 0} +}; + +static const te_variable *find_builtin(const char *name, int len) { + int imin = 0; + int imax = sizeof(functions) / sizeof(te_variable) - 2; + + /*Binary search.*/ + while (imax >= imin) { + const int i = (imin + ((imax-imin)/2)); + int c = strncmp(name, functions[i].name, len); + if (!c) c = '\0' - functions[i].name[len]; + if (c == 0) { + return functions + i; + } else if (c > 0) { + imin = i + 1; + } else { + imax = i - 1; + } + } + + return 0; +} + +static const te_variable *find_lookup(const state *s, const char *name, int len) { + int iters; + const te_variable *var; + if (!s->lookup) return 0; + + for (var = s->lookup, iters = s->lookup_len; iters; ++var, --iters) { + if (strncmp(name, var->name, len) == 0 && var->name[len] == '\0') { + return var; + } + } + return 0; +} + + + +static double add(double a, double b) {return a + b;} +static double sub(double a, double b) {return a - b;} +static double mul(double a, double b) {return a * b;} +static double divide(double a, double b) {return a / b;} +static double negate(double a) {return -a;} +static double comma(double a, double b) {(void)a; return b;} + + +void next_token(state *s) { + s->type = TOK_NULL; + + do { + + if (!*s->next){ + s->type = TOK_END; + return; + } + + /* Try reading a number. */ + if ((s->next[0] >= '0' && s->next[0] <= '9') || s->next[0] == '.') { + s->value = strtod(s->next, (char**)&s->next); + s->type = TOK_NUMBER; + } else { + /* Look for a variable or builtin function call. */ + if (isalpha(s->next[0])) { + const char *start; + start = s->next; + while (isalpha(s->next[0]) || isdigit(s->next[0]) || (s->next[0] == '_')) s->next++; + + const te_variable *var = find_lookup(s, start, s->next - start); + if (!var) var = find_builtin(start, s->next - start); + + if (!var) { + s->type = TOK_ERROR; + } else { + switch(TYPE_MASK(var->type)) + { + case TE_VARIABLE: + s->type = TOK_VARIABLE; + s->bound = var->address; + break; + + case TE_CLOSURE0: case TE_CLOSURE1: case TE_CLOSURE2: case TE_CLOSURE3: /* Falls through. */ + case TE_CLOSURE4: case TE_CLOSURE5: case TE_CLOSURE6: case TE_CLOSURE7: /* Falls through. */ + s->context = var->context; /* Falls through. */ + + case TE_FUNCTION0: case TE_FUNCTION1: case TE_FUNCTION2: case TE_FUNCTION3: /* Falls through. */ + case TE_FUNCTION4: case TE_FUNCTION5: case TE_FUNCTION6: case TE_FUNCTION7: /* Falls through. */ + s->type = var->type; + s->function = var->address; + break; + } + } + + } else { + /* Look for an operator or special character. */ + switch (s->next++[0]) { + case '+': s->type = TOK_INFIX; s->function = add; break; + case '-': s->type = TOK_INFIX; s->function = sub; break; + case '*': s->type = TOK_INFIX; s->function = mul; break; + case '/': s->type = TOK_INFIX; s->function = divide; break; + case '^': s->type = TOK_INFIX; s->function = pow; break; + case '%': s->type = TOK_INFIX; s->function = fmod; break; + case '(': s->type = TOK_OPEN; break; + case ')': s->type = TOK_CLOSE; break; + case ',': s->type = TOK_SEP; break; + case ' ': case '\t': case '\n': case '\r': break; + default: s->type = TOK_ERROR; break; + } + } + } + } while (s->type == TOK_NULL); +} + + +static te_expr *list(state *s); +static te_expr *expr(state *s); +static te_expr *power(state *s); + +static te_expr *base(state *s) { + /* = | | {"(" ")"} | | "(" {"," } ")" | "(" ")" */ + te_expr *ret; + int arity; + + switch (TYPE_MASK(s->type)) { + case TOK_NUMBER: + ret = new_expr(TE_CONSTANT, 0); + CHECK_NULL(ret); + + ret->value = s->value; + next_token(s); + break; + + case TOK_VARIABLE: + ret = new_expr(TE_VARIABLE, 0); + CHECK_NULL(ret); + + ret->bound = s->bound; + next_token(s); + break; + + case TE_FUNCTION0: + case TE_CLOSURE0: + ret = new_expr(s->type, 0); + CHECK_NULL(ret); + + ret->function = s->function; + if (IS_CLOSURE(s->type)) ret->parameters[0] = s->context; + next_token(s); + if (s->type == TOK_OPEN) { + next_token(s); + if (s->type != TOK_CLOSE) { + s->type = TOK_ERROR; + } else { + next_token(s); + } + } + break; + + case TE_FUNCTION1: + case TE_CLOSURE1: + ret = new_expr(s->type, 0); + CHECK_NULL(ret); + + ret->function = s->function; + if (IS_CLOSURE(s->type)) ret->parameters[1] = s->context; + next_token(s); + ret->parameters[0] = power(s); + CHECK_NULL(ret->parameters[0], te_free(ret)); + break; + + case TE_FUNCTION2: case TE_FUNCTION3: case TE_FUNCTION4: + case TE_FUNCTION5: case TE_FUNCTION6: case TE_FUNCTION7: + case TE_CLOSURE2: case TE_CLOSURE3: case TE_CLOSURE4: + case TE_CLOSURE5: case TE_CLOSURE6: case TE_CLOSURE7: + arity = ARITY(s->type); + + ret = new_expr(s->type, 0); + CHECK_NULL(ret); + + ret->function = s->function; + if (IS_CLOSURE(s->type)) ret->parameters[arity] = s->context; + next_token(s); + + if (s->type != TOK_OPEN) { + s->type = TOK_ERROR; + } else { + int i; + for(i = 0; i < arity; i++) { + next_token(s); + ret->parameters[i] = expr(s); + CHECK_NULL(ret->parameters[i], te_free(ret)); + + if(s->type != TOK_SEP) { + break; + } + } + if(s->type != TOK_CLOSE || i != arity - 1) { + s->type = TOK_ERROR; + } else { + next_token(s); + } + } + + break; + + case TOK_OPEN: + next_token(s); + ret = list(s); + CHECK_NULL(ret); + + if (s->type != TOK_CLOSE) { + s->type = TOK_ERROR; + } else { + next_token(s); + } + break; + + default: + ret = new_expr(0, 0); + CHECK_NULL(ret); + + s->type = TOK_ERROR; + ret->value = NAN; + break; + } + + return ret; +} + + +static te_expr *power(state *s) { + /* = {("-" | "+")} */ + int sign = 1; + while (s->type == TOK_INFIX && (s->function == add || s->function == sub)) { + if (s->function == sub) sign = -sign; + next_token(s); + } + + te_expr *ret; + + if (sign == 1) { + ret = base(s); + } else { + te_expr *b = base(s); + CHECK_NULL(b); + + ret = NEW_EXPR(TE_FUNCTION1 | TE_FLAG_PURE, b); + CHECK_NULL(ret, te_free(b)); + + ret->function = negate; + } + + return ret; +} + +#ifdef TE_POW_FROM_RIGHT +static te_expr *factor(state *s) { + /* = {"^" } */ + te_expr *ret = power(s); + CHECK_NULL(ret); + + int neg = 0; + + if (ret->type == (TE_FUNCTION1 | TE_FLAG_PURE) && ret->function == negate) { + te_expr *se = ret->parameters[0]; + free(ret); + ret = se; + neg = 1; + } + + te_expr *insertion = 0; + + while (s->type == TOK_INFIX && (s->function == pow)) { + te_fun2 t = s->function; + next_token(s); + + if (insertion) { + /* Make exponentiation go right-to-left. */ + te_expr *p = power(s); + CHECK_NULL(p, te_free(ret)); + + te_expr *insert = NEW_EXPR(TE_FUNCTION2 | TE_FLAG_PURE, insertion->parameters[1], p); + CHECK_NULL(insert, te_free(p), te_free(ret)); + + insert->function = t; + insertion->parameters[1] = insert; + insertion = insert; + } else { + te_expr *p = power(s); + CHECK_NULL(p, te_free(ret)); + + te_expr *prev = ret; + ret = NEW_EXPR(TE_FUNCTION2 | TE_FLAG_PURE, ret, p); + CHECK_NULL(ret, te_free(p), te_free(prev)); + + ret->function = t; + insertion = ret; + } + } + + if (neg) { + te_expr *prev = ret; + ret = NEW_EXPR(TE_FUNCTION1 | TE_FLAG_PURE, ret); + CHECK_NULL(ret, te_free(prev)); + + ret->function = negate; + } + + return ret; +} +#else +static te_expr *factor(state *s) { + /* = {"^" } */ + te_expr *ret = power(s); + CHECK_NULL(ret); + + while (s->type == TOK_INFIX && (s->function == pow)) { + te_fun2 t = s->function; + next_token(s); + te_expr *p = power(s); + CHECK_NULL(p, te_free(ret)); + + te_expr *prev = ret; + ret = NEW_EXPR(TE_FUNCTION2 | TE_FLAG_PURE, ret, p); + CHECK_NULL(ret, te_free(p), te_free(prev)); + + ret->function = t; + } + + return ret; +} +#endif + + + +static te_expr *term(state *s) { + /* = {("*" | "/" | "%") } */ + te_expr *ret = factor(s); + CHECK_NULL(ret); + + while (s->type == TOK_INFIX && (s->function == mul || s->function == divide || s->function == fmod)) { + te_fun2 t = s->function; + next_token(s); + te_expr *f = factor(s); + CHECK_NULL(f, te_free(ret)); + + te_expr *prev = ret; + ret = NEW_EXPR(TE_FUNCTION2 | TE_FLAG_PURE, ret, f); + CHECK_NULL(ret, te_free(f), te_free(prev)); + + ret->function = t; + } + + return ret; +} + + +static te_expr *expr(state *s) { + /* = {("+" | "-") } */ + te_expr *ret = term(s); + CHECK_NULL(ret); + + while (s->type == TOK_INFIX && (s->function == add || s->function == sub)) { + te_fun2 t = s->function; + next_token(s); + te_expr *te = term(s); + CHECK_NULL(te, te_free(ret)); + + te_expr *prev = ret; + ret = NEW_EXPR(TE_FUNCTION2 | TE_FLAG_PURE, ret, te); + CHECK_NULL(ret, te_free(te), te_free(prev)); + + ret->function = t; + } + + return ret; +} + + +static te_expr *list(state *s) { + /* = {"," } */ + te_expr *ret = expr(s); + CHECK_NULL(ret); + + while (s->type == TOK_SEP) { + next_token(s); + te_expr *e = expr(s); + CHECK_NULL(e, te_free(ret)); + + te_expr *prev = ret; + ret = NEW_EXPR(TE_FUNCTION2 | TE_FLAG_PURE, ret, e); + CHECK_NULL(ret, te_free(e), te_free(prev)); + + ret->function = comma; + } + + return ret; +} + + +#define TE_FUN(...) ((double(*)(__VA_ARGS__))n->function) +#define M(e) te_eval(n->parameters[e]) + + +double te_eval(const te_expr *n) { + if (!n) return NAN; + + switch(TYPE_MASK(n->type)) { + case TE_CONSTANT: return n->value; + case TE_VARIABLE: return *n->bound; + + case TE_FUNCTION0: case TE_FUNCTION1: case TE_FUNCTION2: case TE_FUNCTION3: + case TE_FUNCTION4: case TE_FUNCTION5: case TE_FUNCTION6: case TE_FUNCTION7: + switch(ARITY(n->type)) { + case 0: return TE_FUN(void)(); + case 1: return TE_FUN(double)(M(0)); + case 2: return TE_FUN(double, double)(M(0), M(1)); + case 3: return TE_FUN(double, double, double)(M(0), M(1), M(2)); + case 4: return TE_FUN(double, double, double, double)(M(0), M(1), M(2), M(3)); + case 5: return TE_FUN(double, double, double, double, double)(M(0), M(1), M(2), M(3), M(4)); + case 6: return TE_FUN(double, double, double, double, double, double)(M(0), M(1), M(2), M(3), M(4), M(5)); + case 7: return TE_FUN(double, double, double, double, double, double, double)(M(0), M(1), M(2), M(3), M(4), M(5), M(6)); + default: return NAN; + } + + case TE_CLOSURE0: case TE_CLOSURE1: case TE_CLOSURE2: case TE_CLOSURE3: + case TE_CLOSURE4: case TE_CLOSURE5: case TE_CLOSURE6: case TE_CLOSURE7: + switch(ARITY(n->type)) { + case 0: return TE_FUN(void*)(n->parameters[0]); + case 1: return TE_FUN(void*, double)(n->parameters[1], M(0)); + case 2: return TE_FUN(void*, double, double)(n->parameters[2], M(0), M(1)); + case 3: return TE_FUN(void*, double, double, double)(n->parameters[3], M(0), M(1), M(2)); + case 4: return TE_FUN(void*, double, double, double, double)(n->parameters[4], M(0), M(1), M(2), M(3)); + case 5: return TE_FUN(void*, double, double, double, double, double)(n->parameters[5], M(0), M(1), M(2), M(3), M(4)); + case 6: return TE_FUN(void*, double, double, double, double, double, double)(n->parameters[6], M(0), M(1), M(2), M(3), M(4), M(5)); + case 7: return TE_FUN(void*, double, double, double, double, double, double, double)(n->parameters[7], M(0), M(1), M(2), M(3), M(4), M(5), M(6)); + default: return NAN; + } + + default: return NAN; + } + +} + +#undef TE_FUN +#undef M + +static void optimize(te_expr *n) { + /* Evaluates as much as possible. */ + if (n->type == TE_CONSTANT) return; + if (n->type == TE_VARIABLE) return; + + /* Only optimize out functions flagged as pure. */ + if (IS_PURE(n->type)) { + const int arity = ARITY(n->type); + int known = 1; + int i; + for (i = 0; i < arity; ++i) { + optimize(n->parameters[i]); + if (((te_expr*)(n->parameters[i]))->type != TE_CONSTANT) { + known = 0; + } + } + if (known) { + const double value = te_eval(n); + te_free_parameters(n); + n->type = TE_CONSTANT; + n->value = value; + } + } +} + + +te_expr *te_compile(const char *expression, const te_variable *variables, int var_count, int *error) { + state s; + s.start = s.next = expression; + s.lookup = variables; + s.lookup_len = var_count; + + next_token(&s); + te_expr *root = list(&s); + if (root == NULL) { + if (error) *error = -1; + return NULL; + } + + if (s.type != TOK_END) { + te_free(root); + if (error) { + *error = (s.next - s.start); + if (*error == 0) *error = 1; + } + return 0; + } else { + optimize(root); + if (error) *error = 0; + return root; + } +} + + +double te_interp(const char *expression, int *error) { + te_expr *n = te_compile(expression, 0, 0, error); + + double ret; + if (n) { + ret = te_eval(n); + te_free(n); + } else { + ret = NAN; + } + return ret; +} + +static void pn (const te_expr *n, int depth) { + int i, arity; + printf("%*s", depth, ""); + + switch(TYPE_MASK(n->type)) { + case TE_CONSTANT: printf("%f\n", n->value); break; + case TE_VARIABLE: printf("bound %p\n", n->bound); break; + + case TE_FUNCTION0: case TE_FUNCTION1: case TE_FUNCTION2: case TE_FUNCTION3: + case TE_FUNCTION4: case TE_FUNCTION5: case TE_FUNCTION6: case TE_FUNCTION7: + case TE_CLOSURE0: case TE_CLOSURE1: case TE_CLOSURE2: case TE_CLOSURE3: + case TE_CLOSURE4: case TE_CLOSURE5: case TE_CLOSURE6: case TE_CLOSURE7: + arity = ARITY(n->type); + printf("f%d", arity); + for(i = 0; i < arity; i++) { + printf(" %p", n->parameters[i]); + } + printf("\n"); + for(i = 0; i < arity; i++) { + pn(n->parameters[i], depth + 1); + } + break; + } +} + + +void te_print(const te_expr *n) { + pn(n, 0); +} + diff --git a/tests/data/c/tinyexpr/tinyexpr.h b/tests/data/c/tinyexpr/tinyexpr.h new file mode 100644 index 000000000..053620c47 --- /dev/null +++ b/tests/data/c/tinyexpr/tinyexpr.h @@ -0,0 +1,88 @@ +// SPDX-License-Identifier: Zlib +/* + * TINYEXPR - Tiny recursive descent parser and evaluation engine in C + * + * Copyright (c) 2015-2020 Lewis Van Winkle + * + * http://CodePlea.com + * + * This software is provided 'as-is', without any express or implied + * warranty. In no event will the authors be held liable for any damages + * arising from the use of this software. + * + * Permission is granted to anyone to use this software for any purpose, + * including commercial applications, and to alter it and redistribute it + * freely, subject to the following restrictions: + * + * 1. The origin of this software must not be misrepresented; you must not + * claim that you wrote the original software. If you use this software + * in a product, an acknowledgement in the product documentation would be + * appreciated but is not required. + * 2. Altered source versions must be plainly marked as such, and must not be + * misrepresented as being the original software. + * 3. This notice may not be removed or altered from any source distribution. + */ + +#ifndef TINYEXPR_H +#define TINYEXPR_H + + +#ifdef __cplusplus +extern "C" { +#endif + + + +typedef struct te_expr { + int type; + union {double value; const double *bound; const void *function;}; + void *parameters[1]; +} te_expr; + + +enum { + TE_VARIABLE = 0, + + TE_FUNCTION0 = 8, TE_FUNCTION1, TE_FUNCTION2, TE_FUNCTION3, + TE_FUNCTION4, TE_FUNCTION5, TE_FUNCTION6, TE_FUNCTION7, + + TE_CLOSURE0 = 16, TE_CLOSURE1, TE_CLOSURE2, TE_CLOSURE3, + TE_CLOSURE4, TE_CLOSURE5, TE_CLOSURE6, TE_CLOSURE7, + + TE_FLAG_PURE = 32 +}; + +typedef struct te_variable { + const char *name; + const void *address; + int type; + void *context; +} te_variable; + + + +/* Parses the input expression, evaluates it, and frees it. */ +/* Returns NaN on error. */ +double te_interp(const char *expression, int *error); + +/* Parses the input expression and binds variables. */ +/* Returns NULL on error. */ +te_expr *te_compile(const char *expression, const te_variable *variables, int var_count, int *error); + +/* Evaluates the expression. */ +double te_eval(const te_expr *n); + +/* Prints debugging information on the syntax tree. */ +void te_print(const te_expr *n); + +/* Frees the expression. */ +/* This is safe to call on NULL pointers. */ +void te_free(te_expr *n); + + +#ifdef __cplusplus +} +#endif + +#endif /*TINYEXPR_H*/ + diff --git a/tests/parser/c/README.md b/tests/parser/c/README.md new file mode 100644 index 000000000..b11d76c76 --- /dev/null +++ b/tests/parser/c/README.md @@ -0,0 +1,85 @@ +# C Parser Tests + +This directory contains active tests for the implemented partial C parser and +narrowly scoped skipped tests for genuinely deferred input/corpus work. + +Unskip tests one capability at a time on a short-lived `c-parser/*` branch, then +merge only into `c-parser/main`. + +Guidelines: + +- keep these tests separate from the Fortran parser tests +- keep wrap-readiness tests under `tests/semantics`, not under parser tests +- do not import `c_parser` at module import time while a roadmap test is skipped +- activate or remove roadmap tests once matching active coverage lands +- add fixtures and goldens only when the corresponding schema is stable +- keep cJSON as the first real-world corpus target once corpus tests start + +## Intentional Skips + +The normal parser test run retains skips only for the pinned/provenanced +cJSON corpus roadmap and compiler-preprocessed `.i`/`#line` behavior, which +are not implemented yet. CLI, public API, and current project-resolution +coverage are active. + +When `C_PARSER_UPDATE_GOLDENS=1` is set, golden inventory checks are skipped +while their corresponding comparison tests rewrite the expected output. Those +update-mode skips are workflow behavior, not unsupported parser input. + +## Parser Goldens + +Active parser goldens cover grouped projects from `tests/data/c/general/`, +`tests/data/c/json/`, `tests/data/c/tinyexpr/`, `tests/data/c/linmath/`, and +`tests/data/c/nanosvg/`, plus top-level C inputs from `tests/data/c/stb/`. +Files sharing a stem are parsed together as a project, with a `.c` +translation-unit input ordered before its `.h` sibling. +Explicit dependent header groups are ordered with the included header before +the dependent header, as in `nanosvg.h` then `nanosvgrast.h`. A source or +header without a matching sibling is serialized as a one-file project. +STB inputs remain separate one-file projects because that distribution is a +collection of independent single-file libraries. +The current parser records the resolved include edge but parses each project +member separately; it does not yet preprocess header contents into the source +translation unit. +The third-party-library inputs are realistic regression inputs for the partial +parser; diagnostics in their goldens are expected and do not claim full +library support. + +Each logical project produces one output, for example `math_api.json` for +`math_api.c` plus `math_api.h`, `cJSON.json` for the cJSON pair, and +`jsmn.json` or `linmath.json` for unpaired headers. The NanoSVG header pair +produces `nanosvg.json`; STB produces one golden per top-level library input. + +Regenerate all parser goldens with: + +```bash +python -m tests.parser.c.generate_c_parser_goldens +``` + +Regenerate selected projects by naming either input relative to +`tests/data/c/`; matching siblings are included automatically: + +```bash +python -m tests.parser.c.generate_c_parser_goldens general/math_api.c json/cJSON.h +``` + +The fixture comparison test also supports the explicit update mode: + +```bash +C_PARSER_UPDATE_GOLDENS=1 python -m pytest -q tests/parser/c/test_c_fixture_suite.py +``` + +## Error Goldens + +Fatal diagnostic fixtures live in `tests/data/c/errors/parser/` and their +expected metadata lives in `fixtures/errors/`. Regenerate them with: + +```bash +python -m tests.parser.c.errors.generate_c_parser_error_goldens +``` + +or update through the active regression test: + +```bash +C_PARSER_UPDATE_GOLDENS=1 python -m pytest -q tests/parser/c/test_c_error_fixture_suite.py +``` diff --git a/tests/parser/c/errors/generate_c_parser_error_goldens.py b/tests/parser/c/errors/generate_c_parser_error_goldens.py new file mode 100644 index 000000000..71ab9a1d1 --- /dev/null +++ b/tests/parser/c/errors/generate_c_parser_error_goldens.py @@ -0,0 +1,75 @@ +# -*- coding: utf-8 -*- +"""Generate/update golden files for C parser error fixtures.""" + +from __future__ import annotations + +import json +import sys +from pathlib import Path + +from c_parser import CParseError, parse_c_file + + +_TESTS_DIR = Path(__file__).resolve().parents[3] +_ERRORS_DIR = _TESTS_DIR / "data" / "c" / "errors" / "parser" +_EXPECTED_ERRORS_DIR = _TESTS_DIR / "parser" / "c" / "fixtures" / "errors" +_SOURCE_SUFFIXES = {".c", ".h", ".i"} + + +def _serialize_error_fixture(fixture: Path) -> dict: + source = fixture.read_text(encoding="utf-8") + try: + parse_c_file(source, filename=fixture.name) + except CParseError as exc: + return { + "parser": "parse_c_file", + "error_type": "CParseError", + "message_contains": [exc.base_message], + "diagnostic_contains": [ + f"error[{exc.code}]", + exc.base_message, + exc.source_line.strip() if exc.source_line else "", + ], + } + raise SystemExit( + f"ERROR: {fixture.name} did not raise CParseError; " + "error fixture files must trigger a parse error." + ) + + +def _output_path_for_fixture(fixture: Path) -> Path: + return _EXPECTED_ERRORS_DIR / f"{fixture.name}.json" + + +def main() -> None: + requested = sys.argv[1:] + if requested: + fixtures = [] + for item in requested: + fixture = Path(item) + if not fixture.is_absolute(): + fixture = _ERRORS_DIR / fixture + if fixture.suffix.lower() not in _SOURCE_SUFFIXES: + raise SystemExit(f"C error fixtures must use .c, .h, or .i: {fixture}") + fixtures.append(fixture) + else: + fixtures = sorted( + fixture + for fixture in _ERRORS_DIR.glob("*") + if fixture.is_file() and fixture.suffix.lower() in _SOURCE_SUFFIXES + ) + if not fixtures: + raise SystemExit("No C parser error fixtures found") + + _EXPECTED_ERRORS_DIR.mkdir(parents=True, exist_ok=True) + for fixture in fixtures: + if not fixture.exists(): + raise SystemExit(f"Fixture does not exist: {fixture}") + payload = _serialize_error_fixture(fixture) + out = _output_path_for_fixture(fixture) + out.write_text(json.dumps(payload, indent=2) + "\n", encoding="utf-8") + print(f"updated {out}") + + +if __name__ == "__main__": + main() diff --git a/tests/parser/c/fixtures/errors/invalid_type_specifiers.h.json b/tests/parser/c/fixtures/errors/invalid_type_specifiers.h.json new file mode 100644 index 000000000..a28fe9b60 --- /dev/null +++ b/tests/parser/c/fixtures/errors/invalid_type_specifiers.h.json @@ -0,0 +1,12 @@ +{ + "parser": "parse_c_file", + "error_type": "CParseError", + "message_contains": [ + "Invalid type specifier sequence 'unsigned float'." + ], + "diagnostic_contains": [ + "error[CPARSE003]", + "Invalid type specifier sequence 'unsigned float'.", + "unsigned float value;" + ] +} diff --git a/tests/parser/c/fixtures/general/basic_array_update.json b/tests/parser/c/fixtures/general/basic_array_update.json new file mode 100644 index 000000000..1d64c3805 --- /dev/null +++ b/tests/parser/c/fixtures/general/basic_array_update.json @@ -0,0 +1,766 @@ +{ + "files": { + "general/basic_array_update.c": { + "filename": "general/basic_array_update.c", + "language": "c", + "parser_status": "partial", + "preprocessing": "raw", + "functions": [ + { + "name": "add1", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "double x[static 1]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "double x[static 1]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "1", + "is_static_minimum": true, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "general/basic_array_update.c", + "line": 3, + "column": 1, + "source_line": "void add1(int n, double x[static 1])" + }, + "start": { + "filename": "general/basic_array_update.c", + "line": 3, + "column": 1, + "source_line": "void add1(int n, double x[static 1])" + }, + "end": { + "filename": "general/basic_array_update.c", + "line": 8, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "general/basic_array_update.h", + "line": 4, + "column": 1, + "source_line": "void add1(int n, double x[static 1]);" + } + ] + }, + { + "name": "add1_strided", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "double *restrict x", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "restrict" + ], + "source_text": "" + }, + { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "double *restrict x", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "restrict" + ], + "source_text": "" + }, + { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "incx", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int incx" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int incx" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "general/basic_array_update.c", + "line": 10, + "column": 1, + "source_line": "void add1_strided(int n, double *restrict x, int incx)" + }, + "start": { + "filename": "general/basic_array_update.c", + "line": 10, + "column": 1, + "source_line": "void add1_strided(int n, double *restrict x, int incx)" + }, + "end": { + "filename": "general/basic_array_update.c", + "line": 15, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "general/basic_array_update.h", + "line": 5, + "column": 1, + "source_line": "void add1_strided(int n, double *restrict x, int incx);" + } + ] + } + ], + "structs": [], + "unions": [], + "enums": [], + "typedefs": [], + "variables": [], + "macros": [], + "includes": [ + { + "target": "basic_array_update.h", + "kind": "local", + "resolved_path": "general/basic_array_update.h", + "source_location": { + "filename": "general/basic_array_update.c", + "line": 1, + "column": 1, + "source_line": "#include \"basic_array_update.h\"" + } + } + ], + "raw_directives": [], + "macro_dependencies": [], + "diagnostics": [] + }, + "general/basic_array_update.h": { + "filename": "general/basic_array_update.h", + "language": "c", + "parser_status": "partial", + "preprocessing": "raw", + "functions": [ + { + "name": "add1", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "double x[static 1]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "double x[static 1]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "1", + "is_static_minimum": true, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": false, + "prototype_style": "prototype", + "source_location": { + "filename": "general/basic_array_update.h", + "line": 4, + "column": 1, + "source_line": "void add1(int n, double x[static 1]);" + }, + "start": { + "filename": "general/basic_array_update.h", + "line": 4, + "column": 1, + "source_line": "void add1(int n, double x[static 1]);" + }, + "end": null, + "declaration_locations": [] + }, + { + "name": "add1_strided", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "double *restrict x", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "restrict" + ], + "source_text": "" + }, + { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "double *restrict x", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "restrict" + ], + "source_text": "" + }, + { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "incx", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int incx" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int incx" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": false, + "prototype_style": "prototype", + "source_location": { + "filename": "general/basic_array_update.h", + "line": 5, + "column": 1, + "source_line": "void add1_strided(int n, double *restrict x, int incx);" + }, + "start": { + "filename": "general/basic_array_update.h", + "line": 5, + "column": 1, + "source_line": "void add1_strided(int n, double *restrict x, int incx);" + }, + "end": null, + "declaration_locations": [] + } + ], + "structs": [], + "unions": [], + "enums": [], + "typedefs": [], + "variables": [], + "macros": [ + { + "name": "X2PY_GENERAL_BASIC_ARRAY_UPDATE_H", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "general/basic_array_update.h", + "line": 2, + "column": 1, + "source_line": "#define X2PY_GENERAL_BASIC_ARRAY_UPDATE_H" + } + } + ], + "includes": [], + "raw_directives": [ + { + "directive": "ifndef", + "argument": "X2PY_GENERAL_BASIC_ARRAY_UPDATE_H", + "source_location": { + "filename": "general/basic_array_update.h", + "line": 1, + "column": 1, + "source_line": "#ifndef X2PY_GENERAL_BASIC_ARRAY_UPDATE_H" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "general/basic_array_update.h", + "line": 7, + "column": 1, + "source_line": "#endif" + } + } + ], + "macro_dependencies": [], + "diagnostics": [] + } + }, + "functions": { + "add1": { + "name": "add1", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "double x[static 1]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "double x[static 1]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "1", + "is_static_minimum": true, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "general/basic_array_update.c", + "line": 3, + "column": 1, + "source_line": "void add1(int n, double x[static 1])" + }, + "start": { + "filename": "general/basic_array_update.c", + "line": 3, + "column": 1, + "source_line": "void add1(int n, double x[static 1])" + }, + "end": { + "filename": "general/basic_array_update.c", + "line": 8, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "general/basic_array_update.h", + "line": 4, + "column": 1, + "source_line": "void add1(int n, double x[static 1]);" + } + ] + }, + "add1_strided": { + "name": "add1_strided", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "double *restrict x", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "restrict" + ], + "source_text": "" + }, + { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "double *restrict x", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "restrict" + ], + "source_text": "" + }, + { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "incx", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int incx" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int incx" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "general/basic_array_update.c", + "line": 10, + "column": 1, + "source_line": "void add1_strided(int n, double *restrict x, int incx)" + }, + "start": { + "filename": "general/basic_array_update.c", + "line": 10, + "column": 1, + "source_line": "void add1_strided(int n, double *restrict x, int incx)" + }, + "end": { + "filename": "general/basic_array_update.c", + "line": 15, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "general/basic_array_update.h", + "line": 5, + "column": 1, + "source_line": "void add1_strided(int n, double *restrict x, int incx);" + } + ] + } + }, + "structs": {}, + "unions": {}, + "enums": {}, + "typedefs": {}, + "variables": {}, + "macros": { + "X2PY_GENERAL_BASIC_ARRAY_UPDATE_H": { + "name": "X2PY_GENERAL_BASIC_ARRAY_UPDATE_H", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "general/basic_array_update.h", + "line": 2, + "column": 1, + "source_line": "#define X2PY_GENERAL_BASIC_ARRAY_UPDATE_H" + } + } + }, + "includes": { + "general/basic_array_update.c:basic_array_update.h": { + "target": "basic_array_update.h", + "kind": "local", + "resolved_path": "general/basic_array_update.h", + "source_location": { + "filename": "general/basic_array_update.c", + "line": 1, + "column": 1, + "source_line": "#include \"basic_array_update.h\"" + } + } + }, + "functions_by_file": { + "general/basic_array_update.c": [ + "add1", + "add1_strided" + ], + "general/basic_array_update.h": [ + "add1", + "add1_strided" + ] + }, + "enum_constants": {}, + "include_graph": { + "general/basic_array_update.c": [ + "general/basic_array_update.h" + ], + "general/basic_array_update.h": [] + }, + "system_includes": { + "general/basic_array_update.c": [], + "general/basic_array_update.h": [] + }, + "unresolved_includes": { + "general/basic_array_update.c": [], + "general/basic_array_update.h": [] + }, + "header_source_pairs": { + "general/basic_array_update.h": [ + "general/basic_array_update.c" + ] + }, + "diagnostics": [] +} diff --git a/tests/parser/c/fixtures/general/c_richer_features.json b/tests/parser/c/fixtures/general/c_richer_features.json new file mode 100644 index 000000000..0d868911a --- /dev/null +++ b/tests/parser/c/fixtures/general/c_richer_features.json @@ -0,0 +1,1485 @@ +{ + "files": { + "general/c_richer_features.h": { + "filename": "general/c_richer_features.h", + "language": "c", + "parser_status": "partial", + "preprocessing": "raw", + "functions": [ + { + "name": "x2py_fast_path", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": false, + "prototype_style": "prototype", + "source_location": { + "filename": "general/c_richer_features.h", + "line": 10, + "column": 1, + "source_line": "int x2py_fast_path(void);" + }, + "start": { + "filename": "general/c_richer_features.h", + "line": 10, + "column": 1, + "source_line": "int x2py_fast_path(void);" + }, + "end": null, + "declaration_locations": [] + }, + { + "name": "x2py_slow_path", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": false, + "prototype_style": "prototype", + "source_location": { + "filename": "general/c_richer_features.h", + "line": 12, + "column": 1, + "source_line": "int x2py_slow_path(void);" + }, + "start": { + "filename": "general/c_richer_features.h", + "line": 12, + "column": 1, + "source_line": "int x2py_slow_path(void);" + }, + "end": null, + "declaration_locations": [] + }, + { + "name": "x2py_register_callback", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "context", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "x2py_context_handle", + "name": "x2py_context_handle", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "typedef struct x2py_context *x2py_context_handle", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": "x2py_context", + "members": [], + "anonymous_id": null, + "is_incomplete": true, + "source_location": { + "filename": "general/c_richer_features.h", + "line": 35, + "column": 1, + "source_line": "struct x2py_context;" + } + } + ] + }, + "source_location": { + "filename": "general/c_richer_features.h", + "line": 36, + "column": 1, + "source_line": "typedef struct x2py_context *x2py_context_handle;" + }, + "declaration_locations": [] + }, + "declared_type": { + "reference": "x2py_context_handle" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "callback", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void (*callback)(void *userdata, enum x2py_status status)", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFunctionType", + "qualifiers": [], + "source_text": "void", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameter_types": [ + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *userdata", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + { + "model": "CEnum", + "qualifiers": [], + "source_text": "", + "name": "x2py_status", + "constants": [ + { + "name": "X2PY_STATUS_OK", + "value": "0", + "source_location": { + "filename": "general/c_richer_features.h", + "line": 17, + "column": 1, + "source_line": "enum x2py_status {" + } + }, + { + "name": "X2PY_STATUS_RETRY", + "value": "1", + "source_location": { + "filename": "general/c_richer_features.h", + "line": 17, + "column": 1, + "source_line": "enum x2py_status {" + } + }, + { + "name": "X2PY_STATUS_ERROR", + "value": "-1", + "source_location": { + "filename": "general/c_richer_features.h", + "line": 17, + "column": 1, + "source_line": "enum x2py_status {" + } + } + ], + "anonymous_id": null, + "source_location": { + "filename": "general/c_richer_features.h", + "line": 17, + "column": 1, + "source_line": "enum x2py_status {" + } + } + ], + "is_variadic": false, + "prototype_style": "prototype" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void (*callback)(void *userdata, enum x2py_status status)", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFunctionType", + "qualifiers": [], + "source_text": "void", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameter_types": [ + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *userdata", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + { + "reference": "enum x2py_status" + } + ], + "is_variadic": false, + "prototype_style": "prototype" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "userdata", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *userdata", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *userdata", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": false, + "prototype_style": "prototype", + "source_location": { + "filename": "general/c_richer_features.h", + "line": 47, + "column": 1, + "source_line": "int x2py_register_callback(" + }, + "start": { + "filename": "general/c_richer_features.h", + "line": 47, + "column": 1, + "source_line": "int x2py_register_callback(" + }, + "end": null, + "declaration_locations": [] + }, + { + "name": "x2py_status_message", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "parameters": [ + { + "name": "status", + "type": { + "reference": "enum x2py_status" + }, + "declared_type": { + "reference": "enum x2py_status" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": false, + "prototype_style": "prototype", + "source_location": { + "filename": "general/c_richer_features.h", + "line": 53, + "column": 1, + "source_line": "const char *x2py_status_message(enum x2py_status status);" + }, + "start": { + "filename": "general/c_richer_features.h", + "line": 53, + "column": 1, + "source_line": "const char *x2py_status_message(enum x2py_status status);" + }, + "end": null, + "declaration_locations": [] + }, + { + "name": "x2py_fill_matrix", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "rows", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t rows", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cols", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t cols", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "matrix", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "double matrix[static rows][cols]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "cols", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "double matrix[static rows][cols]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "rows", + "is_static_minimum": true, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "cols", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": false, + "prototype_style": "prototype", + "source_location": { + "filename": "general/c_richer_features.h", + "line": 54, + "column": 1, + "source_line": "void x2py_fill_matrix(size_t rows, size_t cols, double matrix[static rows][cols]);" + }, + "start": { + "filename": "general/c_richer_features.h", + "line": 54, + "column": 1, + "source_line": "void x2py_fill_matrix(size_t rows, size_t cols, double matrix[static rows][cols]);" + }, + "end": null, + "declaration_locations": [] + } + ], + "structs": [ + { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": "x2py_flags", + "members": [ + { + "name": "ready", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned ready" + }, + "storage": [], + "initializer": null, + "bit_width": "1", + "source_location": { + "filename": "general/c_richer_features.h", + "line": 30, + "column": 5, + "source_line": " unsigned ready : 1;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "mode", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned mode" + }, + "storage": [], + "initializer": null, + "bit_width": "3", + "source_location": { + "filename": "general/c_richer_features.h", + "line": 31, + "column": 5, + "source_line": " unsigned mode : 3;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "reserved", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned reserved" + }, + "storage": [], + "initializer": null, + "bit_width": "28", + "source_location": { + "filename": "general/c_richer_features.h", + "line": 32, + "column": 5, + "source_line": " unsigned reserved : 28;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": null, + "is_incomplete": false, + "source_location": { + "filename": "general/c_richer_features.h", + "line": 29, + "column": 1, + "source_line": "struct x2py_flags {" + } + }, + { + "reference": "struct x2py_context" + } + ], + "unions": [ + { + "model": "CUnion", + "qualifiers": [], + "source_text": "", + "name": "x2py_scalar", + "members": [ + { + "name": "i32", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int i32" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "general/c_richer_features.h", + "line": 24, + "column": 5, + "source_line": " int i32;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "u64", + "type": { + "model": "CUnsignedLong", + "qualifiers": [], + "source_text": "unsigned long u64" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "general/c_richer_features.h", + "line": 25, + "column": 5, + "source_line": " unsigned long u64;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "f64", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double f64" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "general/c_richer_features.h", + "line": 26, + "column": 5, + "source_line": " double f64;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": null, + "is_incomplete": false, + "source_location": { + "filename": "general/c_richer_features.h", + "line": 23, + "column": 1, + "source_line": "union x2py_scalar {" + } + } + ], + "enums": [ + { + "reference": "enum x2py_status" + } + ], + "typedefs": [ + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "x2py_compare_fn", + "name": "x2py_compare_fn", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "typedef int (*x2py_compare_fn)(const void *left, const void *right)", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFunctionType", + "qualifiers": [], + "source_text": "int", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameter_types": [ + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const void *left", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [ + "const" + ], + "source_text": "const void" + } + ] + }, + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const void *right", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [ + "const" + ], + "source_text": "const void" + } + ] + } + ], + "is_variadic": false, + "prototype_style": "prototype" + } + ] + }, + "source_location": { + "filename": "general/c_richer_features.h", + "line": 15, + "column": 1, + "source_line": "typedef int (*x2py_compare_fn)(const void *left, const void *right);" + }, + "declaration_locations": [] + }, + { + "reference": "x2py_context_handle" + } + ], + "variables": [], + "macros": [ + { + "name": "X2PY_GENERAL_C_RICHER_FEATURES_H", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "general/c_richer_features.h", + "line": 2, + "column": 1, + "source_line": "#define X2PY_GENERAL_C_RICHER_FEATURES_H" + } + }, + { + "name": "X2PY_API", + "value": "ret", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "general/c_richer_features.h", + "line": 6, + "column": 1, + "source_line": "#define X2PY_API(ret) ret" + } + }, + { + "name": "X2PY_STRINGIFY", + "value": "#value", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "general/c_richer_features.h", + "line": 7, + "column": 1, + "source_line": "#define X2PY_STRINGIFY(value) #value" + } + }, + { + "name": "X2PY_API", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "general/c_richer_features.h", + "line": 56, + "column": 1, + "source_line": "#undef X2PY_API" + } + } + ], + "includes": [ + { + "target": "stddef.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "general/c_richer_features.h", + "line": 4, + "column": 1, + "source_line": "#include " + } + } + ], + "raw_directives": [ + { + "directive": "ifndef", + "argument": "X2PY_GENERAL_C_RICHER_FEATURES_H", + "source_location": { + "filename": "general/c_richer_features.h", + "line": 1, + "column": 1, + "source_line": "#ifndef X2PY_GENERAL_C_RICHER_FEATURES_H" + } + }, + { + "directive": "ifdef", + "argument": "X2PY_ENABLE_FAST_PATH", + "source_location": { + "filename": "general/c_richer_features.h", + "line": 9, + "column": 1, + "source_line": "#ifdef X2PY_ENABLE_FAST_PATH" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "general/c_richer_features.h", + "line": 11, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "general/c_richer_features.h", + "line": 13, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "general/c_richer_features.h", + "line": 58, + "column": 1, + "source_line": "#endif" + } + } + ], + "macro_dependencies": [ + { + "name": "X2PY_API", + "context": "declaration", + "source_location": { + "filename": "general/c_richer_features.h", + "line": 40, + "column": 1, + "source_line": "X2PY_API(int) x2py_sort(" + }, + "source_text": "X2PY_API(int) x2py_sort(\n void *items,\n size_t count,\n size_t item_size,\n x2py_compare_fn compare\n)" + } + ], + "diagnostics": [ + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'X2PY_API' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "general/c_richer_features.h", + "line": 6, + "column": 1, + "source_line": "#define X2PY_API(ret) ret" + }, + "unit_kind": "macro", + "unit_name": "X2PY_API" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'X2PY_STRINGIFY' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "general/c_richer_features.h", + "line": 7, + "column": 1, + "source_line": "#define X2PY_STRINGIFY(value) #value" + }, + "unit_kind": "macro", + "unit_name": "X2PY_STRINGIFY" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'X2PY_API'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "general/c_richer_features.h", + "line": 40, + "column": 1, + "source_line": "X2PY_API(int) x2py_sort(" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "X2PY_API" + } + ] + } + }, + "functions": { + "x2py_fast_path": { + "name": "x2py_fast_path", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": false, + "prototype_style": "prototype", + "source_location": { + "filename": "general/c_richer_features.h", + "line": 10, + "column": 1, + "source_line": "int x2py_fast_path(void);" + }, + "start": { + "filename": "general/c_richer_features.h", + "line": 10, + "column": 1, + "source_line": "int x2py_fast_path(void);" + }, + "end": null, + "declaration_locations": [] + }, + "x2py_slow_path": { + "name": "x2py_slow_path", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": false, + "prototype_style": "prototype", + "source_location": { + "filename": "general/c_richer_features.h", + "line": 12, + "column": 1, + "source_line": "int x2py_slow_path(void);" + }, + "start": { + "filename": "general/c_richer_features.h", + "line": 12, + "column": 1, + "source_line": "int x2py_slow_path(void);" + }, + "end": null, + "declaration_locations": [] + }, + "x2py_register_callback": { + "name": "x2py_register_callback", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "context", + "type": { + "reference": "x2py_context_handle" + }, + "declared_type": { + "reference": "x2py_context_handle" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "callback", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void (*callback)(void *userdata, enum x2py_status status)", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFunctionType", + "qualifiers": [], + "source_text": "void", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameter_types": [ + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *userdata", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + { + "reference": "enum x2py_status" + } + ], + "is_variadic": false, + "prototype_style": "prototype" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void (*callback)(void *userdata, enum x2py_status status)", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFunctionType", + "qualifiers": [], + "source_text": "void", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameter_types": [ + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *userdata", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + { + "reference": "enum x2py_status" + } + ], + "is_variadic": false, + "prototype_style": "prototype" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "userdata", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *userdata", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *userdata", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": false, + "prototype_style": "prototype", + "source_location": { + "filename": "general/c_richer_features.h", + "line": 47, + "column": 1, + "source_line": "int x2py_register_callback(" + }, + "start": { + "filename": "general/c_richer_features.h", + "line": 47, + "column": 1, + "source_line": "int x2py_register_callback(" + }, + "end": null, + "declaration_locations": [] + }, + "x2py_status_message": { + "name": "x2py_status_message", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "parameters": [ + { + "name": "status", + "type": { + "reference": "enum x2py_status" + }, + "declared_type": { + "reference": "enum x2py_status" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": false, + "prototype_style": "prototype", + "source_location": { + "filename": "general/c_richer_features.h", + "line": 53, + "column": 1, + "source_line": "const char *x2py_status_message(enum x2py_status status);" + }, + "start": { + "filename": "general/c_richer_features.h", + "line": 53, + "column": 1, + "source_line": "const char *x2py_status_message(enum x2py_status status);" + }, + "end": null, + "declaration_locations": [] + }, + "x2py_fill_matrix": { + "name": "x2py_fill_matrix", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "rows", + "type": { + "reference": "size_t" + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cols", + "type": { + "reference": "size_t" + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "matrix", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "double matrix[static rows][cols]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "cols", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "double matrix[static rows][cols]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "rows", + "is_static_minimum": true, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "cols", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": false, + "prototype_style": "prototype", + "source_location": { + "filename": "general/c_richer_features.h", + "line": 54, + "column": 1, + "source_line": "void x2py_fill_matrix(size_t rows, size_t cols, double matrix[static rows][cols]);" + }, + "start": { + "filename": "general/c_richer_features.h", + "line": 54, + "column": 1, + "source_line": "void x2py_fill_matrix(size_t rows, size_t cols, double matrix[static rows][cols]);" + }, + "end": null, + "declaration_locations": [] + } + }, + "structs": { + "x2py_flags": { + "reference": "struct x2py_flags" + }, + "x2py_context": { + "reference": "struct x2py_context" + } + }, + "unions": { + "x2py_scalar": { + "reference": "union x2py_scalar" + } + }, + "enums": { + "x2py_status": { + "reference": "enum x2py_status" + } + }, + "typedefs": { + "x2py_compare_fn": { + "reference": "x2py_compare_fn" + }, + "x2py_context_handle": { + "reference": "x2py_context_handle" + } + }, + "variables": {}, + "macros": { + "X2PY_GENERAL_C_RICHER_FEATURES_H": { + "name": "X2PY_GENERAL_C_RICHER_FEATURES_H", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "general/c_richer_features.h", + "line": 2, + "column": 1, + "source_line": "#define X2PY_GENERAL_C_RICHER_FEATURES_H" + } + }, + "X2PY_API": { + "name": "X2PY_API", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "general/c_richer_features.h", + "line": 56, + "column": 1, + "source_line": "#undef X2PY_API" + } + }, + "X2PY_STRINGIFY": { + "name": "X2PY_STRINGIFY", + "value": "#value", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "general/c_richer_features.h", + "line": 7, + "column": 1, + "source_line": "#define X2PY_STRINGIFY(value) #value" + } + } + }, + "includes": { + "general/c_richer_features.h:stddef.h": { + "target": "stddef.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "general/c_richer_features.h", + "line": 4, + "column": 1, + "source_line": "#include " + } + } + }, + "functions_by_file": { + "general/c_richer_features.h": [ + "x2py_fast_path", + "x2py_slow_path", + "x2py_register_callback", + "x2py_status_message", + "x2py_fill_matrix" + ] + }, + "enum_constants": { + "X2PY_STATUS_OK": { + "name": "X2PY_STATUS_OK", + "value": "0", + "source_location": { + "filename": "general/c_richer_features.h", + "line": 17, + "column": 1, + "source_line": "enum x2py_status {" + } + }, + "X2PY_STATUS_RETRY": { + "name": "X2PY_STATUS_RETRY", + "value": "1", + "source_location": { + "filename": "general/c_richer_features.h", + "line": 17, + "column": 1, + "source_line": "enum x2py_status {" + } + }, + "X2PY_STATUS_ERROR": { + "name": "X2PY_STATUS_ERROR", + "value": "-1", + "source_location": { + "filename": "general/c_richer_features.h", + "line": 17, + "column": 1, + "source_line": "enum x2py_status {" + } + } + }, + "include_graph": { + "general/c_richer_features.h": [] + }, + "system_includes": { + "general/c_richer_features.h": [ + "stddef.h" + ] + }, + "unresolved_includes": { + "general/c_richer_features.h": [] + }, + "header_source_pairs": { + "general/c_richer_features.h": [] + }, + "diagnostics": [ + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'X2PY_API' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "general/c_richer_features.h", + "line": 6, + "column": 1, + "source_line": "#define X2PY_API(ret) ret" + }, + "unit_kind": "macro", + "unit_name": "X2PY_API" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'X2PY_STRINGIFY' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "general/c_richer_features.h", + "line": 7, + "column": 1, + "source_line": "#define X2PY_STRINGIFY(value) #value" + }, + "unit_kind": "macro", + "unit_name": "X2PY_STRINGIFY" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'X2PY_API'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "general/c_richer_features.h", + "line": 40, + "column": 1, + "source_line": "X2PY_API(int) x2py_sort(" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "X2PY_API" + } + ] +} diff --git a/tests/parser/c/fixtures/general/constants.json b/tests/parser/c/fixtures/general/constants.json new file mode 100644 index 000000000..e5568a188 --- /dev/null +++ b/tests/parser/c/fixtures/general/constants.json @@ -0,0 +1,577 @@ +{ + "files": { + "general/constants.h": { + "filename": "general/constants.h", + "language": "c", + "parser_status": "partial", + "preprocessing": "raw", + "functions": [ + { + "name": "coordinate_axis_name", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "parameters": [ + { + "name": "axis", + "type": { + "model": "CEnum", + "qualifiers": [], + "source_text": "", + "name": "coordinate_axis", + "constants": [ + { + "name": "COORD_X", + "value": "0", + "source_location": { + "filename": "general/constants.h", + "line": 12, + "column": 1, + "source_line": "enum coordinate_axis {" + } + }, + { + "name": "COORD_Y", + "value": "1", + "source_location": { + "filename": "general/constants.h", + "line": 12, + "column": 1, + "source_line": "enum coordinate_axis {" + } + }, + { + "name": "COORD_Z", + "value": "2", + "source_location": { + "filename": "general/constants.h", + "line": 12, + "column": 1, + "source_line": "enum coordinate_axis {" + } + } + ], + "anonymous_id": null, + "source_location": { + "filename": "general/constants.h", + "line": 12, + "column": 1, + "source_line": "enum coordinate_axis {" + } + }, + "declared_type": { + "reference": "enum coordinate_axis" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "extern" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": false, + "prototype_style": "prototype", + "source_location": { + "filename": "general/constants.h", + "line": 20, + "column": 1, + "source_line": "extern const char *coordinate_axis_name(enum coordinate_axis axis);" + }, + "start": { + "filename": "general/constants.h", + "line": 20, + "column": 1, + "source_line": "extern const char *coordinate_axis_name(enum coordinate_axis axis);" + }, + "end": null, + "declaration_locations": [] + }, + { + "name": "coordinate_axis_count", + "result_type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "parameters": [], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": false, + "prototype_style": "prototype", + "source_location": { + "filename": "general/constants.h", + "line": 21, + "column": 1, + "source_line": "size_t coordinate_axis_count(void);" + }, + "start": { + "filename": "general/constants.h", + "line": 21, + "column": 1, + "source_line": "size_t coordinate_axis_count(void);" + }, + "end": null, + "declaration_locations": [] + } + ], + "structs": [], + "unions": [], + "enums": [ + { + "reference": "enum coordinate_axis" + } + ], + "typedefs": [ + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "c_int_like", + "name": "c_int_like", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "typedef int c_int_like" + }, + "source_location": { + "filename": "general/constants.h", + "line": 9, + "column": 1, + "source_line": "typedef int c_int_like;" + }, + "declaration_locations": [] + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "c_double_like", + "name": "c_double_like", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "typedef double c_double_like" + }, + "source_location": { + "filename": "general/constants.h", + "line": 10, + "column": 1, + "source_line": "typedef double c_double_like;" + }, + "declaration_locations": [] + } + ], + "variables": [ + { + "name": "nmax", + "type": { + "reference": "c_int_like" + }, + "storage": [ + "extern" + ], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "general/constants.h", + "line": 18, + "column": 1, + "source_line": "extern c_int_like nmax;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "origin", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "extern c_double_like origin[3]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "3", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "reference": "c_double_like" + } + ] + }, + "storage": [ + "extern" + ], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "general/constants.h", + "line": 19, + "column": 1, + "source_line": "extern c_double_like origin[3];" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "macros": [ + { + "name": "X2PY_GENERAL_CONSTANTS_H", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "general/constants.h", + "line": 2, + "column": 1, + "source_line": "#define X2PY_GENERAL_CONSTANTS_H" + } + }, + { + "name": "X2PY_GENERAL_NMAX", + "value": "100", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "general/constants.h", + "line": 6, + "column": 1, + "source_line": "#define X2PY_GENERAL_NMAX 100" + } + }, + { + "name": "X2PY_GENERAL_ORIGIN_RANK", + "value": "3", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "general/constants.h", + "line": 7, + "column": 1, + "source_line": "#define X2PY_GENERAL_ORIGIN_RANK 3" + } + } + ], + "includes": [ + { + "target": "stddef.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "general/constants.h", + "line": 4, + "column": 1, + "source_line": "#include " + } + } + ], + "raw_directives": [ + { + "directive": "ifndef", + "argument": "X2PY_GENERAL_CONSTANTS_H", + "source_location": { + "filename": "general/constants.h", + "line": 1, + "column": 1, + "source_line": "#ifndef X2PY_GENERAL_CONSTANTS_H" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "general/constants.h", + "line": 23, + "column": 1, + "source_line": "#endif" + } + } + ], + "macro_dependencies": [], + "diagnostics": [] + } + }, + "functions": { + "coordinate_axis_name": { + "name": "coordinate_axis_name", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "parameters": [ + { + "name": "axis", + "type": { + "reference": "enum coordinate_axis" + }, + "declared_type": { + "reference": "enum coordinate_axis" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "extern" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": false, + "prototype_style": "prototype", + "source_location": { + "filename": "general/constants.h", + "line": 20, + "column": 1, + "source_line": "extern const char *coordinate_axis_name(enum coordinate_axis axis);" + }, + "start": { + "filename": "general/constants.h", + "line": 20, + "column": 1, + "source_line": "extern const char *coordinate_axis_name(enum coordinate_axis axis);" + }, + "end": null, + "declaration_locations": [] + }, + "coordinate_axis_count": { + "name": "coordinate_axis_count", + "result_type": { + "reference": "size_t" + }, + "parameters": [], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": false, + "prototype_style": "prototype", + "source_location": { + "filename": "general/constants.h", + "line": 21, + "column": 1, + "source_line": "size_t coordinate_axis_count(void);" + }, + "start": { + "filename": "general/constants.h", + "line": 21, + "column": 1, + "source_line": "size_t coordinate_axis_count(void);" + }, + "end": null, + "declaration_locations": [] + } + }, + "structs": {}, + "unions": {}, + "enums": { + "coordinate_axis": { + "reference": "enum coordinate_axis" + } + }, + "typedefs": { + "c_int_like": { + "reference": "c_int_like" + }, + "c_double_like": { + "reference": "c_double_like" + } + }, + "variables": { + "nmax": { + "name": "nmax", + "type": { + "reference": "c_int_like" + }, + "storage": [ + "extern" + ], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "general/constants.h", + "line": 18, + "column": 1, + "source_line": "extern c_int_like nmax;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + "origin": { + "name": "origin", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "extern c_double_like origin[3]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "3", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "reference": "c_double_like" + } + ] + }, + "storage": [ + "extern" + ], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "general/constants.h", + "line": 19, + "column": 1, + "source_line": "extern c_double_like origin[3];" + }, + "callback_policy": null, + "declaration_locations": [] + } + }, + "macros": { + "X2PY_GENERAL_CONSTANTS_H": { + "name": "X2PY_GENERAL_CONSTANTS_H", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "general/constants.h", + "line": 2, + "column": 1, + "source_line": "#define X2PY_GENERAL_CONSTANTS_H" + } + }, + "X2PY_GENERAL_NMAX": { + "name": "X2PY_GENERAL_NMAX", + "value": "100", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "general/constants.h", + "line": 6, + "column": 1, + "source_line": "#define X2PY_GENERAL_NMAX 100" + } + }, + "X2PY_GENERAL_ORIGIN_RANK": { + "name": "X2PY_GENERAL_ORIGIN_RANK", + "value": "3", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "general/constants.h", + "line": 7, + "column": 1, + "source_line": "#define X2PY_GENERAL_ORIGIN_RANK 3" + } + } + }, + "includes": { + "general/constants.h:stddef.h": { + "target": "stddef.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "general/constants.h", + "line": 4, + "column": 1, + "source_line": "#include " + } + } + }, + "functions_by_file": { + "general/constants.h": [ + "coordinate_axis_name", + "coordinate_axis_count" + ] + }, + "enum_constants": { + "COORD_X": { + "name": "COORD_X", + "value": "0", + "source_location": { + "filename": "general/constants.h", + "line": 12, + "column": 1, + "source_line": "enum coordinate_axis {" + } + }, + "COORD_Y": { + "name": "COORD_Y", + "value": "1", + "source_location": { + "filename": "general/constants.h", + "line": 12, + "column": 1, + "source_line": "enum coordinate_axis {" + } + }, + "COORD_Z": { + "name": "COORD_Z", + "value": "2", + "source_location": { + "filename": "general/constants.h", + "line": 12, + "column": 1, + "source_line": "enum coordinate_axis {" + } + } + }, + "include_graph": { + "general/constants.h": [] + }, + "system_includes": { + "general/constants.h": [ + "stddef.h" + ] + }, + "unresolved_includes": { + "general/constants.h": [] + }, + "header_source_pairs": { + "general/constants.h": [] + }, + "diagnostics": [] +} diff --git a/tests/parser/c/fixtures/general/math_api.json b/tests/parser/c/fixtures/general/math_api.json new file mode 100644 index 000000000..e64f85279 --- /dev/null +++ b/tests/parser/c/fixtures/general/math_api.json @@ -0,0 +1,1538 @@ +{ + "files": { + "general/math_api.c": { + "filename": "general/math_api.c", + "language": "c", + "parser_status": "partial", + "preprocessing": "raw", + "functions": [ + { + "name": "norm2", + "result_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + }, + "parameters": [ + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const double x[static 1]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CDouble", + "qualifiers": [ + "const" + ], + "source_text": "const double" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const double x[static 1]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "1", + "is_static_minimum": true, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CDouble", + "qualifiers": [ + "const" + ], + "source_text": "const double" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "general/math_api.c", + "line": 5, + "column": 1, + "source_line": "double norm2(int n, const double x[static 1])" + }, + "start": { + "filename": "general/math_api.c", + "line": 5, + "column": 1, + "source_line": "double norm2(int n, const double x[static 1])" + }, + "end": { + "filename": "general/math_api.c", + "line": 12, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "general/math_api.h", + "line": 4, + "column": 1, + "source_line": "double norm2(int n, const double x[static 1]);" + } + ] + }, + { + "name": "scale", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "alpha", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double alpha" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double alpha" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "double x[static 1]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "double x[static 1]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "1", + "is_static_minimum": true, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "general/math_api.c", + "line": 14, + "column": 1, + "source_line": "void scale(int n, double alpha, double x[static 1])" + }, + "start": { + "filename": "general/math_api.c", + "line": 14, + "column": 1, + "source_line": "void scale(int n, double alpha, double x[static 1])" + }, + "end": { + "filename": "general/math_api.c", + "line": 19, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "general/math_api.h", + "line": 5, + "column": 1, + "source_line": "void scale(int n, double alpha, double x[static 1]);" + } + ] + }, + { + "name": "dot", + "result_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + }, + "parameters": [ + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const double *restrict x", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "restrict" + ], + "source_text": "" + }, + { + "model": "CDouble", + "qualifiers": [ + "const" + ], + "source_text": "const double" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const double *restrict x", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "restrict" + ], + "source_text": "" + }, + { + "model": "CDouble", + "qualifiers": [ + "const" + ], + "source_text": "const double" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const double *restrict y", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "restrict" + ], + "source_text": "" + }, + { + "model": "CDouble", + "qualifiers": [ + "const" + ], + "source_text": "const double" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const double *restrict y", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "restrict" + ], + "source_text": "" + }, + { + "model": "CDouble", + "qualifiers": [ + "const" + ], + "source_text": "const double" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "general/math_api.c", + "line": 21, + "column": 1, + "source_line": "double dot(int n, const double *restrict x, const double *restrict y)" + }, + "start": { + "filename": "general/math_api.c", + "line": 21, + "column": 1, + "source_line": "double dot(int n, const double *restrict x, const double *restrict y)" + }, + "end": { + "filename": "general/math_api.c", + "line": 28, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "general/math_api.h", + "line": 6, + "column": 1, + "source_line": "double dot(int n, const double *restrict x, const double *restrict y);" + } + ] + }, + { + "name": "fill_identity3", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "double a[static 3][3]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "3", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "double a[static 3][3]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "3", + "is_static_minimum": true, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "3", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "general/math_api.c", + "line": 30, + "column": 1, + "source_line": "void fill_identity3(double a[static 3][3])" + }, + "start": { + "filename": "general/math_api.c", + "line": 30, + "column": 1, + "source_line": "void fill_identity3(double a[static 3][3])" + }, + "end": { + "filename": "general/math_api.c", + "line": 37, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "general/math_api.h", + "line": 7, + "column": 1, + "source_line": "void fill_identity3(double a[static 3][3]);" + } + ] + } + ], + "structs": [], + "unions": [], + "enums": [], + "typedefs": [], + "variables": [], + "macros": [], + "includes": [ + { + "target": "math_api.h", + "kind": "local", + "resolved_path": "general/math_api.h", + "source_location": { + "filename": "general/math_api.c", + "line": 1, + "column": 1, + "source_line": "#include \"math_api.h\"" + } + }, + { + "target": "math.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "general/math_api.c", + "line": 3, + "column": 1, + "source_line": "#include " + } + } + ], + "raw_directives": [], + "macro_dependencies": [], + "diagnostics": [] + }, + "general/math_api.h": { + "filename": "general/math_api.h", + "language": "c", + "parser_status": "partial", + "preprocessing": "raw", + "functions": [ + { + "name": "norm2", + "result_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + }, + "parameters": [ + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const double x[static 1]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CDouble", + "qualifiers": [ + "const" + ], + "source_text": "const double" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const double x[static 1]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "1", + "is_static_minimum": true, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CDouble", + "qualifiers": [ + "const" + ], + "source_text": "const double" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": false, + "prototype_style": "prototype", + "source_location": { + "filename": "general/math_api.h", + "line": 4, + "column": 1, + "source_line": "double norm2(int n, const double x[static 1]);" + }, + "start": { + "filename": "general/math_api.h", + "line": 4, + "column": 1, + "source_line": "double norm2(int n, const double x[static 1]);" + }, + "end": null, + "declaration_locations": [] + }, + { + "name": "scale", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "alpha", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double alpha" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double alpha" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "double x[static 1]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "double x[static 1]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "1", + "is_static_minimum": true, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": false, + "prototype_style": "prototype", + "source_location": { + "filename": "general/math_api.h", + "line": 5, + "column": 1, + "source_line": "void scale(int n, double alpha, double x[static 1]);" + }, + "start": { + "filename": "general/math_api.h", + "line": 5, + "column": 1, + "source_line": "void scale(int n, double alpha, double x[static 1]);" + }, + "end": null, + "declaration_locations": [] + }, + { + "name": "dot", + "result_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + }, + "parameters": [ + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const double *restrict x", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "restrict" + ], + "source_text": "" + }, + { + "model": "CDouble", + "qualifiers": [ + "const" + ], + "source_text": "const double" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const double *restrict x", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "restrict" + ], + "source_text": "" + }, + { + "model": "CDouble", + "qualifiers": [ + "const" + ], + "source_text": "const double" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const double *restrict y", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "restrict" + ], + "source_text": "" + }, + { + "model": "CDouble", + "qualifiers": [ + "const" + ], + "source_text": "const double" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const double *restrict y", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "restrict" + ], + "source_text": "" + }, + { + "model": "CDouble", + "qualifiers": [ + "const" + ], + "source_text": "const double" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": false, + "prototype_style": "prototype", + "source_location": { + "filename": "general/math_api.h", + "line": 6, + "column": 1, + "source_line": "double dot(int n, const double *restrict x, const double *restrict y);" + }, + "start": { + "filename": "general/math_api.h", + "line": 6, + "column": 1, + "source_line": "double dot(int n, const double *restrict x, const double *restrict y);" + }, + "end": null, + "declaration_locations": [] + }, + { + "name": "fill_identity3", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "double a[static 3][3]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "3", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "double a[static 3][3]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "3", + "is_static_minimum": true, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "3", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": false, + "prototype_style": "prototype", + "source_location": { + "filename": "general/math_api.h", + "line": 7, + "column": 1, + "source_line": "void fill_identity3(double a[static 3][3]);" + }, + "start": { + "filename": "general/math_api.h", + "line": 7, + "column": 1, + "source_line": "void fill_identity3(double a[static 3][3]);" + }, + "end": null, + "declaration_locations": [] + } + ], + "structs": [], + "unions": [], + "enums": [], + "typedefs": [], + "variables": [], + "macros": [ + { + "name": "X2PY_GENERAL_MATH_API_H", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "general/math_api.h", + "line": 2, + "column": 1, + "source_line": "#define X2PY_GENERAL_MATH_API_H" + } + } + ], + "includes": [], + "raw_directives": [ + { + "directive": "ifndef", + "argument": "X2PY_GENERAL_MATH_API_H", + "source_location": { + "filename": "general/math_api.h", + "line": 1, + "column": 1, + "source_line": "#ifndef X2PY_GENERAL_MATH_API_H" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "general/math_api.h", + "line": 9, + "column": 1, + "source_line": "#endif" + } + } + ], + "macro_dependencies": [], + "diagnostics": [] + } + }, + "functions": { + "norm2": { + "name": "norm2", + "result_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + }, + "parameters": [ + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const double x[static 1]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CDouble", + "qualifiers": [ + "const" + ], + "source_text": "const double" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const double x[static 1]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "1", + "is_static_minimum": true, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CDouble", + "qualifiers": [ + "const" + ], + "source_text": "const double" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "general/math_api.c", + "line": 5, + "column": 1, + "source_line": "double norm2(int n, const double x[static 1])" + }, + "start": { + "filename": "general/math_api.c", + "line": 5, + "column": 1, + "source_line": "double norm2(int n, const double x[static 1])" + }, + "end": { + "filename": "general/math_api.c", + "line": 12, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "general/math_api.h", + "line": 4, + "column": 1, + "source_line": "double norm2(int n, const double x[static 1]);" + } + ] + }, + "scale": { + "name": "scale", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "alpha", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double alpha" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double alpha" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "double x[static 1]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "double x[static 1]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "1", + "is_static_minimum": true, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "general/math_api.c", + "line": 14, + "column": 1, + "source_line": "void scale(int n, double alpha, double x[static 1])" + }, + "start": { + "filename": "general/math_api.c", + "line": 14, + "column": 1, + "source_line": "void scale(int n, double alpha, double x[static 1])" + }, + "end": { + "filename": "general/math_api.c", + "line": 19, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "general/math_api.h", + "line": 5, + "column": 1, + "source_line": "void scale(int n, double alpha, double x[static 1]);" + } + ] + }, + "dot": { + "name": "dot", + "result_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + }, + "parameters": [ + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const double *restrict x", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "restrict" + ], + "source_text": "" + }, + { + "model": "CDouble", + "qualifiers": [ + "const" + ], + "source_text": "const double" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const double *restrict x", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "restrict" + ], + "source_text": "" + }, + { + "model": "CDouble", + "qualifiers": [ + "const" + ], + "source_text": "const double" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const double *restrict y", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "restrict" + ], + "source_text": "" + }, + { + "model": "CDouble", + "qualifiers": [ + "const" + ], + "source_text": "const double" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const double *restrict y", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "restrict" + ], + "source_text": "" + }, + { + "model": "CDouble", + "qualifiers": [ + "const" + ], + "source_text": "const double" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "general/math_api.c", + "line": 21, + "column": 1, + "source_line": "double dot(int n, const double *restrict x, const double *restrict y)" + }, + "start": { + "filename": "general/math_api.c", + "line": 21, + "column": 1, + "source_line": "double dot(int n, const double *restrict x, const double *restrict y)" + }, + "end": { + "filename": "general/math_api.c", + "line": 28, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "general/math_api.h", + "line": 6, + "column": 1, + "source_line": "double dot(int n, const double *restrict x, const double *restrict y);" + } + ] + }, + "fill_identity3": { + "name": "fill_identity3", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "double a[static 3][3]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "3", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "double a[static 3][3]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "3", + "is_static_minimum": true, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "3", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "general/math_api.c", + "line": 30, + "column": 1, + "source_line": "void fill_identity3(double a[static 3][3])" + }, + "start": { + "filename": "general/math_api.c", + "line": 30, + "column": 1, + "source_line": "void fill_identity3(double a[static 3][3])" + }, + "end": { + "filename": "general/math_api.c", + "line": 37, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "general/math_api.h", + "line": 7, + "column": 1, + "source_line": "void fill_identity3(double a[static 3][3]);" + } + ] + } + }, + "structs": {}, + "unions": {}, + "enums": {}, + "typedefs": {}, + "variables": {}, + "macros": { + "X2PY_GENERAL_MATH_API_H": { + "name": "X2PY_GENERAL_MATH_API_H", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "general/math_api.h", + "line": 2, + "column": 1, + "source_line": "#define X2PY_GENERAL_MATH_API_H" + } + } + }, + "includes": { + "general/math_api.c:math_api.h": { + "target": "math_api.h", + "kind": "local", + "resolved_path": "general/math_api.h", + "source_location": { + "filename": "general/math_api.c", + "line": 1, + "column": 1, + "source_line": "#include \"math_api.h\"" + } + }, + "general/math_api.c:math.h": { + "target": "math.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "general/math_api.c", + "line": 3, + "column": 1, + "source_line": "#include " + } + } + }, + "functions_by_file": { + "general/math_api.c": [ + "norm2", + "scale", + "dot", + "fill_identity3" + ], + "general/math_api.h": [ + "norm2", + "scale", + "dot", + "fill_identity3" + ] + }, + "enum_constants": {}, + "include_graph": { + "general/math_api.c": [ + "general/math_api.h" + ], + "general/math_api.h": [] + }, + "system_includes": { + "general/math_api.c": [ + "math.h" + ], + "general/math_api.h": [] + }, + "unresolved_includes": { + "general/math_api.c": [], + "general/math_api.h": [] + }, + "header_source_pairs": { + "general/math_api.h": [ + "general/math_api.c" + ] + }, + "diagnostics": [] +} diff --git a/tests/parser/c/fixtures/general/mesh.json b/tests/parser/c/fixtures/general/mesh.json new file mode 100644 index 000000000..d53eb7985 --- /dev/null +++ b/tests/parser/c/fixtures/general/mesh.json @@ -0,0 +1,994 @@ +{ + "files": { + "general/mesh.h": { + "filename": "general/mesh.h", + "language": "c", + "parser_status": "partial", + "preprocessing": "raw", + "functions": [ + { + "name": "node_move", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "node", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "struct node *node", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": "node", + "members": [ + { + "name": "id", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int id" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "general/mesh.h", + "line": 7, + "column": 5, + "source_line": " int id;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "xyz", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "double xyz[3]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "3", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "general/mesh.h", + "line": 8, + "column": 5, + "source_line": " double xyz[3];" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": null, + "is_incomplete": false, + "source_location": { + "filename": "general/mesh.h", + "line": 6, + "column": 1, + "source_line": "struct node {" + } + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "struct node *node", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "struct node" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "delta", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const double delta[static 3]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CDouble", + "qualifiers": [ + "const" + ], + "source_text": "const double" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const double delta[static 3]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "3", + "is_static_minimum": true, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CDouble", + "qualifiers": [ + "const" + ], + "source_text": "const double" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": false, + "prototype_style": "prototype", + "source_location": { + "filename": "general/mesh.h", + "line": 19, + "column": 1, + "source_line": "void node_move(struct node *node, const double delta[static 3]);" + }, + "start": { + "filename": "general/mesh.h", + "line": 19, + "column": 1, + "source_line": "void node_move(struct node *node, const double delta[static 3]);" + }, + "end": null, + "declaration_locations": [] + }, + { + "name": "mesh_init", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "mesh", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "struct mesh *mesh", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": "mesh", + "members": [ + { + "name": "nnodes", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t nnodes", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "general/mesh.h", + "line": 12, + "column": 5, + "source_line": " size_t nnodes;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "nodes", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "struct node *nodes", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "struct node" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "general/mesh.h", + "line": 13, + "column": 5, + "source_line": " struct node *nodes;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": null, + "is_incomplete": false, + "source_location": { + "filename": "general/mesh.h", + "line": 11, + "column": 1, + "source_line": "struct mesh {" + } + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "struct mesh *mesh", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "struct mesh" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "nnodes", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t nnodes", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": false, + "prototype_style": "prototype", + "source_location": { + "filename": "general/mesh.h", + "line": 20, + "column": 1, + "source_line": "int mesh_init(struct mesh *mesh, size_t nnodes);" + }, + "start": { + "filename": "general/mesh.h", + "line": 20, + "column": 1, + "source_line": "int mesh_init(struct mesh *mesh, size_t nnodes);" + }, + "end": null, + "declaration_locations": [] + }, + { + "name": "mesh_clear", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "mesh", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "struct mesh *mesh", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "struct mesh" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "struct mesh *mesh", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "struct mesh" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": false, + "prototype_style": "prototype", + "source_location": { + "filename": "general/mesh.h", + "line": 21, + "column": 1, + "source_line": "void mesh_clear(struct mesh *mesh);" + }, + "start": { + "filename": "general/mesh.h", + "line": 21, + "column": 1, + "source_line": "void mesh_clear(struct mesh *mesh);" + }, + "end": null, + "declaration_locations": [] + }, + { + "name": "mesh_node_at", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "struct node", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "struct node" + } + ] + }, + "parameters": [ + { + "name": "mesh", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "struct mesh *mesh", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "struct mesh" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "struct mesh *mesh", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "struct mesh" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "index", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t index", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": false, + "prototype_style": "prototype", + "source_location": { + "filename": "general/mesh.h", + "line": 22, + "column": 1, + "source_line": "struct node *mesh_node_at(struct mesh *mesh, size_t index);" + }, + "start": { + "filename": "general/mesh.h", + "line": 22, + "column": 1, + "source_line": "struct node *mesh_node_at(struct mesh *mesh, size_t index);" + }, + "end": null, + "declaration_locations": [] + } + ], + "structs": [ + { + "reference": "struct node" + }, + { + "reference": "struct mesh" + } + ], + "unions": [], + "enums": [], + "typedefs": [ + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "node", + "name": "node", + "type": { + "reference": "struct node" + }, + "source_location": { + "filename": "general/mesh.h", + "line": 16, + "column": 1, + "source_line": "typedef struct node node;" + }, + "declaration_locations": [] + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "mesh", + "name": "mesh", + "type": { + "reference": "struct mesh" + }, + "source_location": { + "filename": "general/mesh.h", + "line": 17, + "column": 1, + "source_line": "typedef struct mesh mesh;" + }, + "declaration_locations": [] + } + ], + "variables": [], + "macros": [ + { + "name": "X2PY_GENERAL_MESH_H", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "general/mesh.h", + "line": 2, + "column": 1, + "source_line": "#define X2PY_GENERAL_MESH_H" + } + } + ], + "includes": [ + { + "target": "stddef.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "general/mesh.h", + "line": 4, + "column": 1, + "source_line": "#include " + } + } + ], + "raw_directives": [ + { + "directive": "ifndef", + "argument": "X2PY_GENERAL_MESH_H", + "source_location": { + "filename": "general/mesh.h", + "line": 1, + "column": 1, + "source_line": "#ifndef X2PY_GENERAL_MESH_H" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "general/mesh.h", + "line": 24, + "column": 1, + "source_line": "#endif" + } + } + ], + "macro_dependencies": [], + "diagnostics": [] + } + }, + "functions": { + "node_move": { + "name": "node_move", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "node", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "struct node *node", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "struct node" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "struct node *node", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "struct node" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "delta", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const double delta[static 3]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CDouble", + "qualifiers": [ + "const" + ], + "source_text": "const double" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const double delta[static 3]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "3", + "is_static_minimum": true, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CDouble", + "qualifiers": [ + "const" + ], + "source_text": "const double" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": false, + "prototype_style": "prototype", + "source_location": { + "filename": "general/mesh.h", + "line": 19, + "column": 1, + "source_line": "void node_move(struct node *node, const double delta[static 3]);" + }, + "start": { + "filename": "general/mesh.h", + "line": 19, + "column": 1, + "source_line": "void node_move(struct node *node, const double delta[static 3]);" + }, + "end": null, + "declaration_locations": [] + }, + "mesh_init": { + "name": "mesh_init", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "mesh", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "struct mesh *mesh", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "struct mesh" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "struct mesh *mesh", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "struct mesh" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "nnodes", + "type": { + "reference": "size_t" + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": false, + "prototype_style": "prototype", + "source_location": { + "filename": "general/mesh.h", + "line": 20, + "column": 1, + "source_line": "int mesh_init(struct mesh *mesh, size_t nnodes);" + }, + "start": { + "filename": "general/mesh.h", + "line": 20, + "column": 1, + "source_line": "int mesh_init(struct mesh *mesh, size_t nnodes);" + }, + "end": null, + "declaration_locations": [] + }, + "mesh_clear": { + "name": "mesh_clear", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "mesh", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "struct mesh *mesh", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "struct mesh" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "struct mesh *mesh", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "struct mesh" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": false, + "prototype_style": "prototype", + "source_location": { + "filename": "general/mesh.h", + "line": 21, + "column": 1, + "source_line": "void mesh_clear(struct mesh *mesh);" + }, + "start": { + "filename": "general/mesh.h", + "line": 21, + "column": 1, + "source_line": "void mesh_clear(struct mesh *mesh);" + }, + "end": null, + "declaration_locations": [] + }, + "mesh_node_at": { + "name": "mesh_node_at", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "struct node", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "struct node" + } + ] + }, + "parameters": [ + { + "name": "mesh", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "struct mesh *mesh", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "struct mesh" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "struct mesh *mesh", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "struct mesh" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "index", + "type": { + "reference": "size_t" + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": false, + "prototype_style": "prototype", + "source_location": { + "filename": "general/mesh.h", + "line": 22, + "column": 1, + "source_line": "struct node *mesh_node_at(struct mesh *mesh, size_t index);" + }, + "start": { + "filename": "general/mesh.h", + "line": 22, + "column": 1, + "source_line": "struct node *mesh_node_at(struct mesh *mesh, size_t index);" + }, + "end": null, + "declaration_locations": [] + } + }, + "structs": { + "node": { + "reference": "struct node" + }, + "mesh": { + "reference": "struct mesh" + } + }, + "unions": {}, + "enums": {}, + "typedefs": { + "node": { + "reference": "node" + }, + "mesh": { + "reference": "mesh" + } + }, + "variables": {}, + "macros": { + "X2PY_GENERAL_MESH_H": { + "name": "X2PY_GENERAL_MESH_H", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "general/mesh.h", + "line": 2, + "column": 1, + "source_line": "#define X2PY_GENERAL_MESH_H" + } + } + }, + "includes": { + "general/mesh.h:stddef.h": { + "target": "stddef.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "general/mesh.h", + "line": 4, + "column": 1, + "source_line": "#include " + } + } + }, + "functions_by_file": { + "general/mesh.h": [ + "node_move", + "mesh_init", + "mesh_clear", + "mesh_node_at" + ] + }, + "enum_constants": {}, + "include_graph": { + "general/mesh.h": [] + }, + "system_includes": { + "general/mesh.h": [ + "stddef.h" + ] + }, + "unresolved_includes": { + "general/mesh.h": [] + }, + "header_source_pairs": { + "general/mesh.h": [] + }, + "diagnostics": [] +} diff --git a/tests/parser/c/fixtures/general/modern_math_physics.json b/tests/parser/c/fixtures/general/modern_math_physics.json new file mode 100644 index 000000000..9677fb3fa --- /dev/null +++ b/tests/parser/c/fixtures/general/modern_math_physics.json @@ -0,0 +1,2508 @@ +{ + "files": { + "general/modern_math_physics.c": { + "filename": "general/modern_math_physics.c", + "language": "c", + "parser_status": "partial", + "preprocessing": "raw", + "functions": [ + { + "name": "init_particle", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "modern_particle *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "modern_particle", + "name": "modern_particle", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": "modern_particle", + "members": [ + { + "name": "id", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int id" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "general/modern_math_physics.h", + "line": 7, + "column": 5, + "source_line": " int id;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "mass", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double mass" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "general/modern_math_physics.h", + "line": 8, + "column": 5, + "source_line": " double mass;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "position", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "double position[3]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "3", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "general/modern_math_physics.h", + "line": 9, + "column": 5, + "source_line": " double position[3];" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": null, + "is_incomplete": false, + "source_location": { + "filename": "general/modern_math_physics.h", + "line": 6, + "column": 1, + "source_line": "struct modern_particle {" + } + }, + "source_location": { + "filename": "general/modern_math_physics.h", + "line": 16, + "column": 1, + "source_line": "typedef struct modern_particle modern_particle;" + }, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "modern_particle *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "modern_particle" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "pid", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int pid" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int pid" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mass", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double mass" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double mass" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double x" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double y" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "z", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double z" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double z" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "general/modern_math_physics.c", + "line": 8, + "column": 1, + "source_line": "void init_particle(modern_particle *p, int pid, double mass, double x, double y, double z)" + }, + "start": { + "filename": "general/modern_math_physics.c", + "line": 8, + "column": 1, + "source_line": "void init_particle(modern_particle *p, int pid, double mass, double x, double y, double z)" + }, + "end": { + "filename": "general/modern_math_physics.c", + "line": 16, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "general/modern_math_physics.h", + "line": 19, + "column": 1, + "source_line": "void init_particle(modern_particle *p, int pid, double mass, double x, double y, double z);" + } + ] + }, + { + "name": "kinetic_energy", + "result_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const modern_particle *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "modern_particle" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const modern_particle *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "modern_particle" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "vx", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double vx" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double vx" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "vy", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double vy" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double vy" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "vz", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double vz" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double vz" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "general/modern_math_physics.c", + "line": 18, + "column": 1, + "source_line": "double kinetic_energy(const modern_particle *p, double vx, double vy, double vz)" + }, + "start": { + "filename": "general/modern_math_physics.c", + "line": 18, + "column": 1, + "source_line": "double kinetic_energy(const modern_particle *p, double vx, double vy, double vz)" + }, + "end": { + "filename": "general/modern_math_physics.c", + "line": 21, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "general/modern_math_physics.h", + "line": 20, + "column": 1, + "source_line": "double kinetic_energy(const modern_particle *p, double vx, double vy, double vz);" + } + ] + }, + { + "name": "scale_vector", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "v", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "double v[static 1]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "double v[static 1]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "1", + "is_static_minimum": true, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "alpha", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double alpha" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double alpha" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "general/modern_math_physics.c", + "line": 23, + "column": 1, + "source_line": "void scale_vector(int n, double v[static 1], double alpha)" + }, + "start": { + "filename": "general/modern_math_physics.c", + "line": 23, + "column": 1, + "source_line": "void scale_vector(int n, double v[static 1], double alpha)" + }, + "end": { + "filename": "general/modern_math_physics.c", + "line": 28, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "general/modern_math_physics.h", + "line": 21, + "column": 1, + "source_line": "void scale_vector(int n, double v[static 1], double alpha);" + } + ] + }, + { + "name": "dot3", + "result_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const double a[static 3]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CDouble", + "qualifiers": [ + "const" + ], + "source_text": "const double" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const double a[static 3]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "3", + "is_static_minimum": true, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CDouble", + "qualifiers": [ + "const" + ], + "source_text": "const double" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const double b[static 3]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CDouble", + "qualifiers": [ + "const" + ], + "source_text": "const double" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const double b[static 3]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "3", + "is_static_minimum": true, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CDouble", + "qualifiers": [ + "const" + ], + "source_text": "const double" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "general/modern_math_physics.c", + "line": 30, + "column": 1, + "source_line": "double dot3(const double a[static 3], const double b[static 3])" + }, + "start": { + "filename": "general/modern_math_physics.c", + "line": 30, + "column": 1, + "source_line": "double dot3(const double a[static 3], const double b[static 3])" + }, + "end": { + "filename": "general/modern_math_physics.c", + "line": 33, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "general/modern_math_physics.h", + "line": 22, + "column": 1, + "source_line": "double dot3(const double a[static 3], const double b[static 3]);" + } + ] + }, + { + "name": "fill_identity3_modern", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "double a[static 3][3]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "3", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "double a[static 3][3]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "3", + "is_static_minimum": true, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "3", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "general/modern_math_physics.c", + "line": 35, + "column": 1, + "source_line": "void fill_identity3_modern(double a[static 3][3])" + }, + "start": { + "filename": "general/modern_math_physics.c", + "line": 35, + "column": 1, + "source_line": "void fill_identity3_modern(double a[static 3][3])" + }, + "end": { + "filename": "general/modern_math_physics.c", + "line": 42, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "general/modern_math_physics.h", + "line": 23, + "column": 1, + "source_line": "void fill_identity3_modern(double a[static 3][3]);" + } + ] + }, + { + "name": "normalize_particle", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "modern_particle *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "modern_particle" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "modern_particle *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "modern_particle" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "general/modern_math_physics.c", + "line": 44, + "column": 1, + "source_line": "void normalize_particle(modern_particle *p)" + }, + "start": { + "filename": "general/modern_math_physics.c", + "line": 44, + "column": 1, + "source_line": "void normalize_particle(modern_particle *p)" + }, + "end": { + "filename": "general/modern_math_physics.c", + "line": 52, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "general/modern_math_physics.h", + "line": 24, + "column": 1, + "source_line": "void normalize_particle(modern_particle *p);" + } + ] + } + ], + "structs": [], + "unions": [], + "enums": [], + "typedefs": [], + "variables": [ + { + "name": "modern_counter", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int modern_counter" + }, + "storage": [], + "initializer": { + "source_text": "0" + }, + "bit_width": null, + "source_location": { + "filename": "general/modern_math_physics.c", + "line": 5, + "column": 1, + "source_line": "int modern_counter = 0;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "hidden_scale", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "static double hidden_scale" + }, + "storage": [ + "static" + ], + "initializer": { + "source_text": "1.0" + }, + "bit_width": null, + "source_location": { + "filename": "general/modern_math_physics.c", + "line": 6, + "column": 1, + "source_line": "static double hidden_scale = 1.0;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "macros": [], + "includes": [ + { + "target": "modern_math_physics.h", + "kind": "local", + "resolved_path": "general/modern_math_physics.h", + "source_location": { + "filename": "general/modern_math_physics.c", + "line": 1, + "column": 1, + "source_line": "#include \"modern_math_physics.h\"" + } + }, + { + "target": "math.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "general/modern_math_physics.c", + "line": 3, + "column": 1, + "source_line": "#include " + } + } + ], + "raw_directives": [], + "macro_dependencies": [], + "diagnostics": [] + }, + "general/modern_math_physics.h": { + "filename": "general/modern_math_physics.h", + "language": "c", + "parser_status": "partial", + "preprocessing": "raw", + "functions": [ + { + "name": "init_particle", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "modern_particle *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "modern_particle" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "modern_particle *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "modern_particle" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "pid", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int pid" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int pid" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mass", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double mass" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double mass" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double x" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double y" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "z", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double z" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double z" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": false, + "prototype_style": "prototype", + "source_location": { + "filename": "general/modern_math_physics.h", + "line": 19, + "column": 1, + "source_line": "void init_particle(modern_particle *p, int pid, double mass, double x, double y, double z);" + }, + "start": { + "filename": "general/modern_math_physics.h", + "line": 19, + "column": 1, + "source_line": "void init_particle(modern_particle *p, int pid, double mass, double x, double y, double z);" + }, + "end": null, + "declaration_locations": [] + }, + { + "name": "kinetic_energy", + "result_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const modern_particle *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "modern_particle" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const modern_particle *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "modern_particle" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "vx", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double vx" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double vx" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "vy", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double vy" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double vy" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "vz", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double vz" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double vz" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": false, + "prototype_style": "prototype", + "source_location": { + "filename": "general/modern_math_physics.h", + "line": 20, + "column": 1, + "source_line": "double kinetic_energy(const modern_particle *p, double vx, double vy, double vz);" + }, + "start": { + "filename": "general/modern_math_physics.h", + "line": 20, + "column": 1, + "source_line": "double kinetic_energy(const modern_particle *p, double vx, double vy, double vz);" + }, + "end": null, + "declaration_locations": [] + }, + { + "name": "scale_vector", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "v", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "double v[static 1]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "double v[static 1]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "1", + "is_static_minimum": true, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "alpha", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double alpha" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double alpha" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": false, + "prototype_style": "prototype", + "source_location": { + "filename": "general/modern_math_physics.h", + "line": 21, + "column": 1, + "source_line": "void scale_vector(int n, double v[static 1], double alpha);" + }, + "start": { + "filename": "general/modern_math_physics.h", + "line": 21, + "column": 1, + "source_line": "void scale_vector(int n, double v[static 1], double alpha);" + }, + "end": null, + "declaration_locations": [] + }, + { + "name": "dot3", + "result_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const double a[static 3]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CDouble", + "qualifiers": [ + "const" + ], + "source_text": "const double" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const double a[static 3]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "3", + "is_static_minimum": true, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CDouble", + "qualifiers": [ + "const" + ], + "source_text": "const double" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const double b[static 3]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CDouble", + "qualifiers": [ + "const" + ], + "source_text": "const double" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const double b[static 3]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "3", + "is_static_minimum": true, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CDouble", + "qualifiers": [ + "const" + ], + "source_text": "const double" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": false, + "prototype_style": "prototype", + "source_location": { + "filename": "general/modern_math_physics.h", + "line": 22, + "column": 1, + "source_line": "double dot3(const double a[static 3], const double b[static 3]);" + }, + "start": { + "filename": "general/modern_math_physics.h", + "line": 22, + "column": 1, + "source_line": "double dot3(const double a[static 3], const double b[static 3]);" + }, + "end": null, + "declaration_locations": [] + }, + { + "name": "fill_identity3_modern", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "double a[static 3][3]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "3", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "double a[static 3][3]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "3", + "is_static_minimum": true, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "3", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": false, + "prototype_style": "prototype", + "source_location": { + "filename": "general/modern_math_physics.h", + "line": 23, + "column": 1, + "source_line": "void fill_identity3_modern(double a[static 3][3]);" + }, + "start": { + "filename": "general/modern_math_physics.h", + "line": 23, + "column": 1, + "source_line": "void fill_identity3_modern(double a[static 3][3]);" + }, + "end": null, + "declaration_locations": [] + }, + { + "name": "normalize_particle", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "modern_particle *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "modern_particle" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "modern_particle *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "modern_particle" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": false, + "prototype_style": "prototype", + "source_location": { + "filename": "general/modern_math_physics.h", + "line": 24, + "column": 1, + "source_line": "void normalize_particle(modern_particle *p);" + }, + "start": { + "filename": "general/modern_math_physics.h", + "line": 24, + "column": 1, + "source_line": "void normalize_particle(modern_particle *p);" + }, + "end": null, + "declaration_locations": [] + } + ], + "structs": [ + { + "reference": "struct modern_particle" + }, + { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": "vector3", + "members": [ + { + "name": "values", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "double values[3]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "3", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "general/modern_math_physics.h", + "line": 13, + "column": 5, + "source_line": " double values[3];" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": null, + "is_incomplete": false, + "source_location": { + "filename": "general/modern_math_physics.h", + "line": 12, + "column": 1, + "source_line": "struct vector3 {" + } + } + ], + "unions": [], + "enums": [], + "typedefs": [ + { + "reference": "modern_particle" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "vector3", + "name": "vector3", + "type": { + "reference": "struct vector3" + }, + "source_location": { + "filename": "general/modern_math_physics.h", + "line": 17, + "column": 1, + "source_line": "typedef struct vector3 vector3;" + }, + "declaration_locations": [] + } + ], + "variables": [ + { + "name": "modern_counter", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "extern int modern_counter" + }, + "storage": [ + "extern" + ], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "general/modern_math_physics.h", + "line": 4, + "column": 1, + "source_line": "extern int modern_counter;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "macros": [ + { + "name": "X2PY_GENERAL_MODERN_MATH_PHYSICS_H", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "general/modern_math_physics.h", + "line": 2, + "column": 1, + "source_line": "#define X2PY_GENERAL_MODERN_MATH_PHYSICS_H" + } + } + ], + "includes": [], + "raw_directives": [ + { + "directive": "ifndef", + "argument": "X2PY_GENERAL_MODERN_MATH_PHYSICS_H", + "source_location": { + "filename": "general/modern_math_physics.h", + "line": 1, + "column": 1, + "source_line": "#ifndef X2PY_GENERAL_MODERN_MATH_PHYSICS_H" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "general/modern_math_physics.h", + "line": 26, + "column": 1, + "source_line": "#endif" + } + } + ], + "macro_dependencies": [], + "diagnostics": [] + } + }, + "functions": { + "init_particle": { + "name": "init_particle", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "modern_particle *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "modern_particle" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "modern_particle *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "modern_particle" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "pid", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int pid" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int pid" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mass", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double mass" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double mass" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double x" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double y" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "z", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double z" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double z" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "general/modern_math_physics.c", + "line": 8, + "column": 1, + "source_line": "void init_particle(modern_particle *p, int pid, double mass, double x, double y, double z)" + }, + "start": { + "filename": "general/modern_math_physics.c", + "line": 8, + "column": 1, + "source_line": "void init_particle(modern_particle *p, int pid, double mass, double x, double y, double z)" + }, + "end": { + "filename": "general/modern_math_physics.c", + "line": 16, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "general/modern_math_physics.h", + "line": 19, + "column": 1, + "source_line": "void init_particle(modern_particle *p, int pid, double mass, double x, double y, double z);" + } + ] + }, + "kinetic_energy": { + "name": "kinetic_energy", + "result_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const modern_particle *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "modern_particle" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const modern_particle *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "modern_particle" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "vx", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double vx" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double vx" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "vy", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double vy" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double vy" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "vz", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double vz" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double vz" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "general/modern_math_physics.c", + "line": 18, + "column": 1, + "source_line": "double kinetic_energy(const modern_particle *p, double vx, double vy, double vz)" + }, + "start": { + "filename": "general/modern_math_physics.c", + "line": 18, + "column": 1, + "source_line": "double kinetic_energy(const modern_particle *p, double vx, double vy, double vz)" + }, + "end": { + "filename": "general/modern_math_physics.c", + "line": 21, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "general/modern_math_physics.h", + "line": 20, + "column": 1, + "source_line": "double kinetic_energy(const modern_particle *p, double vx, double vy, double vz);" + } + ] + }, + "scale_vector": { + "name": "scale_vector", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "v", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "double v[static 1]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "double v[static 1]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "1", + "is_static_minimum": true, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "alpha", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double alpha" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double alpha" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "general/modern_math_physics.c", + "line": 23, + "column": 1, + "source_line": "void scale_vector(int n, double v[static 1], double alpha)" + }, + "start": { + "filename": "general/modern_math_physics.c", + "line": 23, + "column": 1, + "source_line": "void scale_vector(int n, double v[static 1], double alpha)" + }, + "end": { + "filename": "general/modern_math_physics.c", + "line": 28, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "general/modern_math_physics.h", + "line": 21, + "column": 1, + "source_line": "void scale_vector(int n, double v[static 1], double alpha);" + } + ] + }, + "dot3": { + "name": "dot3", + "result_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const double a[static 3]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CDouble", + "qualifiers": [ + "const" + ], + "source_text": "const double" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const double a[static 3]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "3", + "is_static_minimum": true, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CDouble", + "qualifiers": [ + "const" + ], + "source_text": "const double" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const double b[static 3]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CDouble", + "qualifiers": [ + "const" + ], + "source_text": "const double" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const double b[static 3]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "3", + "is_static_minimum": true, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CDouble", + "qualifiers": [ + "const" + ], + "source_text": "const double" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "general/modern_math_physics.c", + "line": 30, + "column": 1, + "source_line": "double dot3(const double a[static 3], const double b[static 3])" + }, + "start": { + "filename": "general/modern_math_physics.c", + "line": 30, + "column": 1, + "source_line": "double dot3(const double a[static 3], const double b[static 3])" + }, + "end": { + "filename": "general/modern_math_physics.c", + "line": 33, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "general/modern_math_physics.h", + "line": 22, + "column": 1, + "source_line": "double dot3(const double a[static 3], const double b[static 3]);" + } + ] + }, + "fill_identity3_modern": { + "name": "fill_identity3_modern", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "double a[static 3][3]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "3", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "double a[static 3][3]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "3", + "is_static_minimum": true, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "3", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "general/modern_math_physics.c", + "line": 35, + "column": 1, + "source_line": "void fill_identity3_modern(double a[static 3][3])" + }, + "start": { + "filename": "general/modern_math_physics.c", + "line": 35, + "column": 1, + "source_line": "void fill_identity3_modern(double a[static 3][3])" + }, + "end": { + "filename": "general/modern_math_physics.c", + "line": 42, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "general/modern_math_physics.h", + "line": 23, + "column": 1, + "source_line": "void fill_identity3_modern(double a[static 3][3]);" + } + ] + }, + "normalize_particle": { + "name": "normalize_particle", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "modern_particle *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "modern_particle" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "modern_particle *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "modern_particle" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "general/modern_math_physics.c", + "line": 44, + "column": 1, + "source_line": "void normalize_particle(modern_particle *p)" + }, + "start": { + "filename": "general/modern_math_physics.c", + "line": 44, + "column": 1, + "source_line": "void normalize_particle(modern_particle *p)" + }, + "end": { + "filename": "general/modern_math_physics.c", + "line": 52, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "general/modern_math_physics.h", + "line": 24, + "column": 1, + "source_line": "void normalize_particle(modern_particle *p);" + } + ] + } + }, + "structs": { + "modern_particle": { + "reference": "struct modern_particle" + }, + "vector3": { + "reference": "struct vector3" + } + }, + "unions": {}, + "enums": {}, + "typedefs": { + "modern_particle": { + "reference": "modern_particle" + }, + "vector3": { + "reference": "vector3" + } + }, + "variables": { + "modern_counter": { + "name": "modern_counter", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "extern int modern_counter" + }, + "storage": [ + "extern" + ], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "general/modern_math_physics.h", + "line": 4, + "column": 1, + "source_line": "extern int modern_counter;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + "hidden_scale": { + "name": "hidden_scale", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "static double hidden_scale" + }, + "storage": [ + "static" + ], + "initializer": { + "source_text": "1.0" + }, + "bit_width": null, + "source_location": { + "filename": "general/modern_math_physics.c", + "line": 6, + "column": 1, + "source_line": "static double hidden_scale = 1.0;" + }, + "callback_policy": null, + "declaration_locations": [] + } + }, + "macros": { + "X2PY_GENERAL_MODERN_MATH_PHYSICS_H": { + "name": "X2PY_GENERAL_MODERN_MATH_PHYSICS_H", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "general/modern_math_physics.h", + "line": 2, + "column": 1, + "source_line": "#define X2PY_GENERAL_MODERN_MATH_PHYSICS_H" + } + } + }, + "includes": { + "general/modern_math_physics.c:modern_math_physics.h": { + "target": "modern_math_physics.h", + "kind": "local", + "resolved_path": "general/modern_math_physics.h", + "source_location": { + "filename": "general/modern_math_physics.c", + "line": 1, + "column": 1, + "source_line": "#include \"modern_math_physics.h\"" + } + }, + "general/modern_math_physics.c:math.h": { + "target": "math.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "general/modern_math_physics.c", + "line": 3, + "column": 1, + "source_line": "#include " + } + } + }, + "functions_by_file": { + "general/modern_math_physics.c": [ + "init_particle", + "kinetic_energy", + "scale_vector", + "dot3", + "fill_identity3_modern", + "normalize_particle" + ], + "general/modern_math_physics.h": [ + "init_particle", + "kinetic_energy", + "scale_vector", + "dot3", + "fill_identity3_modern", + "normalize_particle" + ] + }, + "enum_constants": {}, + "include_graph": { + "general/modern_math_physics.c": [ + "general/modern_math_physics.h" + ], + "general/modern_math_physics.h": [] + }, + "system_includes": { + "general/modern_math_physics.c": [ + "math.h" + ], + "general/modern_math_physics.h": [] + }, + "unresolved_includes": { + "general/modern_math_physics.c": [], + "general/modern_math_physics.h": [] + }, + "header_source_pairs": { + "general/modern_math_physics.h": [ + "general/modern_math_physics.c" + ] + }, + "diagnostics": [] +} diff --git a/tests/parser/c/fixtures/general/name_reuse.json b/tests/parser/c/fixtures/general/name_reuse.json new file mode 100644 index 000000000..4dcd1eb8e --- /dev/null +++ b/tests/parser/c/fixtures/general/name_reuse.json @@ -0,0 +1,1202 @@ +{ + "files": { + "general/name_reuse.h": { + "filename": "general/name_reuse.h", + "language": "c", + "parser_status": "partial", + "preprocessing": "raw", + "functions": [ + { + "name": "do_work_i", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "same_name", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *same_name", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *same_name", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": false, + "prototype_style": "prototype", + "source_location": { + "filename": "general/name_reuse.h", + "line": 16, + "column": 1, + "source_line": "void do_work_i(int *same_name);" + }, + "start": { + "filename": "general/name_reuse.h", + "line": 16, + "column": 1, + "source_line": "void do_work_i(int *same_name);" + }, + "end": null, + "declaration_locations": [] + }, + { + "name": "do_work_r", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "same_name", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float same_name" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float same_name" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": false, + "prototype_style": "prototype", + "source_location": { + "filename": "general/name_reuse.h", + "line": 17, + "column": 1, + "source_line": "void do_work_r(float same_name);" + }, + "start": { + "filename": "general/name_reuse.h", + "line": 17, + "column": 1, + "source_line": "void do_work_r(float same_name);" + }, + "end": null, + "declaration_locations": [] + }, + { + "name": "do_work_l", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "same_name", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "bool same_name", + "name": "bool", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "declared_type": { + "reference": "bool" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "shared", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "struct same_name *shared", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": "same_name", + "members": [ + { + "name": "payload", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int payload" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "general/name_reuse.h", + "line": 7, + "column": 5, + "source_line": " int payload;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": null, + "is_incomplete": false, + "source_location": { + "filename": "general/name_reuse.h", + "line": 6, + "column": 1, + "source_line": "struct same_name {" + } + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "struct same_name *shared", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "struct same_name" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": false, + "prototype_style": "prototype", + "source_location": { + "filename": "general/name_reuse.h", + "line": 18, + "column": 1, + "source_line": "void do_work_l(bool same_name, struct same_name *shared);" + }, + "start": { + "filename": "general/name_reuse.h", + "line": 18, + "column": 1, + "source_line": "void do_work_l(bool same_name, struct same_name *shared);" + }, + "end": null, + "declaration_locations": [] + }, + { + "name": "convert_to_complex", + "result_type": { + "model": "CDoubleComplex", + "qualifiers": [], + "source_text": "double _Complex" + }, + "parameters": [ + { + "name": "same_name", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int same_name" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int same_name" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": false, + "prototype_style": "prototype", + "source_location": { + "filename": "general/name_reuse.h", + "line": 19, + "column": 1, + "source_line": "double _Complex convert_to_complex(int same_name);" + }, + "start": { + "filename": "general/name_reuse.h", + "line": 19, + "column": 1, + "source_line": "double _Complex convert_to_complex(int same_name);" + }, + "end": null, + "declaration_locations": [] + }, + { + "name": "convert_to_string", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "same_name", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float same_name" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float same_name" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "shared", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char shared[static 16]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char shared[static 16]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "16", + "is_static_minimum": true, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": false, + "prototype_style": "prototype", + "source_location": { + "filename": "general/name_reuse.h", + "line": 20, + "column": 1, + "source_line": "int convert_to_string(float same_name, char shared[static 16]);" + }, + "start": { + "filename": "general/name_reuse.h", + "line": 20, + "column": 1, + "source_line": "int convert_to_string(float same_name, char shared[static 16]);" + }, + "end": null, + "declaration_locations": [] + }, + { + "name": "convert_to_logical", + "result_type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "bool", + "name": "bool", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "parameters": [ + { + "name": "same_name", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *same_name", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *same_name", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": false, + "prototype_style": "prototype", + "source_location": { + "filename": "general/name_reuse.h", + "line": 21, + "column": 1, + "source_line": "bool convert_to_logical(const char *same_name);" + }, + "start": { + "filename": "general/name_reuse.h", + "line": 21, + "column": 1, + "source_line": "bool convert_to_logical(const char *same_name);" + }, + "end": null, + "declaration_locations": [] + } + ], + "structs": [ + { + "reference": "struct same_name" + } + ], + "unions": [], + "enums": [], + "typedefs": [], + "variables": [ + { + "name": "same_name_i", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "extern int same_name_i" + }, + "storage": [ + "extern" + ], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "general/name_reuse.h", + "line": 10, + "column": 1, + "source_line": "extern int same_name_i;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "same_name_r", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "extern float same_name_r" + }, + "storage": [ + "extern" + ], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "general/name_reuse.h", + "line": 11, + "column": 1, + "source_line": "extern float same_name_r;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "same_name_l", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "extern bool same_name_l", + "name": "bool", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "storage": [ + "extern" + ], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "general/name_reuse.h", + "line": 12, + "column": 1, + "source_line": "extern bool same_name_l;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "same_name_c", + "type": { + "model": "CDoubleComplex", + "qualifiers": [], + "source_text": "extern double _Complex same_name_c" + }, + "storage": [ + "extern" + ], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "general/name_reuse.h", + "line": 13, + "column": 1, + "source_line": "extern double _Complex same_name_c;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "same_name_s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "extern char same_name_s[8]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "8", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "storage": [ + "extern" + ], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "general/name_reuse.h", + "line": 14, + "column": 1, + "source_line": "extern char same_name_s[8];" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "macros": [ + { + "name": "X2PY_GENERAL_NAME_REUSE_H", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "general/name_reuse.h", + "line": 2, + "column": 1, + "source_line": "#define X2PY_GENERAL_NAME_REUSE_H" + } + } + ], + "includes": [ + { + "target": "stdbool.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "general/name_reuse.h", + "line": 4, + "column": 1, + "source_line": "#include " + } + } + ], + "raw_directives": [ + { + "directive": "ifndef", + "argument": "X2PY_GENERAL_NAME_REUSE_H", + "source_location": { + "filename": "general/name_reuse.h", + "line": 1, + "column": 1, + "source_line": "#ifndef X2PY_GENERAL_NAME_REUSE_H" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "general/name_reuse.h", + "line": 23, + "column": 1, + "source_line": "#endif" + } + } + ], + "macro_dependencies": [], + "diagnostics": [] + } + }, + "functions": { + "do_work_i": { + "name": "do_work_i", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "same_name", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *same_name", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *same_name", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": false, + "prototype_style": "prototype", + "source_location": { + "filename": "general/name_reuse.h", + "line": 16, + "column": 1, + "source_line": "void do_work_i(int *same_name);" + }, + "start": { + "filename": "general/name_reuse.h", + "line": 16, + "column": 1, + "source_line": "void do_work_i(int *same_name);" + }, + "end": null, + "declaration_locations": [] + }, + "do_work_r": { + "name": "do_work_r", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "same_name", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float same_name" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float same_name" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": false, + "prototype_style": "prototype", + "source_location": { + "filename": "general/name_reuse.h", + "line": 17, + "column": 1, + "source_line": "void do_work_r(float same_name);" + }, + "start": { + "filename": "general/name_reuse.h", + "line": 17, + "column": 1, + "source_line": "void do_work_r(float same_name);" + }, + "end": null, + "declaration_locations": [] + }, + "do_work_l": { + "name": "do_work_l", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "same_name", + "type": { + "reference": "bool" + }, + "declared_type": { + "reference": "bool" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "shared", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "struct same_name *shared", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "struct same_name" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "struct same_name *shared", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "struct same_name" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": false, + "prototype_style": "prototype", + "source_location": { + "filename": "general/name_reuse.h", + "line": 18, + "column": 1, + "source_line": "void do_work_l(bool same_name, struct same_name *shared);" + }, + "start": { + "filename": "general/name_reuse.h", + "line": 18, + "column": 1, + "source_line": "void do_work_l(bool same_name, struct same_name *shared);" + }, + "end": null, + "declaration_locations": [] + }, + "convert_to_complex": { + "name": "convert_to_complex", + "result_type": { + "model": "CDoubleComplex", + "qualifiers": [], + "source_text": "double _Complex" + }, + "parameters": [ + { + "name": "same_name", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int same_name" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int same_name" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": false, + "prototype_style": "prototype", + "source_location": { + "filename": "general/name_reuse.h", + "line": 19, + "column": 1, + "source_line": "double _Complex convert_to_complex(int same_name);" + }, + "start": { + "filename": "general/name_reuse.h", + "line": 19, + "column": 1, + "source_line": "double _Complex convert_to_complex(int same_name);" + }, + "end": null, + "declaration_locations": [] + }, + "convert_to_string": { + "name": "convert_to_string", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "same_name", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float same_name" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float same_name" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "shared", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char shared[static 16]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char shared[static 16]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "16", + "is_static_minimum": true, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": false, + "prototype_style": "prototype", + "source_location": { + "filename": "general/name_reuse.h", + "line": 20, + "column": 1, + "source_line": "int convert_to_string(float same_name, char shared[static 16]);" + }, + "start": { + "filename": "general/name_reuse.h", + "line": 20, + "column": 1, + "source_line": "int convert_to_string(float same_name, char shared[static 16]);" + }, + "end": null, + "declaration_locations": [] + }, + "convert_to_logical": { + "name": "convert_to_logical", + "result_type": { + "reference": "bool" + }, + "parameters": [ + { + "name": "same_name", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *same_name", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *same_name", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": false, + "prototype_style": "prototype", + "source_location": { + "filename": "general/name_reuse.h", + "line": 21, + "column": 1, + "source_line": "bool convert_to_logical(const char *same_name);" + }, + "start": { + "filename": "general/name_reuse.h", + "line": 21, + "column": 1, + "source_line": "bool convert_to_logical(const char *same_name);" + }, + "end": null, + "declaration_locations": [] + } + }, + "structs": { + "same_name": { + "reference": "struct same_name" + } + }, + "unions": {}, + "enums": {}, + "typedefs": {}, + "variables": { + "same_name_i": { + "name": "same_name_i", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "extern int same_name_i" + }, + "storage": [ + "extern" + ], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "general/name_reuse.h", + "line": 10, + "column": 1, + "source_line": "extern int same_name_i;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + "same_name_r": { + "name": "same_name_r", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "extern float same_name_r" + }, + "storage": [ + "extern" + ], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "general/name_reuse.h", + "line": 11, + "column": 1, + "source_line": "extern float same_name_r;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + "same_name_l": { + "name": "same_name_l", + "type": { + "reference": "bool" + }, + "storage": [ + "extern" + ], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "general/name_reuse.h", + "line": 12, + "column": 1, + "source_line": "extern bool same_name_l;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + "same_name_c": { + "name": "same_name_c", + "type": { + "model": "CDoubleComplex", + "qualifiers": [], + "source_text": "extern double _Complex same_name_c" + }, + "storage": [ + "extern" + ], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "general/name_reuse.h", + "line": 13, + "column": 1, + "source_line": "extern double _Complex same_name_c;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + "same_name_s": { + "name": "same_name_s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "extern char same_name_s[8]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "8", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "storage": [ + "extern" + ], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "general/name_reuse.h", + "line": 14, + "column": 1, + "source_line": "extern char same_name_s[8];" + }, + "callback_policy": null, + "declaration_locations": [] + } + }, + "macros": { + "X2PY_GENERAL_NAME_REUSE_H": { + "name": "X2PY_GENERAL_NAME_REUSE_H", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "general/name_reuse.h", + "line": 2, + "column": 1, + "source_line": "#define X2PY_GENERAL_NAME_REUSE_H" + } + } + }, + "includes": { + "general/name_reuse.h:stdbool.h": { + "target": "stdbool.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "general/name_reuse.h", + "line": 4, + "column": 1, + "source_line": "#include " + } + } + }, + "functions_by_file": { + "general/name_reuse.h": [ + "do_work_i", + "do_work_r", + "do_work_l", + "convert_to_complex", + "convert_to_string", + "convert_to_logical" + ] + }, + "enum_constants": {}, + "include_graph": { + "general/name_reuse.h": [] + }, + "system_includes": { + "general/name_reuse.h": [ + "stdbool.h" + ] + }, + "unresolved_includes": { + "general/name_reuse.h": [] + }, + "header_source_pairs": { + "general/name_reuse.h": [] + }, + "diagnostics": [] +} diff --git a/tests/parser/c/fixtures/general/particles.json b/tests/parser/c/fixtures/general/particles.json new file mode 100644 index 000000000..88498cee2 --- /dev/null +++ b/tests/parser/c/fixtures/general/particles.json @@ -0,0 +1,1267 @@ +{ + "files": { + "general/particles.c": { + "filename": "general/particles.c", + "language": "c", + "parser_status": "partial", + "preprocessing": "raw", + "functions": [ + { + "name": "particle_touch", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "struct particle *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": "particle", + "members": [ + { + "name": "id", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int id" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "general/particles.h", + "line": 5, + "column": 5, + "source_line": " int id;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "double x[3]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "3", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "general/particles.h", + "line": 6, + "column": 5, + "source_line": " double x[3];" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": null, + "is_incomplete": false, + "source_location": { + "filename": "general/particles.h", + "line": 4, + "column": 1, + "source_line": "struct particle {" + } + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "struct particle *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "struct particle" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "general/particles.c", + "line": 5, + "column": 1, + "source_line": "void particle_touch(struct particle *p)" + }, + "start": { + "filename": "general/particles.c", + "line": 5, + "column": 1, + "source_line": "void particle_touch(struct particle *p)" + }, + "end": { + "filename": "general/particles.c", + "line": 10, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "general/particles.h", + "line": 12, + "column": 1, + "source_line": "void particle_touch(struct particle *p);" + } + ] + }, + { + "name": "particle_reset", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "particle *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "particle", + "name": "particle", + "type": { + "reference": "struct particle" + }, + "source_location": { + "filename": "general/particles.h", + "line": 9, + "column": 1, + "source_line": "typedef struct particle particle;" + }, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "particle *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "particle" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "general/particles.c", + "line": 12, + "column": 1, + "source_line": "void particle_reset(particle *p)" + }, + "start": { + "filename": "general/particles.c", + "line": 12, + "column": 1, + "source_line": "void particle_reset(particle *p)" + }, + "end": { + "filename": "general/particles.c", + "line": 20, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "general/particles.h", + "line": 13, + "column": 1, + "source_line": "void particle_reset(particle *p);" + } + ] + }, + { + "name": "particle_move", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "particle *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "particle" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "particle *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "particle" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "delta", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const double delta[static 3]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CDouble", + "qualifiers": [ + "const" + ], + "source_text": "const double" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const double delta[static 3]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "3", + "is_static_minimum": true, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CDouble", + "qualifiers": [ + "const" + ], + "source_text": "const double" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "general/particles.c", + "line": 22, + "column": 1, + "source_line": "void particle_move(particle *p, const double delta[static 3])" + }, + "start": { + "filename": "general/particles.c", + "line": 22, + "column": 1, + "source_line": "void particle_move(particle *p, const double delta[static 3])" + }, + "end": { + "filename": "general/particles.c", + "line": 29, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "general/particles.h", + "line": 14, + "column": 1, + "source_line": "void particle_move(particle *p, const double delta[static 3]);" + } + ] + }, + { + "name": "particle_current", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const struct particle", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CStruct", + "qualifiers": [ + "const" + ], + "source_text": "const struct particle", + "name": "particle", + "members": [], + "anonymous_id": null, + "is_incomplete": true, + "source_location": null + } + ] + }, + "parameters": [], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "general/particles.c", + "line": 31, + "column": 1, + "source_line": "const struct particle *particle_current(void)" + }, + "start": { + "filename": "general/particles.c", + "line": 31, + "column": 1, + "source_line": "const struct particle *particle_current(void)" + }, + "end": { + "filename": "general/particles.c", + "line": 34, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "general/particles.h", + "line": 15, + "column": 1, + "source_line": "const struct particle *particle_current(void);" + } + ] + } + ], + "structs": [], + "unions": [], + "enums": [], + "typedefs": [], + "variables": [ + { + "name": "current_particle", + "type": { + "reference": "struct particle" + }, + "storage": [ + "static" + ], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "general/particles.c", + "line": 3, + "column": 1, + "source_line": "static struct particle current_particle;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "macros": [], + "includes": [ + { + "target": "particles.h", + "kind": "local", + "resolved_path": "general/particles.h", + "source_location": { + "filename": "general/particles.c", + "line": 1, + "column": 1, + "source_line": "#include \"particles.h\"" + } + } + ], + "raw_directives": [], + "macro_dependencies": [], + "diagnostics": [] + }, + "general/particles.h": { + "filename": "general/particles.h", + "language": "c", + "parser_status": "partial", + "preprocessing": "raw", + "functions": [ + { + "name": "particle_touch", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "struct particle *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "struct particle" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "struct particle *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "struct particle" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": false, + "prototype_style": "prototype", + "source_location": { + "filename": "general/particles.h", + "line": 12, + "column": 1, + "source_line": "void particle_touch(struct particle *p);" + }, + "start": { + "filename": "general/particles.h", + "line": 12, + "column": 1, + "source_line": "void particle_touch(struct particle *p);" + }, + "end": null, + "declaration_locations": [] + }, + { + "name": "particle_reset", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "particle *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "particle" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "particle *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "particle" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": false, + "prototype_style": "prototype", + "source_location": { + "filename": "general/particles.h", + "line": 13, + "column": 1, + "source_line": "void particle_reset(particle *p);" + }, + "start": { + "filename": "general/particles.h", + "line": 13, + "column": 1, + "source_line": "void particle_reset(particle *p);" + }, + "end": null, + "declaration_locations": [] + }, + { + "name": "particle_move", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "particle *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "particle" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "particle *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "particle" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "delta", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const double delta[static 3]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CDouble", + "qualifiers": [ + "const" + ], + "source_text": "const double" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const double delta[static 3]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "3", + "is_static_minimum": true, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CDouble", + "qualifiers": [ + "const" + ], + "source_text": "const double" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": false, + "prototype_style": "prototype", + "source_location": { + "filename": "general/particles.h", + "line": 14, + "column": 1, + "source_line": "void particle_move(particle *p, const double delta[static 3]);" + }, + "start": { + "filename": "general/particles.h", + "line": 14, + "column": 1, + "source_line": "void particle_move(particle *p, const double delta[static 3]);" + }, + "end": null, + "declaration_locations": [] + }, + { + "name": "particle_current", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const struct particle", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CStruct", + "qualifiers": [ + "const" + ], + "source_text": "const struct particle", + "name": "particle", + "members": [], + "anonymous_id": null, + "is_incomplete": true, + "source_location": null + } + ] + }, + "parameters": [], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": false, + "prototype_style": "prototype", + "source_location": { + "filename": "general/particles.h", + "line": 15, + "column": 1, + "source_line": "const struct particle *particle_current(void);" + }, + "start": { + "filename": "general/particles.h", + "line": 15, + "column": 1, + "source_line": "const struct particle *particle_current(void);" + }, + "end": null, + "declaration_locations": [] + } + ], + "structs": [ + { + "reference": "struct particle" + } + ], + "unions": [], + "enums": [], + "typedefs": [ + { + "reference": "particle" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "particle_handle", + "name": "particle_handle", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "typedef struct particle *particle_handle", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "struct particle" + } + ] + }, + "source_location": { + "filename": "general/particles.h", + "line": 10, + "column": 1, + "source_line": "typedef struct particle *particle_handle;" + }, + "declaration_locations": [] + } + ], + "variables": [], + "macros": [ + { + "name": "X2PY_GENERAL_PARTICLES_H", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "general/particles.h", + "line": 2, + "column": 1, + "source_line": "#define X2PY_GENERAL_PARTICLES_H" + } + } + ], + "includes": [], + "raw_directives": [ + { + "directive": "ifndef", + "argument": "X2PY_GENERAL_PARTICLES_H", + "source_location": { + "filename": "general/particles.h", + "line": 1, + "column": 1, + "source_line": "#ifndef X2PY_GENERAL_PARTICLES_H" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "general/particles.h", + "line": 17, + "column": 1, + "source_line": "#endif" + } + } + ], + "macro_dependencies": [], + "diagnostics": [] + } + }, + "functions": { + "particle_touch": { + "name": "particle_touch", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "struct particle *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "struct particle" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "struct particle *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "struct particle" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "general/particles.c", + "line": 5, + "column": 1, + "source_line": "void particle_touch(struct particle *p)" + }, + "start": { + "filename": "general/particles.c", + "line": 5, + "column": 1, + "source_line": "void particle_touch(struct particle *p)" + }, + "end": { + "filename": "general/particles.c", + "line": 10, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "general/particles.h", + "line": 12, + "column": 1, + "source_line": "void particle_touch(struct particle *p);" + } + ] + }, + "particle_reset": { + "name": "particle_reset", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "particle *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "particle" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "particle *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "particle" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "general/particles.c", + "line": 12, + "column": 1, + "source_line": "void particle_reset(particle *p)" + }, + "start": { + "filename": "general/particles.c", + "line": 12, + "column": 1, + "source_line": "void particle_reset(particle *p)" + }, + "end": { + "filename": "general/particles.c", + "line": 20, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "general/particles.h", + "line": 13, + "column": 1, + "source_line": "void particle_reset(particle *p);" + } + ] + }, + "particle_move": { + "name": "particle_move", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "particle *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "particle" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "particle *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "particle" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "delta", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const double delta[static 3]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CDouble", + "qualifiers": [ + "const" + ], + "source_text": "const double" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const double delta[static 3]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "3", + "is_static_minimum": true, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CDouble", + "qualifiers": [ + "const" + ], + "source_text": "const double" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "general/particles.c", + "line": 22, + "column": 1, + "source_line": "void particle_move(particle *p, const double delta[static 3])" + }, + "start": { + "filename": "general/particles.c", + "line": 22, + "column": 1, + "source_line": "void particle_move(particle *p, const double delta[static 3])" + }, + "end": { + "filename": "general/particles.c", + "line": 29, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "general/particles.h", + "line": 14, + "column": 1, + "source_line": "void particle_move(particle *p, const double delta[static 3]);" + } + ] + }, + "particle_current": { + "name": "particle_current", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const struct particle", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "struct particle" + } + ] + }, + "parameters": [], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "general/particles.c", + "line": 31, + "column": 1, + "source_line": "const struct particle *particle_current(void)" + }, + "start": { + "filename": "general/particles.c", + "line": 31, + "column": 1, + "source_line": "const struct particle *particle_current(void)" + }, + "end": { + "filename": "general/particles.c", + "line": 34, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "general/particles.h", + "line": 15, + "column": 1, + "source_line": "const struct particle *particle_current(void);" + } + ] + } + }, + "structs": { + "particle": { + "reference": "struct particle" + } + }, + "unions": {}, + "enums": {}, + "typedefs": { + "particle": { + "reference": "particle" + }, + "particle_handle": { + "reference": "particle_handle" + } + }, + "variables": { + "current_particle": { + "name": "current_particle", + "type": { + "reference": "struct particle" + }, + "storage": [ + "static" + ], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "general/particles.c", + "line": 3, + "column": 1, + "source_line": "static struct particle current_particle;" + }, + "callback_policy": null, + "declaration_locations": [] + } + }, + "macros": { + "X2PY_GENERAL_PARTICLES_H": { + "name": "X2PY_GENERAL_PARTICLES_H", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "general/particles.h", + "line": 2, + "column": 1, + "source_line": "#define X2PY_GENERAL_PARTICLES_H" + } + } + }, + "includes": { + "general/particles.c:particles.h": { + "target": "particles.h", + "kind": "local", + "resolved_path": "general/particles.h", + "source_location": { + "filename": "general/particles.c", + "line": 1, + "column": 1, + "source_line": "#include \"particles.h\"" + } + } + }, + "functions_by_file": { + "general/particles.c": [ + "particle_touch", + "particle_reset", + "particle_move", + "particle_current" + ], + "general/particles.h": [ + "particle_touch", + "particle_reset", + "particle_move", + "particle_current" + ] + }, + "enum_constants": {}, + "include_graph": { + "general/particles.c": [ + "general/particles.h" + ], + "general/particles.h": [] + }, + "system_includes": { + "general/particles.c": [], + "general/particles.h": [] + }, + "unresolved_includes": { + "general/particles.c": [], + "general/particles.h": [] + }, + "header_source_pairs": { + "general/particles.h": [ + "general/particles.c" + ] + }, + "diagnostics": [] +} diff --git a/tests/parser/c/fixtures/general/shape_exprs.json b/tests/parser/c/fixtures/general/shape_exprs.json new file mode 100644 index 000000000..1e9fedb78 --- /dev/null +++ b/tests/parser/c/fixtures/general/shape_exprs.json @@ -0,0 +1,1672 @@ +{ + "files": { + "general/shape_exprs.h": { + "filename": "general/shape_exprs.h", + "language": "c", + "parser_status": "partial", + "preprocessing": "raw", + "functions": [ + { + "name": "fill_grid", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int x[static 1][X2PY_EXPR_N1]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "X2PY_EXPR_N1", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int x[static 1][X2PY_EXPR_N1]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "1", + "is_static_minimum": true, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "X2PY_EXPR_N1", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": false, + "prototype_style": "prototype", + "source_location": { + "filename": "general/shape_exprs.h", + "line": 10, + "column": 1, + "source_line": "void fill_grid(int x[static 1][X2PY_EXPR_N1]);" + }, + "start": { + "filename": "general/shape_exprs.h", + "line": 10, + "column": 1, + "source_line": "void fill_grid(int x[static 1][X2PY_EXPR_N1]);" + }, + "end": null, + "declaration_locations": [] + }, + { + "name": "update_plane", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float x[static 1][n]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "n", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float x[static 1][n]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "1", + "is_static_minimum": true, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "n", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": false, + "prototype_style": "prototype", + "source_location": { + "filename": "general/shape_exprs.h", + "line": 11, + "column": 1, + "source_line": "void update_plane(int n, float x[static 1][n]);" + }, + "start": { + "filename": "general/shape_exprs.h", + "line": 11, + "column": 1, + "source_line": "void update_plane(int n, float x[static 1][n]);" + }, + "end": null, + "declaration_locations": [] + }, + { + "name": "use_expr", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int x[static X2PY_EXPR_N1]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int x[static X2PY_EXPR_N1]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "X2PY_EXPR_N1", + "is_static_minimum": true, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float y[static X2PY_EXPR_N0 * 2]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float y[static X2PY_EXPR_N0 * 2]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "X2PY_EXPR_N0 * 2", + "is_static_minimum": true, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": false, + "prototype_style": "prototype", + "source_location": { + "filename": "general/shape_exprs.h", + "line": 13, + "column": 1, + "source_line": "void use_expr(" + }, + "start": { + "filename": "general/shape_exprs.h", + "line": 13, + "column": 1, + "source_line": "void use_expr(" + }, + "end": null, + "declaration_locations": [] + }, + { + "name": "all_exprs", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "x1", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int x1[static X2PY_EXPR_A + X2PY_EXPR_B]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int x1[static X2PY_EXPR_A + X2PY_EXPR_B]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "X2PY_EXPR_A + X2PY_EXPR_B", + "is_static_minimum": true, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x2", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int x2[static X2PY_EXPR_A - X2PY_EXPR_B]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int x2[static X2PY_EXPR_A - X2PY_EXPR_B]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "X2PY_EXPR_A - X2PY_EXPR_B", + "is_static_minimum": true, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x3", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int x3[static X2PY_EXPR_B * X2PY_EXPR_C]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int x3[static X2PY_EXPR_B * X2PY_EXPR_C]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "X2PY_EXPR_B * X2PY_EXPR_C", + "is_static_minimum": true, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x4", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int x4[static X2PY_EXPR_A / X2PY_EXPR_C]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int x4[static X2PY_EXPR_A / X2PY_EXPR_C]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "X2PY_EXPR_A / X2PY_EXPR_C", + "is_static_minimum": true, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x5", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int x5[static 1 << X2PY_EXPR_B]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int x5[static 1 << X2PY_EXPR_B]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "1 << X2PY_EXPR_B", + "is_static_minimum": true, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x6", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int x6[static (X2PY_EXPR_A + X2PY_EXPR_B) * X2PY_EXPR_C - 1]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int x6[static (X2PY_EXPR_A + X2PY_EXPR_B) * X2PY_EXPR_C - 1]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "(X2PY_EXPR_A + X2PY_EXPR_B) * X2PY_EXPR_C - 1", + "is_static_minimum": true, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x7", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int x7[static -(-X2PY_EXPR_A + X2PY_EXPR_B)]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int x7[static -(-X2PY_EXPR_A + X2PY_EXPR_B)]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "-(-X2PY_EXPR_A + X2PY_EXPR_B)", + "is_static_minimum": true, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x8", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int x8[static (X2PY_EXPR_A + X2PY_EXPR_B) * (X2PY_EXPR_C + 1) - 1]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int x8[static (X2PY_EXPR_A + X2PY_EXPR_B) * (X2PY_EXPR_C + 1) - 1]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "(X2PY_EXPR_A + X2PY_EXPR_B) * (X2PY_EXPR_C + 1) - 1", + "is_static_minimum": true, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x9", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int x9[static (X2PY_EXPR_A - X2PY_EXPR_B) * (X2PY_EXPR_A - X2PY_EXPR_C)]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int x9[static (X2PY_EXPR_A - X2PY_EXPR_B) * (X2PY_EXPR_A - X2PY_EXPR_C)]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "(X2PY_EXPR_A - X2PY_EXPR_B) * (X2PY_EXPR_A - X2PY_EXPR_C)", + "is_static_minimum": true, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": false, + "prototype_style": "prototype", + "source_location": { + "filename": "general/shape_exprs.h", + "line": 18, + "column": 1, + "source_line": "void all_exprs(" + }, + "start": { + "filename": "general/shape_exprs.h", + "line": 18, + "column": 1, + "source_line": "void all_exprs(" + }, + "end": null, + "declaration_locations": [] + } + ], + "structs": [], + "unions": [], + "enums": [], + "typedefs": [], + "variables": [], + "macros": [ + { + "name": "X2PY_GENERAL_SHAPE_EXPRS_H", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "general/shape_exprs.h", + "line": 2, + "column": 1, + "source_line": "#define X2PY_GENERAL_SHAPE_EXPRS_H" + } + }, + { + "name": "X2PY_EXPR_N0", + "value": "4", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "general/shape_exprs.h", + "line": 4, + "column": 1, + "source_line": "#define X2PY_EXPR_N0 4" + } + }, + { + "name": "X2PY_EXPR_N1", + "value": "(X2PY_EXPR_N0 + 2)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "general/shape_exprs.h", + "line": 5, + "column": 1, + "source_line": "#define X2PY_EXPR_N1 (X2PY_EXPR_N0 + 2)" + } + }, + { + "name": "X2PY_EXPR_A", + "value": "8", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "general/shape_exprs.h", + "line": 6, + "column": 1, + "source_line": "#define X2PY_EXPR_A 8" + } + }, + { + "name": "X2PY_EXPR_B", + "value": "3", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "general/shape_exprs.h", + "line": 7, + "column": 1, + "source_line": "#define X2PY_EXPR_B 3" + } + }, + { + "name": "X2PY_EXPR_C", + "value": "2", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "general/shape_exprs.h", + "line": 8, + "column": 1, + "source_line": "#define X2PY_EXPR_C 2" + } + } + ], + "includes": [], + "raw_directives": [ + { + "directive": "ifndef", + "argument": "X2PY_GENERAL_SHAPE_EXPRS_H", + "source_location": { + "filename": "general/shape_exprs.h", + "line": 1, + "column": 1, + "source_line": "#ifndef X2PY_GENERAL_SHAPE_EXPRS_H" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "general/shape_exprs.h", + "line": 30, + "column": 1, + "source_line": "#endif" + } + } + ], + "macro_dependencies": [], + "diagnostics": [] + } + }, + "functions": { + "fill_grid": { + "name": "fill_grid", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int x[static 1][X2PY_EXPR_N1]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "X2PY_EXPR_N1", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int x[static 1][X2PY_EXPR_N1]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "1", + "is_static_minimum": true, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "X2PY_EXPR_N1", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": false, + "prototype_style": "prototype", + "source_location": { + "filename": "general/shape_exprs.h", + "line": 10, + "column": 1, + "source_line": "void fill_grid(int x[static 1][X2PY_EXPR_N1]);" + }, + "start": { + "filename": "general/shape_exprs.h", + "line": 10, + "column": 1, + "source_line": "void fill_grid(int x[static 1][X2PY_EXPR_N1]);" + }, + "end": null, + "declaration_locations": [] + }, + "update_plane": { + "name": "update_plane", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float x[static 1][n]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "n", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float x[static 1][n]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "1", + "is_static_minimum": true, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "n", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": false, + "prototype_style": "prototype", + "source_location": { + "filename": "general/shape_exprs.h", + "line": 11, + "column": 1, + "source_line": "void update_plane(int n, float x[static 1][n]);" + }, + "start": { + "filename": "general/shape_exprs.h", + "line": 11, + "column": 1, + "source_line": "void update_plane(int n, float x[static 1][n]);" + }, + "end": null, + "declaration_locations": [] + }, + "use_expr": { + "name": "use_expr", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int x[static X2PY_EXPR_N1]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int x[static X2PY_EXPR_N1]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "X2PY_EXPR_N1", + "is_static_minimum": true, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float y[static X2PY_EXPR_N0 * 2]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float y[static X2PY_EXPR_N0 * 2]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "X2PY_EXPR_N0 * 2", + "is_static_minimum": true, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": false, + "prototype_style": "prototype", + "source_location": { + "filename": "general/shape_exprs.h", + "line": 13, + "column": 1, + "source_line": "void use_expr(" + }, + "start": { + "filename": "general/shape_exprs.h", + "line": 13, + "column": 1, + "source_line": "void use_expr(" + }, + "end": null, + "declaration_locations": [] + }, + "all_exprs": { + "name": "all_exprs", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "x1", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int x1[static X2PY_EXPR_A + X2PY_EXPR_B]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int x1[static X2PY_EXPR_A + X2PY_EXPR_B]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "X2PY_EXPR_A + X2PY_EXPR_B", + "is_static_minimum": true, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x2", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int x2[static X2PY_EXPR_A - X2PY_EXPR_B]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int x2[static X2PY_EXPR_A - X2PY_EXPR_B]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "X2PY_EXPR_A - X2PY_EXPR_B", + "is_static_minimum": true, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x3", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int x3[static X2PY_EXPR_B * X2PY_EXPR_C]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int x3[static X2PY_EXPR_B * X2PY_EXPR_C]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "X2PY_EXPR_B * X2PY_EXPR_C", + "is_static_minimum": true, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x4", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int x4[static X2PY_EXPR_A / X2PY_EXPR_C]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int x4[static X2PY_EXPR_A / X2PY_EXPR_C]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "X2PY_EXPR_A / X2PY_EXPR_C", + "is_static_minimum": true, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x5", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int x5[static 1 << X2PY_EXPR_B]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int x5[static 1 << X2PY_EXPR_B]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "1 << X2PY_EXPR_B", + "is_static_minimum": true, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x6", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int x6[static (X2PY_EXPR_A + X2PY_EXPR_B) * X2PY_EXPR_C - 1]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int x6[static (X2PY_EXPR_A + X2PY_EXPR_B) * X2PY_EXPR_C - 1]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "(X2PY_EXPR_A + X2PY_EXPR_B) * X2PY_EXPR_C - 1", + "is_static_minimum": true, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x7", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int x7[static -(-X2PY_EXPR_A + X2PY_EXPR_B)]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int x7[static -(-X2PY_EXPR_A + X2PY_EXPR_B)]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "-(-X2PY_EXPR_A + X2PY_EXPR_B)", + "is_static_minimum": true, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x8", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int x8[static (X2PY_EXPR_A + X2PY_EXPR_B) * (X2PY_EXPR_C + 1) - 1]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int x8[static (X2PY_EXPR_A + X2PY_EXPR_B) * (X2PY_EXPR_C + 1) - 1]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "(X2PY_EXPR_A + X2PY_EXPR_B) * (X2PY_EXPR_C + 1) - 1", + "is_static_minimum": true, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x9", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int x9[static (X2PY_EXPR_A - X2PY_EXPR_B) * (X2PY_EXPR_A - X2PY_EXPR_C)]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int x9[static (X2PY_EXPR_A - X2PY_EXPR_B) * (X2PY_EXPR_A - X2PY_EXPR_C)]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "(X2PY_EXPR_A - X2PY_EXPR_B) * (X2PY_EXPR_A - X2PY_EXPR_C)", + "is_static_minimum": true, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": false, + "prototype_style": "prototype", + "source_location": { + "filename": "general/shape_exprs.h", + "line": 18, + "column": 1, + "source_line": "void all_exprs(" + }, + "start": { + "filename": "general/shape_exprs.h", + "line": 18, + "column": 1, + "source_line": "void all_exprs(" + }, + "end": null, + "declaration_locations": [] + } + }, + "structs": {}, + "unions": {}, + "enums": {}, + "typedefs": {}, + "variables": {}, + "macros": { + "X2PY_GENERAL_SHAPE_EXPRS_H": { + "name": "X2PY_GENERAL_SHAPE_EXPRS_H", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "general/shape_exprs.h", + "line": 2, + "column": 1, + "source_line": "#define X2PY_GENERAL_SHAPE_EXPRS_H" + } + }, + "X2PY_EXPR_N0": { + "name": "X2PY_EXPR_N0", + "value": "4", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "general/shape_exprs.h", + "line": 4, + "column": 1, + "source_line": "#define X2PY_EXPR_N0 4" + } + }, + "X2PY_EXPR_N1": { + "name": "X2PY_EXPR_N1", + "value": "(X2PY_EXPR_N0 + 2)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "general/shape_exprs.h", + "line": 5, + "column": 1, + "source_line": "#define X2PY_EXPR_N1 (X2PY_EXPR_N0 + 2)" + } + }, + "X2PY_EXPR_A": { + "name": "X2PY_EXPR_A", + "value": "8", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "general/shape_exprs.h", + "line": 6, + "column": 1, + "source_line": "#define X2PY_EXPR_A 8" + } + }, + "X2PY_EXPR_B": { + "name": "X2PY_EXPR_B", + "value": "3", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "general/shape_exprs.h", + "line": 7, + "column": 1, + "source_line": "#define X2PY_EXPR_B 3" + } + }, + "X2PY_EXPR_C": { + "name": "X2PY_EXPR_C", + "value": "2", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "general/shape_exprs.h", + "line": 8, + "column": 1, + "source_line": "#define X2PY_EXPR_C 2" + } + } + }, + "includes": {}, + "functions_by_file": { + "general/shape_exprs.h": [ + "fill_grid", + "update_plane", + "use_expr", + "all_exprs" + ] + }, + "enum_constants": {}, + "include_graph": { + "general/shape_exprs.h": [] + }, + "system_includes": { + "general/shape_exprs.h": [] + }, + "unresolved_includes": { + "general/shape_exprs.h": [] + }, + "header_source_pairs": { + "general/shape_exprs.h": [] + }, + "diagnostics": [] +} diff --git a/tests/parser/c/fixtures/json/cJSON.json b/tests/parser/c/fixtures/json/cJSON.json new file mode 100644 index 000000000..1e8635c8f --- /dev/null +++ b/tests/parser/c/fixtures/json/cJSON.json @@ -0,0 +1,13461 @@ +{ + "files": { + "json/cJSON.c": { + "filename": "json/cJSON.c", + "language": "c", + "parser_status": "partial", + "preprocessing": "raw", + "functions": [ + { + "name": "case_insensitive_strcmp", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "string1", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const unsigned char *string1", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [ + "const" + ], + "source_text": "const unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const unsigned char *string1", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [ + "const" + ], + "source_text": "const unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "string2", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const unsigned char *string2", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [ + "const" + ], + "source_text": "const unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const unsigned char *string2", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [ + "const" + ], + "source_text": "const unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "json/cJSON.c", + "line": 133, + "column": 1, + "source_line": "static int case_insensitive_strcmp(const unsigned char *string1, const unsigned char *string2)" + }, + "start": { + "filename": "json/cJSON.c", + "line": 133, + "column": 1, + "source_line": "static int case_insensitive_strcmp(const unsigned char *string1, const unsigned char *string2)" + }, + "end": { + "filename": "json/cJSON.c", + "line": 154, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "cJSON_strdup", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "parameters": [ + { + "name": "string", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const unsigned char * string", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [ + "const" + ], + "source_text": "const unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const unsigned char * string", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [ + "const" + ], + "source_text": "const unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "hooks", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const internal_hooks * const hooks", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "internal_hooks", + "name": "internal_hooks", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": "internal_hooks", + "members": [], + "anonymous_id": null, + "is_incomplete": false, + "source_location": { + "filename": "json/cJSON.c", + "line": 156, + "column": 1, + "source_line": "typedef struct internal_hooks" + } + }, + "source_location": { + "filename": "json/cJSON.c", + "line": 156, + "column": 1, + "source_line": "typedef struct internal_hooks" + }, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const internal_hooks * const hooks", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "internal_hooks" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "json/cJSON.c", + "line": 188, + "column": 1, + "source_line": "static unsigned char* cJSON_strdup(const unsigned char* string, const internal_hooks * const hooks)" + }, + "start": { + "filename": "json/cJSON.c", + "line": 188, + "column": 1, + "source_line": "static unsigned char* cJSON_strdup(const unsigned char* string, const internal_hooks * const hooks)" + }, + "end": { + "filename": "json/cJSON.c", + "line": 207, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "cJSON_New_Item", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "cJSON", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "cJSON", + "name": "cJSON", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "parameters": [ + { + "name": "hooks", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const internal_hooks * const hooks", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "internal_hooks" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const internal_hooks * const hooks", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "internal_hooks" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "json/cJSON.c", + "line": 241, + "column": 1, + "source_line": "static cJSON *cJSON_New_Item(const internal_hooks * const hooks)" + }, + "start": { + "filename": "json/cJSON.c", + "line": 241, + "column": 1, + "source_line": "static cJSON *cJSON_New_Item(const internal_hooks * const hooks)" + }, + "end": { + "filename": "json/cJSON.c", + "line": 250, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "get_decimal_point", + "result_type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + }, + "parameters": [], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "json/cJSON.c", + "line": 279, + "column": 1, + "source_line": "static unsigned char get_decimal_point(void)" + }, + "start": { + "filename": "json/cJSON.c", + "line": 279, + "column": 1, + "source_line": "static unsigned char get_decimal_point(void)" + }, + "end": { + "filename": "json/cJSON.c", + "line": 287, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "parse_number", + "result_type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "cJSON_bool", + "name": "cJSON_bool", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "parameters": [ + { + "name": "item", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "cJSON * const item", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "cJSON", + "name": "cJSON", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "cJSON * const item", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "input_buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "parse_buffer * const input_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "parse_buffer", + "name": "parse_buffer", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "content", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const unsigned char *content", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [ + "const" + ], + "source_text": "const unsigned char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "json/cJSON.c", + "line": 291, + "column": 5, + "source_line": " const unsigned char *content;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "length", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t length", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "json/cJSON.c", + "line": 292, + "column": 5, + "source_line": " size_t length;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "offset", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t offset", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "json/cJSON.c", + "line": 293, + "column": 5, + "source_line": " size_t offset;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "depth", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t depth", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "json/cJSON.c", + "line": 294, + "column": 5, + "source_line": " size_t depth; /* How deeply nested (in arrays/objects) is the input at the current offset. */" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "hooks", + "type": { + "reference": "internal_hooks" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "json/cJSON.c", + "line": 295, + "column": 5, + "source_line": " internal_hooks hooks;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@json/cJSON.c:289:1", + "is_incomplete": false, + "source_location": { + "filename": "json/cJSON.c", + "line": 289, + "column": 1, + "source_line": "typedef struct" + } + }, + "source_location": { + "filename": "json/cJSON.c", + "line": 289, + "column": 1, + "source_line": "typedef struct" + }, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "parse_buffer * const input_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "parse_buffer" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "json/cJSON.c", + "line": 307, + "column": 1, + "source_line": "static cJSON_bool parse_number(cJSON * const item, parse_buffer * const input_buffer)" + }, + "start": { + "filename": "json/cJSON.c", + "line": 307, + "column": 1, + "source_line": "static cJSON_bool parse_number(cJSON * const item, parse_buffer * const input_buffer)" + }, + "end": { + "filename": "json/cJSON.c", + "line": 408, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "ensure", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "printbuffer * const p", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "printbuffer", + "name": "printbuffer", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "json/cJSON.c", + "line": 480, + "column": 5, + "source_line": " unsigned char *buffer;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "length", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t length", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "json/cJSON.c", + "line": 481, + "column": 5, + "source_line": " size_t length;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "offset", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t offset", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "json/cJSON.c", + "line": 482, + "column": 5, + "source_line": " size_t offset;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "depth", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t depth", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "json/cJSON.c", + "line": 483, + "column": 5, + "source_line": " size_t depth; /* current nesting depth (for formatted printing) */" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "noalloc", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "cJSON_bool noalloc", + "name": "cJSON_bool", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "json/cJSON.c", + "line": 484, + "column": 5, + "source_line": " cJSON_bool noalloc;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "format", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "cJSON_bool format", + "name": "cJSON_bool", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "json/cJSON.c", + "line": 485, + "column": 5, + "source_line": " cJSON_bool format; /* is this print a formatted print */" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "hooks", + "type": { + "reference": "internal_hooks" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "json/cJSON.c", + "line": 486, + "column": 5, + "source_line": " internal_hooks hooks;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@json/cJSON.c:478:1", + "is_incomplete": false, + "source_location": { + "filename": "json/cJSON.c", + "line": 478, + "column": 1, + "source_line": "typedef struct" + } + }, + "source_location": { + "filename": "json/cJSON.c", + "line": 478, + "column": 1, + "source_line": "typedef struct" + }, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "printbuffer * const p", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "printbuffer" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "needed", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t needed", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "json/cJSON.c", + "line": 490, + "column": 1, + "source_line": "static unsigned char* ensure(printbuffer * const p, size_t needed)" + }, + "start": { + "filename": "json/cJSON.c", + "line": 490, + "column": 1, + "source_line": "static unsigned char* ensure(printbuffer * const p, size_t needed)" + }, + "end": { + "filename": "json/cJSON.c", + "line": 573, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "update_offset", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "printbuffer * const buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "printbuffer" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "printbuffer * const buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "printbuffer" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "json/cJSON.c", + "line": 576, + "column": 1, + "source_line": "static void update_offset(printbuffer * const buffer)" + }, + "start": { + "filename": "json/cJSON.c", + "line": 576, + "column": 1, + "source_line": "static void update_offset(printbuffer * const buffer)" + }, + "end": { + "filename": "json/cJSON.c", + "line": 586, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "compare_double", + "result_type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "cJSON_bool", + "name": "cJSON_bool", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double a" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double a" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double b" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double b" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "json/cJSON.c", + "line": 589, + "column": 1, + "source_line": "static cJSON_bool compare_double(double a, double b)" + }, + "start": { + "filename": "json/cJSON.c", + "line": 589, + "column": 1, + "source_line": "static cJSON_bool compare_double(double a, double b)" + }, + "end": { + "filename": "json/cJSON.c", + "line": 593, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "print_number", + "result_type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "cJSON_bool", + "name": "cJSON_bool", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "parameters": [ + { + "name": "item", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const cJSON * const item", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [ + "const" + ], + "source_text": "const cJSON", + "name": "cJSON", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const cJSON * const item", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "output_buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "printbuffer * const output_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "printbuffer" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "printbuffer * const output_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "printbuffer" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "json/cJSON.c", + "line": 596, + "column": 1, + "source_line": "static cJSON_bool print_number(const cJSON * const item, printbuffer * const output_buffer)" + }, + "start": { + "filename": "json/cJSON.c", + "line": 596, + "column": 1, + "source_line": "static cJSON_bool print_number(const cJSON * const item, printbuffer * const output_buffer)" + }, + "end": { + "filename": "json/cJSON.c", + "line": 663, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "parse_hex4", + "result_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned" + }, + "parameters": [ + { + "name": "input", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const unsigned char * const input", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [ + "const" + ], + "source_text": "const unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const unsigned char * const input", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [ + "const" + ], + "source_text": "const unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "json/cJSON.c", + "line": 666, + "column": 1, + "source_line": "static unsigned parse_hex4(const unsigned char * const input)" + }, + "start": { + "filename": "json/cJSON.c", + "line": 666, + "column": 1, + "source_line": "static unsigned parse_hex4(const unsigned char * const input)" + }, + "end": { + "filename": "json/cJSON.c", + "line": 699, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "utf16_literal_to_utf8", + "result_type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + }, + "parameters": [ + { + "name": "input_pointer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const unsigned char * const input_pointer", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [ + "const" + ], + "source_text": "const unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const unsigned char * const input_pointer", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [ + "const" + ], + "source_text": "const unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "input_end", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const unsigned char * const input_end", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [ + "const" + ], + "source_text": "const unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const unsigned char * const input_end", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [ + "const" + ], + "source_text": "const unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "output_pointer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char **output_pointer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char **output_pointer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "json/cJSON.c", + "line": 703, + "column": 1, + "source_line": "static unsigned char utf16_literal_to_utf8(const unsigned char * const input_pointer, const unsigned char * const input_end, unsigned char **output_pointer)" + }, + "start": { + "filename": "json/cJSON.c", + "line": 703, + "column": 1, + "source_line": "static unsigned char utf16_literal_to_utf8(const unsigned char * const input_pointer, const unsigned char * const input_end, unsigned char **output_pointer)" + }, + "end": { + "filename": "json/cJSON.c", + "line": 821, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "parse_string", + "result_type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "cJSON_bool", + "name": "cJSON_bool", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "parameters": [ + { + "name": "item", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "cJSON * const item", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "cJSON", + "name": "cJSON", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "cJSON * const item", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "input_buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "parse_buffer * const input_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "parse_buffer" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "parse_buffer * const input_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "parse_buffer" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "json/cJSON.c", + "line": 824, + "column": 1, + "source_line": "static cJSON_bool parse_string(cJSON * const item, parse_buffer * const input_buffer)" + }, + "start": { + "filename": "json/cJSON.c", + "line": 824, + "column": 1, + "source_line": "static cJSON_bool parse_string(cJSON * const item, parse_buffer * const input_buffer)" + }, + "end": { + "filename": "json/cJSON.c", + "line": 951, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "print_string_ptr", + "result_type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "cJSON_bool", + "name": "cJSON_bool", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "parameters": [ + { + "name": "input", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const unsigned char * const input", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [ + "const" + ], + "source_text": "const unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const unsigned char * const input", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [ + "const" + ], + "source_text": "const unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "output_buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "printbuffer * const output_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "printbuffer" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "printbuffer * const output_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "printbuffer" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "json/cJSON.c", + "line": 954, + "column": 1, + "source_line": "static cJSON_bool print_string_ptr(const unsigned char * const input, printbuffer * const output_buffer)" + }, + "start": { + "filename": "json/cJSON.c", + "line": 954, + "column": 1, + "source_line": "static cJSON_bool print_string_ptr(const unsigned char * const input, printbuffer * const output_buffer)" + }, + "end": { + "filename": "json/cJSON.c", + "line": 1073, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "print_string", + "result_type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "cJSON_bool", + "name": "cJSON_bool", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "parameters": [ + { + "name": "item", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const cJSON * const item", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [ + "const" + ], + "source_text": "const cJSON", + "name": "cJSON", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const cJSON * const item", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "printbuffer * const p", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "printbuffer" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "printbuffer * const p", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "printbuffer" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "json/cJSON.c", + "line": 1076, + "column": 1, + "source_line": "static cJSON_bool print_string(const cJSON * const item, printbuffer * const p)" + }, + "start": { + "filename": "json/cJSON.c", + "line": 1076, + "column": 1, + "source_line": "static cJSON_bool print_string(const cJSON * const item, printbuffer * const p)" + }, + "end": { + "filename": "json/cJSON.c", + "line": 1079, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "parse_value", + "result_type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "cJSON_bool", + "name": "cJSON_bool", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "parameters": [ + { + "name": "item", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "cJSON * const item", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "cJSON", + "name": "cJSON", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "cJSON * const item", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "input_buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "parse_buffer * const input_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "parse_buffer" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "parse_buffer * const input_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "parse_buffer" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "json/cJSON.c", + "line": 1368, + "column": 1, + "source_line": "static cJSON_bool parse_value(cJSON * const item, parse_buffer * const input_buffer)" + }, + "start": { + "filename": "json/cJSON.c", + "line": 1368, + "column": 1, + "source_line": "static cJSON_bool parse_value(cJSON * const item, parse_buffer * const input_buffer)" + }, + "end": { + "filename": "json/cJSON.c", + "line": 1420, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "json/cJSON.c", + "line": 1082, + "column": 1, + "source_line": "static cJSON_bool parse_value(cJSON * const item, parse_buffer * const input_buffer);" + } + ] + }, + { + "name": "print_value", + "result_type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "cJSON_bool", + "name": "cJSON_bool", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "parameters": [ + { + "name": "item", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const cJSON * const item", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [ + "const" + ], + "source_text": "const cJSON", + "name": "cJSON", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const cJSON * const item", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "output_buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "printbuffer * const output_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "printbuffer" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "printbuffer * const output_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "printbuffer" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "json/cJSON.c", + "line": 1423, + "column": 1, + "source_line": "static cJSON_bool print_value(const cJSON * const item, printbuffer * const output_buffer)" + }, + "start": { + "filename": "json/cJSON.c", + "line": 1423, + "column": 1, + "source_line": "static cJSON_bool print_value(const cJSON * const item, printbuffer * const output_buffer)" + }, + "end": { + "filename": "json/cJSON.c", + "line": 1494, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "json/cJSON.c", + "line": 1083, + "column": 1, + "source_line": "static cJSON_bool print_value(const cJSON * const item, printbuffer * const output_buffer);" + } + ] + }, + { + "name": "parse_array", + "result_type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "cJSON_bool", + "name": "cJSON_bool", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "parameters": [ + { + "name": "item", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "cJSON * const item", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "cJSON", + "name": "cJSON", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "cJSON * const item", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "input_buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "parse_buffer * const input_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "parse_buffer" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "parse_buffer * const input_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "parse_buffer" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "json/cJSON.c", + "line": 1497, + "column": 1, + "source_line": "static cJSON_bool parse_array(cJSON * const item, parse_buffer * const input_buffer)" + }, + "start": { + "filename": "json/cJSON.c", + "line": 1497, + "column": 1, + "source_line": "static cJSON_bool parse_array(cJSON * const item, parse_buffer * const input_buffer)" + }, + "end": { + "filename": "json/cJSON.c", + "line": 1592, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "json/cJSON.c", + "line": 1084, + "column": 1, + "source_line": "static cJSON_bool parse_array(cJSON * const item, parse_buffer * const input_buffer);" + } + ] + }, + { + "name": "print_array", + "result_type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "cJSON_bool", + "name": "cJSON_bool", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "parameters": [ + { + "name": "item", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const cJSON * const item", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [ + "const" + ], + "source_text": "const cJSON", + "name": "cJSON", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const cJSON * const item", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "output_buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "printbuffer * const output_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "printbuffer" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "printbuffer * const output_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "printbuffer" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "json/cJSON.c", + "line": 1595, + "column": 1, + "source_line": "static cJSON_bool print_array(const cJSON * const item, printbuffer * const output_buffer)" + }, + "start": { + "filename": "json/cJSON.c", + "line": 1595, + "column": 1, + "source_line": "static cJSON_bool print_array(const cJSON * const item, printbuffer * const output_buffer)" + }, + "end": { + "filename": "json/cJSON.c", + "line": 1659, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "json/cJSON.c", + "line": 1085, + "column": 1, + "source_line": "static cJSON_bool print_array(const cJSON * const item, printbuffer * const output_buffer);" + } + ] + }, + { + "name": "parse_object", + "result_type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "cJSON_bool", + "name": "cJSON_bool", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "parameters": [ + { + "name": "item", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "cJSON * const item", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "cJSON", + "name": "cJSON", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "cJSON * const item", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "input_buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "parse_buffer * const input_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "parse_buffer" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "parse_buffer * const input_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "parse_buffer" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "json/cJSON.c", + "line": 1662, + "column": 1, + "source_line": "static cJSON_bool parse_object(cJSON * const item, parse_buffer * const input_buffer)" + }, + "start": { + "filename": "json/cJSON.c", + "line": 1662, + "column": 1, + "source_line": "static cJSON_bool parse_object(cJSON * const item, parse_buffer * const input_buffer)" + }, + "end": { + "filename": "json/cJSON.c", + "line": 1777, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "json/cJSON.c", + "line": 1086, + "column": 1, + "source_line": "static cJSON_bool parse_object(cJSON * const item, parse_buffer * const input_buffer);" + } + ] + }, + { + "name": "print_object", + "result_type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "cJSON_bool", + "name": "cJSON_bool", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "parameters": [ + { + "name": "item", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const cJSON * const item", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [ + "const" + ], + "source_text": "const cJSON", + "name": "cJSON", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const cJSON * const item", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "output_buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "printbuffer * const output_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "printbuffer" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "printbuffer * const output_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "printbuffer" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "json/cJSON.c", + "line": 1780, + "column": 1, + "source_line": "static cJSON_bool print_object(const cJSON * const item, printbuffer * const output_buffer)" + }, + "start": { + "filename": "json/cJSON.c", + "line": 1780, + "column": 1, + "source_line": "static cJSON_bool print_object(const cJSON * const item, printbuffer * const output_buffer)" + }, + "end": { + "filename": "json/cJSON.c", + "line": 1896, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "json/cJSON.c", + "line": 1087, + "column": 1, + "source_line": "static cJSON_bool print_object(const cJSON * const item, printbuffer * const output_buffer);" + } + ] + }, + { + "name": "buffer_skip_whitespace", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "parse_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "parse_buffer" + } + ] + }, + "parameters": [ + { + "name": "buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "parse_buffer * const buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "parse_buffer" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "parse_buffer * const buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "parse_buffer" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "json/cJSON.c", + "line": 1090, + "column": 1, + "source_line": "static parse_buffer *buffer_skip_whitespace(parse_buffer * const buffer)" + }, + "start": { + "filename": "json/cJSON.c", + "line": 1090, + "column": 1, + "source_line": "static parse_buffer *buffer_skip_whitespace(parse_buffer * const buffer)" + }, + "end": { + "filename": "json/cJSON.c", + "line": 1113, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "skip_utf8_bom", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "parse_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "parse_buffer" + } + ] + }, + "parameters": [ + { + "name": "buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "parse_buffer * const buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "parse_buffer" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "parse_buffer * const buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "parse_buffer" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "json/cJSON.c", + "line": 1116, + "column": 1, + "source_line": "static parse_buffer *skip_utf8_bom(parse_buffer * const buffer)" + }, + "start": { + "filename": "json/cJSON.c", + "line": 1116, + "column": 1, + "source_line": "static parse_buffer *skip_utf8_bom(parse_buffer * const buffer)" + }, + "end": { + "filename": "json/cJSON.c", + "line": 1129, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "print", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "parameters": [ + { + "name": "item", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const cJSON * const item", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [ + "const" + ], + "source_text": "const cJSON", + "name": "cJSON", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const cJSON * const item", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "format", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "cJSON_bool format", + "name": "cJSON_bool", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "declared_type": { + "reference": "cJSON_bool" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "hooks", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const internal_hooks * const hooks", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "internal_hooks" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const internal_hooks * const hooks", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "internal_hooks" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "json/cJSON.c", + "line": 1239, + "column": 1, + "source_line": "static unsigned char *print(const cJSON * const item, cJSON_bool format, const internal_hooks * const hooks)" + }, + "start": { + "filename": "json/cJSON.c", + "line": 1239, + "column": 1, + "source_line": "static unsigned char *print(const cJSON * const item, cJSON_bool format, const internal_hooks * const hooks)" + }, + "end": { + "filename": "json/cJSON.c", + "line": 1304, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "get_array_item", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "cJSON", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "cJSON", + "name": "cJSON", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "parameters": [ + { + "name": "array", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const cJSON *array", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [ + "const" + ], + "source_text": "const cJSON", + "name": "cJSON", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const cJSON *array", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "index", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t index", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "json/cJSON.c", + "line": 1922, + "column": 1, + "source_line": "static cJSON* get_array_item(const cJSON *array, size_t index)" + }, + "start": { + "filename": "json/cJSON.c", + "line": 1922, + "column": 1, + "source_line": "static cJSON* get_array_item(const cJSON *array, size_t index)" + }, + "end": { + "filename": "json/cJSON.c", + "line": 1939, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "get_object_item", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "cJSON", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "cJSON", + "name": "cJSON", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "parameters": [ + { + "name": "object", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const cJSON * const object", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [ + "const" + ], + "source_text": "const cJSON", + "name": "cJSON", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const cJSON * const object", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "name", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * const name", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * const name", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "case_sensitive", + "type": { + "model": "CTypedef", + "qualifiers": [ + "const" + ], + "source_text": "const cJSON_bool case_sensitive", + "name": "cJSON_bool", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "declared_type": { + "reference": "cJSON_bool" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "json/cJSON.c", + "line": 1951, + "column": 1, + "source_line": "static cJSON *get_object_item(const cJSON * const object, const char * const name, const cJSON_bool case_sensitive)" + }, + "start": { + "filename": "json/cJSON.c", + "line": 1951, + "column": 1, + "source_line": "static cJSON *get_object_item(const cJSON * const object, const char * const name, const cJSON_bool case_sensitive)" + }, + "end": { + "filename": "json/cJSON.c", + "line": 1981, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "suffix_object", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "prev", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "cJSON *prev", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "cJSON", + "name": "cJSON", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "cJSON *prev", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "item", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "cJSON *item", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "cJSON", + "name": "cJSON", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "cJSON *item", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "json/cJSON.c", + "line": 1999, + "column": 1, + "source_line": "static void suffix_object(cJSON *prev, cJSON *item)" + }, + "start": { + "filename": "json/cJSON.c", + "line": 1999, + "column": 1, + "source_line": "static void suffix_object(cJSON *prev, cJSON *item)" + }, + "end": { + "filename": "json/cJSON.c", + "line": 2003, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "create_reference", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "cJSON", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "cJSON", + "name": "cJSON", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "parameters": [ + { + "name": "item", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const cJSON *item", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [ + "const" + ], + "source_text": "const cJSON", + "name": "cJSON", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const cJSON *item", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "hooks", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const internal_hooks * const hooks", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "internal_hooks" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const internal_hooks * const hooks", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "internal_hooks" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "json/cJSON.c", + "line": 2006, + "column": 1, + "source_line": "static cJSON *create_reference(const cJSON *item, const internal_hooks * const hooks)" + }, + "start": { + "filename": "json/cJSON.c", + "line": 2006, + "column": 1, + "source_line": "static cJSON *create_reference(const cJSON *item, const internal_hooks * const hooks)" + }, + "end": { + "filename": "json/cJSON.c", + "line": 2025, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "add_item_to_array", + "result_type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "cJSON_bool", + "name": "cJSON_bool", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "parameters": [ + { + "name": "array", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "cJSON *array", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "cJSON", + "name": "cJSON", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "cJSON *array", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "item", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "cJSON *item", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "cJSON", + "name": "cJSON", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "cJSON *item", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "json/cJSON.c", + "line": 2027, + "column": 1, + "source_line": "static cJSON_bool add_item_to_array(cJSON *array, cJSON *item)" + }, + "start": { + "filename": "json/cJSON.c", + "line": 2027, + "column": 1, + "source_line": "static cJSON_bool add_item_to_array(cJSON *array, cJSON *item)" + }, + "end": { + "filename": "json/cJSON.c", + "line": 2058, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "cast_away_const", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "parameters": [ + { + "name": "string", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const void * string", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [ + "const" + ], + "source_text": "const void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const void * string", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [ + "const" + ], + "source_text": "const void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "json/cJSON.c", + "line": 2073, + "column": 1, + "source_line": "static void* cast_away_const(const void* string)" + }, + "start": { + "filename": "json/cJSON.c", + "line": 2073, + "column": 1, + "source_line": "static void* cast_away_const(const void* string)" + }, + "end": { + "filename": "json/cJSON.c", + "line": 2076, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "add_item_to_object", + "result_type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "cJSON_bool", + "name": "cJSON_bool", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "parameters": [ + { + "name": "object", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "cJSON * const object", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "cJSON", + "name": "cJSON", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "cJSON * const object", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "string", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * const string", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * const string", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "item", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "cJSON * const item", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "cJSON", + "name": "cJSON", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "cJSON * const item", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "hooks", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const internal_hooks * const hooks", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "internal_hooks" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const internal_hooks * const hooks", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "internal_hooks" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "constant_key", + "type": { + "model": "CTypedef", + "qualifiers": [ + "const" + ], + "source_text": "const cJSON_bool constant_key", + "name": "cJSON_bool", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "declared_type": { + "reference": "cJSON_bool" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "json/cJSON.c", + "line": 2082, + "column": 1, + "source_line": "static cJSON_bool add_item_to_object(cJSON * const object, const char * const string, cJSON * const item, const internal_hooks * const hooks, const cJSON_bool constant_key)" + }, + "start": { + "filename": "json/cJSON.c", + "line": 2082, + "column": 1, + "source_line": "static cJSON_bool add_item_to_object(cJSON * const object, const char * const string, cJSON * const item, const internal_hooks * const hooks, const cJSON_bool constant_key)" + }, + "end": { + "filename": "json/cJSON.c", + "line": 2117, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "replace_item_in_object", + "result_type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "cJSON_bool", + "name": "cJSON_bool", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "parameters": [ + { + "name": "object", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "cJSON *object", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "cJSON", + "name": "cJSON", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "cJSON *object", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "string", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *string", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *string", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "replacement", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "cJSON *replacement", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "cJSON", + "name": "cJSON", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "cJSON *replacement", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "case_sensitive", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "cJSON_bool case_sensitive", + "name": "cJSON_bool", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "declared_type": { + "reference": "cJSON_bool" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "json/cJSON.c", + "line": 2427, + "column": 1, + "source_line": "static cJSON_bool replace_item_in_object(cJSON *object, const char *string, cJSON *replacement, cJSON_bool case_sensitive)" + }, + "start": { + "filename": "json/cJSON.c", + "line": 2427, + "column": 1, + "source_line": "static cJSON_bool replace_item_in_object(cJSON *object, const char *string, cJSON *replacement, cJSON_bool case_sensitive)" + }, + "end": { + "filename": "json/cJSON.c", + "line": 2448, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "cJSON_Duplicate_rec", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "cJSON", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "cJSON", + "name": "cJSON", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "parameters": [ + { + "name": "item", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const cJSON *item", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [ + "const" + ], + "source_text": "const cJSON", + "name": "cJSON", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const cJSON *item", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "depth", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t depth", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "recurse", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "cJSON_bool recurse", + "name": "cJSON_bool", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "declared_type": { + "reference": "cJSON_bool" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "json/cJSON.c", + "line": 2789, + "column": 1, + "source_line": "cJSON * cJSON_Duplicate_rec(const cJSON *item, size_t depth, cJSON_bool recurse)" + }, + "start": { + "filename": "json/cJSON.c", + "line": 2789, + "column": 1, + "source_line": "cJSON * cJSON_Duplicate_rec(const cJSON *item, size_t depth, cJSON_bool recurse)" + }, + "end": { + "filename": "json/cJSON.c", + "line": 2873, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "json/cJSON.c", + "line": 2782, + "column": 1, + "source_line": "cJSON * cJSON_Duplicate_rec(const cJSON *item, size_t depth, cJSON_bool recurse);" + } + ] + }, + { + "name": "skip_oneline_comment", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "input", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char **input", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char **input", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "json/cJSON.c", + "line": 2875, + "column": 1, + "source_line": "static void skip_oneline_comment(char **input)" + }, + "start": { + "filename": "json/cJSON.c", + "line": 2875, + "column": 1, + "source_line": "static void skip_oneline_comment(char **input)" + }, + "end": { + "filename": "json/cJSON.c", + "line": 2886, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "skip_multiline_comment", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "input", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char **input", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char **input", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "json/cJSON.c", + "line": 2888, + "column": 1, + "source_line": "static void skip_multiline_comment(char **input)" + }, + "start": { + "filename": "json/cJSON.c", + "line": 2888, + "column": 1, + "source_line": "static void skip_multiline_comment(char **input)" + }, + "end": { + "filename": "json/cJSON.c", + "line": 2900, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "minify_string", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "input", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char **input", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char **input", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "output", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char **output", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char **output", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "json/cJSON.c", + "line": 2902, + "column": 1, + "source_line": "static void minify_string(char **input, char **output) {" + }, + "start": { + "filename": "json/cJSON.c", + "line": 2902, + "column": 1, + "source_line": "static void minify_string(char **input, char **output) {" + }, + "end": { + "filename": "json/cJSON.c", + "line": 2922, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + } + ], + "structs": [ + { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "json", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const unsigned char *json", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [ + "const" + ], + "source_text": "const unsigned char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "json/cJSON.c", + "line": 89, + "column": 5, + "source_line": " const unsigned char *json;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "position", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t position", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "json/cJSON.c", + "line": 90, + "column": 5, + "source_line": " size_t position;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@json/cJSON.c:88:1", + "is_incomplete": false, + "source_location": { + "filename": "json/cJSON.c", + "line": 88, + "column": 1, + "source_line": "typedef struct {" + } + }, + { + "reference": "struct internal_hooks" + }, + { + "reference": "struct@json/cJSON.c:289:1" + }, + { + "reference": "struct@json/cJSON.c:478:1" + } + ], + "unions": [], + "enums": [], + "typedefs": [ + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "error", + "name": "error", + "type": { + "reference": "struct@json/cJSON.c:88:1" + }, + "source_location": { + "filename": "json/cJSON.c", + "line": 88, + "column": 1, + "source_line": "typedef struct {" + }, + "declaration_locations": [] + }, + { + "reference": "internal_hooks" + }, + { + "reference": "parse_buffer" + }, + { + "reference": "printbuffer" + } + ], + "variables": [], + "macros": [ + { + "name": "_CRT_SECURE_NO_DEPRECATE", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "json/cJSON.c", + "line": 28, + "column": 1, + "source_line": "#define _CRT_SECURE_NO_DEPRECATE" + } + }, + { + "name": "true", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "json/cJSON.c", + "line": 63, + "column": 1, + "source_line": "#undef true" + } + }, + { + "name": "true", + "value": "((cJSON_bool)1)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "json/cJSON.c", + "line": 65, + "column": 1, + "source_line": "#define true ((cJSON_bool)1)" + } + }, + { + "name": "false", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "json/cJSON.c", + "line": 68, + "column": 1, + "source_line": "#undef false" + } + }, + { + "name": "false", + "value": "((cJSON_bool)0)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "json/cJSON.c", + "line": 70, + "column": 1, + "source_line": "#define false ((cJSON_bool)0)" + } + }, + { + "name": "isinf", + "value": "(isnan((d - d)) && !isnan(d))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "json/cJSON.c", + "line": 74, + "column": 1, + "source_line": "#define isinf(d) (isnan((d - d)) && !isnan(d))" + } + }, + { + "name": "isnan", + "value": "(d != d)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "json/cJSON.c", + "line": 77, + "column": 1, + "source_line": "#define isnan(d) (d != d)" + } + }, + { + "name": "NAN", + "value": "sqrt(-1.0)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "json/cJSON.c", + "line": 82, + "column": 1, + "source_line": "#define NAN sqrt(-1.0)" + } + }, + { + "name": "NAN", + "value": "0.0/0.0", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "json/cJSON.c", + "line": 84, + "column": 1, + "source_line": "#define NAN 0.0/0.0" + } + }, + { + "name": "internal_malloc", + "value": "malloc", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "json/cJSON.c", + "line": 178, + "column": 1, + "source_line": "#define internal_malloc malloc" + } + }, + { + "name": "internal_free", + "value": "free", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "json/cJSON.c", + "line": 179, + "column": 1, + "source_line": "#define internal_free free" + } + }, + { + "name": "internal_realloc", + "value": "realloc", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "json/cJSON.c", + "line": 180, + "column": 1, + "source_line": "#define internal_realloc realloc" + } + }, + { + "name": "static_strlen", + "value": "(sizeof(string_literal) - sizeof(\"\"))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "json/cJSON.c", + "line": 184, + "column": 1, + "source_line": "#define static_strlen(string_literal) (sizeof(string_literal) - sizeof(\"\"))" + } + }, + { + "name": "can_read", + "value": "((buffer != NULL) && (((buffer)->offset + size) <= (buffer)->length))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "json/cJSON.c", + "line": 299, + "column": 1, + "source_line": "#define can_read(buffer, size) ((buffer != NULL) && (((buffer)->offset + size) <= (buffer)->length))" + } + }, + { + "name": "can_access_at_index", + "value": "((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "json/cJSON.c", + "line": 301, + "column": 1, + "source_line": "#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length))" + } + }, + { + "name": "cannot_access_at_index", + "value": "(!can_access_at_index(buffer, index))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "json/cJSON.c", + "line": 302, + "column": 1, + "source_line": "#define cannot_access_at_index(buffer, index) (!can_access_at_index(buffer, index))" + } + }, + { + "name": "buffer_at_offset", + "value": "((buffer)->content + (buffer)->offset)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "json/cJSON.c", + "line": 304, + "column": 1, + "source_line": "#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset)" + } + }, + { + "name": "cjson_min", + "value": "(((a) < (b)) ? (a) : (b))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "json/cJSON.c", + "line": 1237, + "column": 1, + "source_line": "#define cjson_min(a, b) (((a) < (b)) ? (a) : (b))" + } + } + ], + "includes": [ + { + "target": "string.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "json/cJSON.c", + "line": 40, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "stdio.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "json/cJSON.c", + "line": 41, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "math.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "json/cJSON.c", + "line": 42, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "stdlib.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "json/cJSON.c", + "line": 43, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "limits.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "json/cJSON.c", + "line": 44, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "ctype.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "json/cJSON.c", + "line": 45, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "float.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "json/cJSON.c", + "line": 46, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "locale.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "json/cJSON.c", + "line": 49, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "cJSON.h", + "kind": "local", + "resolved_path": "json/cJSON.h", + "source_location": { + "filename": "json/cJSON.c", + "line": 59, + "column": 1, + "source_line": "#include \"cJSON.h\"" + } + } + ], + "raw_directives": [ + { + "directive": "if", + "argument": "!defined(_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)", + "source_location": { + "filename": "json/cJSON.c", + "line": 27, + "column": 1, + "source_line": "#if !defined(_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "json/cJSON.c", + "line": 29, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "__GNUC__", + "source_location": { + "filename": "json/cJSON.c", + "line": 31, + "column": 1, + "source_line": "#ifdef __GNUC__" + } + }, + { + "directive": "pragma", + "argument": "GCC visibility push(default)", + "source_location": { + "filename": "json/cJSON.c", + "line": 32, + "column": 1, + "source_line": "#pragma GCC visibility push(default)" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "json/cJSON.c", + "line": 33, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "defined(_MSC_VER)", + "source_location": { + "filename": "json/cJSON.c", + "line": 34, + "column": 1, + "source_line": "#if defined(_MSC_VER)" + } + }, + { + "directive": "pragma", + "argument": "warning (push)", + "source_location": { + "filename": "json/cJSON.c", + "line": 35, + "column": 1, + "source_line": "#pragma warning (push)" + } + }, + { + "directive": "pragma", + "argument": "warning (disable : 4001)", + "source_location": { + "filename": "json/cJSON.c", + "line": 37, + "column": 1, + "source_line": "#pragma warning (disable : 4001)" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "json/cJSON.c", + "line": 38, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "ENABLE_LOCALES", + "source_location": { + "filename": "json/cJSON.c", + "line": 48, + "column": 1, + "source_line": "#ifdef ENABLE_LOCALES" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "json/cJSON.c", + "line": 50, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "defined(_MSC_VER)", + "source_location": { + "filename": "json/cJSON.c", + "line": 52, + "column": 1, + "source_line": "#if defined(_MSC_VER)" + } + }, + { + "directive": "pragma", + "argument": "warning (pop)", + "source_location": { + "filename": "json/cJSON.c", + "line": 53, + "column": 1, + "source_line": "#pragma warning (pop)" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "json/cJSON.c", + "line": 54, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "__GNUC__", + "source_location": { + "filename": "json/cJSON.c", + "line": 55, + "column": 1, + "source_line": "#ifdef __GNUC__" + } + }, + { + "directive": "pragma", + "argument": "GCC visibility pop", + "source_location": { + "filename": "json/cJSON.c", + "line": 56, + "column": 1, + "source_line": "#pragma GCC visibility pop" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "json/cJSON.c", + "line": 57, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "true", + "source_location": { + "filename": "json/cJSON.c", + "line": 62, + "column": 1, + "source_line": "#ifdef true" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "json/cJSON.c", + "line": 64, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "false", + "source_location": { + "filename": "json/cJSON.c", + "line": 67, + "column": 1, + "source_line": "#ifdef false" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "json/cJSON.c", + "line": 69, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "isinf", + "source_location": { + "filename": "json/cJSON.c", + "line": 73, + "column": 1, + "source_line": "#ifndef isinf" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "json/cJSON.c", + "line": 75, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "isnan", + "source_location": { + "filename": "json/cJSON.c", + "line": 76, + "column": 1, + "source_line": "#ifndef isnan" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "json/cJSON.c", + "line": 78, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "NAN", + "source_location": { + "filename": "json/cJSON.c", + "line": 80, + "column": 1, + "source_line": "#ifndef NAN" + } + }, + { + "directive": "ifdef", + "argument": "_WIN32", + "source_location": { + "filename": "json/cJSON.c", + "line": 81, + "column": 1, + "source_line": "#ifdef _WIN32" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "json/cJSON.c", + "line": 83, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "json/cJSON.c", + "line": 85, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "json/cJSON.c", + "line": 86, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "(CJSON_VERSION_MAJOR != 1) || (CJSON_VERSION_MINOR != 7) || (CJSON_VERSION_PATCH != 19)", + "source_location": { + "filename": "json/cJSON.c", + "line": 120, + "column": 1, + "source_line": "#if (CJSON_VERSION_MAJOR != 1) || (CJSON_VERSION_MINOR != 7) || (CJSON_VERSION_PATCH != 19)" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "json/cJSON.c", + "line": 122, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "defined(_MSC_VER)", + "source_location": { + "filename": "json/cJSON.c", + "line": 163, + "column": 1, + "source_line": "#if defined(_MSC_VER)" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "json/cJSON.c", + "line": 177, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "json/cJSON.c", + "line": 181, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "ENABLE_LOCALES", + "source_location": { + "filename": "json/cJSON.c", + "line": 281, + "column": 1, + "source_line": "#ifdef ENABLE_LOCALES" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "json/cJSON.c", + "line": 284, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "json/cJSON.c", + "line": 286, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "defined(__clang__) || (defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 5))))", + "source_location": { + "filename": "json/cJSON.c", + "line": 2066, + "column": 1, + "source_line": "#if defined(__clang__) || (defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 5))))" + } + }, + { + "directive": "pragma", + "argument": "GCC diagnostic push", + "source_location": { + "filename": "json/cJSON.c", + "line": 2067, + "column": 5, + "source_line": " #pragma GCC diagnostic push" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "json/cJSON.c", + "line": 2068, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "__GNUC__", + "source_location": { + "filename": "json/cJSON.c", + "line": 2069, + "column": 1, + "source_line": "#ifdef __GNUC__" + } + }, + { + "directive": "pragma", + "argument": "GCC diagnostic ignored \"-Wcast-qual\"", + "source_location": { + "filename": "json/cJSON.c", + "line": 2070, + "column": 1, + "source_line": "#pragma GCC diagnostic ignored \"-Wcast-qual\"" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "json/cJSON.c", + "line": 2071, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "defined(__clang__) || (defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 5))))", + "source_location": { + "filename": "json/cJSON.c", + "line": 2077, + "column": 1, + "source_line": "#if defined(__clang__) || (defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 5))))" + } + }, + { + "directive": "pragma", + "argument": "GCC diagnostic pop", + "source_location": { + "filename": "json/cJSON.c", + "line": 2078, + "column": 5, + "source_line": " #pragma GCC diagnostic pop" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "json/cJSON.c", + "line": 2079, + "column": 1, + "source_line": "#endif" + } + } + ], + "macro_dependencies": [], + "diagnostics": [ + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'isinf' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 74, + "column": 1, + "source_line": "#define isinf(d) (isnan((d - d)) && !isnan(d))" + }, + "unit_kind": "macro", + "unit_name": "isinf" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'isnan' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 77, + "column": 1, + "source_line": "#define isnan(d) (d != d)" + }, + "unit_kind": "macro", + "unit_name": "isnan" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'static_strlen' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 184, + "column": 1, + "source_line": "#define static_strlen(string_literal) (sizeof(string_literal) - sizeof(\"\"))" + }, + "unit_kind": "macro", + "unit_name": "static_strlen" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'can_read' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 299, + "column": 1, + "source_line": "#define can_read(buffer, size) ((buffer != NULL) && (((buffer)->offset + size) <= (buffer)->length))" + }, + "unit_kind": "macro", + "unit_name": "can_read" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'can_access_at_index' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 301, + "column": 1, + "source_line": "#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length))" + }, + "unit_kind": "macro", + "unit_name": "can_access_at_index" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'cannot_access_at_index' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 302, + "column": 1, + "source_line": "#define cannot_access_at_index(buffer, index) (!can_access_at_index(buffer, index))" + }, + "unit_kind": "macro", + "unit_name": "cannot_access_at_index" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'buffer_at_offset' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 304, + "column": 1, + "source_line": "#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset)" + }, + "unit_kind": "macro", + "unit_name": "buffer_at_offset" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'cjson_min' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 1237, + "column": 1, + "source_line": "#define cjson_min(a, b) (((a) < (b)) ? (a) : (b))" + }, + "unit_kind": "macro", + "unit_name": "cjson_min" + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 92, + "column": 1, + "source_line": "static error global_error = { NULL, 0 };" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'char *'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 94, + "column": 1, + "source_line": "CJSON_PUBLIC(const char *) cJSON_GetErrorPtr(void)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 99, + "column": 1, + "source_line": "CJSON_PUBLIC(char *) cJSON_GetStringValue(const cJSON * const item)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'cJSON_GetNumberValue(const cJSON * const item)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 109, + "column": 1, + "source_line": "CJSON_PUBLIC(double) cJSON_GetNumberValue(const cJSON * const item)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'char*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 124, + "column": 1, + "source_line": "CJSON_PUBLIC(const char*) cJSON_Version(void)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_FIELD_DECLARATION", + "message": "Unsupported declarator syntax after parsed type layers: '*allocate'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 158, + "column": 5, + "source_line": " void *(CJSON_CDECL *allocate)(size_t size);" + }, + "unit_kind": "struct_field", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_FIELD_DECLARATION", + "message": "Unsupported declarator syntax after parsed type layers: '*deallocate'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 159, + "column": 5, + "source_line": " void (CJSON_CDECL *deallocate)(void *pointer);" + }, + "unit_kind": "struct_field", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_FIELD_DECLARATION", + "message": "Unsupported declarator syntax after parsed type layers: '*reallocate'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 160, + "column": 5, + "source_line": " void *(CJSON_CDECL *reallocate)(void *pointer, size_t size);" + }, + "unit_kind": "struct_field", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'internal_malloc(size_t size)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 165, + "column": 1, + "source_line": "static void * CJSON_CDECL internal_malloc(size_t size)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'internal_free(void *pointer)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 169, + "column": 1, + "source_line": "static void CJSON_CDECL internal_free(void *pointer)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'internal_realloc(void *pointer, size_t size)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 173, + "column": 1, + "source_line": "static void * CJSON_CDECL internal_realloc(void *pointer, size_t size)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 186, + "column": 1, + "source_line": "static internal_hooks global_hooks = { internal_malloc, internal_free, internal_realloc };" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'cJSON_InitHooks(cJSON_Hooks* hooks)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 209, + "column": 1, + "source_line": "CJSON_PUBLIC(void) cJSON_InitHooks(cJSON_Hooks* hooks)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'cJSON_Delete(cJSON *item)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 253, + "column": 1, + "source_line": "CJSON_PUBLIC(void) cJSON_Delete(cJSON *item)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'cJSON_SetNumberHelper(cJSON *object, double number)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 411, + "column": 1, + "source_line": "CJSON_PUBLIC(double) cJSON_SetNumberHelper(cJSON *object, double number)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 435, + "column": 1, + "source_line": "CJSON_PUBLIC(char*) cJSON_SetValuestring(cJSON *object, const char *valuestring)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 1131, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON *) cJSON_ParseWithOpts(const char *value, const char **return_parse_end, cJSON_bool require_null_terminated)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 1147, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON *) cJSON_ParseWithLengthOpts(const char *value, size_t buffer_length, const char **return_parse_end, cJSON_bool require_null_terminated)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 1227, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON *) cJSON_Parse(const char *value)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 1232, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON *) cJSON_ParseWithLength(const char *value, size_t buffer_length)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 1307, + "column": 1, + "source_line": "CJSON_PUBLIC(char *) cJSON_Print(const cJSON *item)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 1312, + "column": 1, + "source_line": "CJSON_PUBLIC(char *) cJSON_PrintUnformatted(const cJSON *item)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 1317, + "column": 1, + "source_line": "CJSON_PUBLIC(char *) cJSON_PrintBuffered(const cJSON *item, int prebuffer, cJSON_bool fmt)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'cJSON_PrintPreallocated(cJSON *item, char *buffer, const int length, const cJSON_bool format)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 1348, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON_bool) cJSON_PrintPreallocated(cJSON *item, char *buffer, const int length, const cJSON_bool format)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'cJSON_GetArraySize(const cJSON *array)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 1899, + "column": 1, + "source_line": "CJSON_PUBLIC(int) cJSON_GetArraySize(const cJSON *array)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 1941, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON *) cJSON_GetArrayItem(const cJSON *array, int index)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 1983, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON *) cJSON_GetObjectItem(const cJSON * const object, const char * const string)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 1988, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON *) cJSON_GetObjectItemCaseSensitive(const cJSON * const object, const char * const string)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'cJSON_HasObjectItem(const cJSON *object, const char *string)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 1993, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON_bool) cJSON_HasObjectItem(const cJSON *object, const char *string)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'cJSON_AddItemToArray(cJSON *array, cJSON *item)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2061, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToArray(cJSON *array, cJSON *item)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'cJSON_AddItemToObject(cJSON *object, const char *string, cJSON *item)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2119, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToObject(cJSON *object, const char *string, cJSON *item)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'cJSON_AddItemToObjectCS(cJSON *object, const char *string, cJSON *item)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2125, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToObjectCS(cJSON *object, const char *string, cJSON *item)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2130, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON_bool) cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'cJSON_AddItemReferenceToObject(cJSON *object, const char *string, cJSON *item)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2140, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON_bool) cJSON_AddItemReferenceToObject(cJSON *object, const char *string, cJSON *item)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2150, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON*) cJSON_AddNullToObject(cJSON * const object, const char * const name)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2162, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON*) cJSON_AddTrueToObject(cJSON * const object, const char * const name)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2174, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON*) cJSON_AddFalseToObject(cJSON * const object, const char * const name)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2186, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON*) cJSON_AddBoolToObject(cJSON * const object, const char * const name, const cJSON_bool boolean)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2198, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON*) cJSON_AddNumberToObject(cJSON * const object, const char * const name, const double number)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2210, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON*) cJSON_AddStringToObject(cJSON * const object, const char * const name, const char * const string)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2222, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON*) cJSON_AddRawToObject(cJSON * const object, const char * const name, const char * const raw)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2234, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON*) cJSON_AddObjectToObject(cJSON * const object, const char * const name)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2246, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON*) cJSON_AddArrayToObject(cJSON * const object, const char * const name)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2258, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON *) cJSON_DetachItemViaPointer(cJSON *parent, cJSON * const item)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2294, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromArray(cJSON *array, int which)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'cJSON_DeleteItemFromArray(cJSON *array, int which)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2304, + "column": 1, + "source_line": "CJSON_PUBLIC(void) cJSON_DeleteItemFromArray(cJSON *array, int which)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2309, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObject(cJSON *object, const char *string)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2316, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObjectCaseSensitive(cJSON *object, const char *string)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'cJSON_DeleteItemFromObject(cJSON *object, const char *string)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2323, + "column": 1, + "source_line": "CJSON_PUBLIC(void) cJSON_DeleteItemFromObject(cJSON *object, const char *string)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'cJSON_DeleteItemFromObjectCaseSensitive(cJSON *object, const char *string)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2328, + "column": 1, + "source_line": "CJSON_PUBLIC(void) cJSON_DeleteItemFromObjectCaseSensitive(cJSON *object, const char *string)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'cJSON_InsertItemInArray(cJSON *array, int which, cJSON *newitem)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2334, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON_bool) cJSON_InsertItemInArray(cJSON *array, int which, cJSON *newitem)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'cJSON_ReplaceItemViaPointer(cJSON * const parent, cJSON * const item, cJSON * replacement)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2368, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemViaPointer(cJSON * const parent, cJSON * const item, cJSON * replacement)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'cJSON_ReplaceItemInArray(cJSON *array, int which, cJSON *newitem)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2417, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInArray(cJSON *array, int which, cJSON *newitem)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'cJSON_ReplaceItemInObject(cJSON *object, const char *string, cJSON *newitem)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2450, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInObject(cJSON *object, const char *string, cJSON *newitem)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'cJSON_ReplaceItemInObjectCaseSensitive(cJSON *object, const char *string, cJSON *newitem)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2455, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInObjectCaseSensitive(cJSON *object, const char *string, cJSON *newitem)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2461, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON *) cJSON_CreateNull(void)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2472, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON *) cJSON_CreateTrue(void)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2483, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON *) cJSON_CreateFalse(void)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2494, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON *) cJSON_CreateBool(cJSON_bool boolean)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2505, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON *) cJSON_CreateNumber(double num)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2531, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON *) cJSON_CreateString(const char *string)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2548, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON *) cJSON_CreateStringReference(const char *string)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2560, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON *) cJSON_CreateObjectReference(const cJSON *child)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2571, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON *) cJSON_CreateArrayReference(const cJSON *child) {" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2581, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON *) cJSON_CreateRaw(const char *raw)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2598, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON *) cJSON_CreateArray(void)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2609, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON *) cJSON_CreateObject(void)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2621, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON *) cJSON_CreateIntArray(const int *numbers, int count)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2661, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON *) cJSON_CreateFloatArray(const float *numbers, int count)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2701, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON *) cJSON_CreateDoubleArray(const double *numbers, int count)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2741, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON *) cJSON_CreateStringArray(const char *const *strings, int count)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2784, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON *) cJSON_Duplicate(const cJSON *item, cJSON_bool recurse)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'cJSON_Minify(char *json)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2924, + "column": 1, + "source_line": "CJSON_PUBLIC(void) cJSON_Minify(char *json)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'cJSON_IsInvalid(const cJSON * const item)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2972, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON_bool) cJSON_IsInvalid(const cJSON * const item)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'cJSON_IsFalse(const cJSON * const item)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2982, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON_bool) cJSON_IsFalse(const cJSON * const item)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'cJSON_IsTrue(const cJSON * const item)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2992, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON_bool) cJSON_IsTrue(const cJSON * const item)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'cJSON_IsBool(const cJSON * const item)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 3003, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON_bool) cJSON_IsBool(const cJSON * const item)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'cJSON_IsNull(const cJSON * const item)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 3012, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON_bool) cJSON_IsNull(const cJSON * const item)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'cJSON_IsNumber(const cJSON * const item)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 3022, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON_bool) cJSON_IsNumber(const cJSON * const item)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'cJSON_IsString(const cJSON * const item)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 3032, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON_bool) cJSON_IsString(const cJSON * const item)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'cJSON_IsArray(const cJSON * const item)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 3042, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON_bool) cJSON_IsArray(const cJSON * const item)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'cJSON_IsObject(const cJSON * const item)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 3052, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON_bool) cJSON_IsObject(const cJSON * const item)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'cJSON_IsRaw(const cJSON * const item)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 3062, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON_bool) cJSON_IsRaw(const cJSON * const item)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'cJSON_Compare(const cJSON * const a, const cJSON * const b, const cJSON_bool case_sensitive)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 3072, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON_bool) cJSON_Compare(const cJSON * const a, const cJSON * const b, const cJSON_bool case_sensitive)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 3197, + "column": 1, + "source_line": "CJSON_PUBLIC(void *) cJSON_malloc(size_t size)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'cJSON_free(void *object)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 3202, + "column": 1, + "source_line": "CJSON_PUBLIC(void) cJSON_free(void *object)" + }, + "unit_kind": "declarator", + "unit_name": null + } + ] + }, + "json/cJSON.h": { + "filename": "json/cJSON.h", + "language": "c", + "parser_status": "partial", + "preprocessing": "raw", + "functions": [], + "structs": [], + "unions": [], + "enums": [], + "typedefs": [], + "variables": [], + "macros": [ + { + "name": "cJSON__h", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "json/cJSON.h", + "line": 24, + "column": 1, + "source_line": "#define cJSON__h" + } + }, + { + "name": "__WINDOWS__", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "json/cJSON.h", + "line": 32, + "column": 1, + "source_line": "#define __WINDOWS__" + } + }, + { + "name": "CJSON_CDECL", + "value": "__cdecl", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "json/cJSON.h", + "line": 55, + "column": 1, + "source_line": "#define CJSON_CDECL __cdecl" + } + }, + { + "name": "CJSON_STDCALL", + "value": "__stdcall", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "json/cJSON.h", + "line": 56, + "column": 1, + "source_line": "#define CJSON_STDCALL __stdcall" + } + }, + { + "name": "CJSON_EXPORT_SYMBOLS", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "json/cJSON.h", + "line": 60, + "column": 1, + "source_line": "#define CJSON_EXPORT_SYMBOLS" + } + }, + { + "name": "CJSON_PUBLIC", + "value": "type CJSON_STDCALL", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "json/cJSON.h", + "line": 64, + "column": 1, + "source_line": "#define CJSON_PUBLIC(type) type CJSON_STDCALL" + } + }, + { + "name": "CJSON_PUBLIC", + "value": "__declspec(dllexport) type CJSON_STDCALL", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "json/cJSON.h", + "line": 66, + "column": 1, + "source_line": "#define CJSON_PUBLIC(type) __declspec(dllexport) type CJSON_STDCALL" + } + }, + { + "name": "CJSON_PUBLIC", + "value": "__declspec(dllimport) type CJSON_STDCALL", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "json/cJSON.h", + "line": 68, + "column": 1, + "source_line": "#define CJSON_PUBLIC(type) __declspec(dllimport) type CJSON_STDCALL" + } + }, + { + "name": "CJSON_CDECL", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "json/cJSON.h", + "line": 71, + "column": 1, + "source_line": "#define CJSON_CDECL" + } + }, + { + "name": "CJSON_STDCALL", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "json/cJSON.h", + "line": 72, + "column": 1, + "source_line": "#define CJSON_STDCALL" + } + }, + { + "name": "CJSON_PUBLIC", + "value": "__attribute__((visibility(\"default\"))) type", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "json/cJSON.h", + "line": 75, + "column": 1, + "source_line": "#define CJSON_PUBLIC(type) __attribute__((visibility(\"default\"))) type" + } + }, + { + "name": "CJSON_PUBLIC", + "value": "type", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "json/cJSON.h", + "line": 77, + "column": 1, + "source_line": "#define CJSON_PUBLIC(type) type" + } + }, + { + "name": "CJSON_VERSION_MAJOR", + "value": "1", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "json/cJSON.h", + "line": 82, + "column": 1, + "source_line": "#define CJSON_VERSION_MAJOR 1" + } + }, + { + "name": "CJSON_VERSION_MINOR", + "value": "7", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "json/cJSON.h", + "line": 83, + "column": 1, + "source_line": "#define CJSON_VERSION_MINOR 7" + } + }, + { + "name": "CJSON_VERSION_PATCH", + "value": "19", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "json/cJSON.h", + "line": 84, + "column": 1, + "source_line": "#define CJSON_VERSION_PATCH 19" + } + }, + { + "name": "cJSON_Invalid", + "value": "(0)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "json/cJSON.h", + "line": 89, + "column": 1, + "source_line": "#define cJSON_Invalid (0)" + } + }, + { + "name": "cJSON_False", + "value": "(1 << 0)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "json/cJSON.h", + "line": 90, + "column": 1, + "source_line": "#define cJSON_False (1 << 0)" + } + }, + { + "name": "cJSON_True", + "value": "(1 << 1)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "json/cJSON.h", + "line": 91, + "column": 1, + "source_line": "#define cJSON_True (1 << 1)" + } + }, + { + "name": "cJSON_NULL", + "value": "(1 << 2)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "json/cJSON.h", + "line": 92, + "column": 1, + "source_line": "#define cJSON_NULL (1 << 2)" + } + }, + { + "name": "cJSON_Number", + "value": "(1 << 3)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "json/cJSON.h", + "line": 93, + "column": 1, + "source_line": "#define cJSON_Number (1 << 3)" + } + }, + { + "name": "cJSON_String", + "value": "(1 << 4)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "json/cJSON.h", + "line": 94, + "column": 1, + "source_line": "#define cJSON_String (1 << 4)" + } + }, + { + "name": "cJSON_Array", + "value": "(1 << 5)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "json/cJSON.h", + "line": 95, + "column": 1, + "source_line": "#define cJSON_Array (1 << 5)" + } + }, + { + "name": "cJSON_Object", + "value": "(1 << 6)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "json/cJSON.h", + "line": 96, + "column": 1, + "source_line": "#define cJSON_Object (1 << 6)" + } + }, + { + "name": "cJSON_Raw", + "value": "(1 << 7)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "json/cJSON.h", + "line": 97, + "column": 1, + "source_line": "#define cJSON_Raw (1 << 7) /* raw json */" + } + }, + { + "name": "cJSON_IsReference", + "value": "256", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "json/cJSON.h", + "line": 99, + "column": 1, + "source_line": "#define cJSON_IsReference 256" + } + }, + { + "name": "cJSON_StringIsConst", + "value": "512", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "json/cJSON.h", + "line": 100, + "column": 1, + "source_line": "#define cJSON_StringIsConst 512" + } + }, + { + "name": "CJSON_NESTING_LIMIT", + "value": "1000", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "json/cJSON.h", + "line": 137, + "column": 1, + "source_line": "#define CJSON_NESTING_LIMIT 1000" + } + }, + { + "name": "CJSON_CIRCULAR_LIMIT", + "value": "10000", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "json/cJSON.h", + "line": 143, + "column": 1, + "source_line": "#define CJSON_CIRCULAR_LIMIT 10000" + } + }, + { + "name": "cJSON_SetIntValue", + "value": "((object) ? (object)->valueint = (object)->valuedouble = (number) : (number))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "json/cJSON.h", + "line": 281, + "column": 1, + "source_line": "#define cJSON_SetIntValue(object, number) ((object) ? (object)->valueint = (object)->valuedouble = (number) : (number))" + } + }, + { + "name": "cJSON_SetNumberValue", + "value": "((object != NULL) ? cJSON_SetNumberHelper(object, (double)number) : (number))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "json/cJSON.h", + "line": 284, + "column": 1, + "source_line": "#define cJSON_SetNumberValue(object, number) ((object != NULL) ? cJSON_SetNumberHelper(object, (double)number) : (number))" + } + }, + { + "name": "cJSON_SetBoolValue", + "value": "( (object != NULL && ((object)->type & (cJSON_False|cJSON_True))) ? (object)->type=((object)->type &(~(cJSON_False|cJSON_True)))|((boolValue)?cJSON_True:cJSON_False) : cJSON_Invalid )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "json/cJSON.h", + "line": 289, + "column": 1, + "source_line": "#define cJSON_SetBoolValue(object, boolValue) ( \\" + } + }, + { + "name": "cJSON_ArrayForEach", + "value": "for(element = (array != NULL) ? (array)->child : NULL; element != NULL; element = element->next)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "json/cJSON.h", + "line": 296, + "column": 1, + "source_line": "#define cJSON_ArrayForEach(element, array) for(element = (array != NULL) ? (array)->child : NULL; element != NULL; element = element->next)" + } + } + ], + "includes": [ + { + "target": "stddef.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "json/cJSON.h", + "line": 86, + "column": 1, + "source_line": "#include " + } + } + ], + "raw_directives": [ + { + "directive": "ifndef", + "argument": "cJSON__h", + "source_location": { + "filename": "json/cJSON.h", + "line": 23, + "column": 1, + "source_line": "#ifndef cJSON__h" + } + }, + { + "directive": "ifdef", + "argument": "__cplusplus", + "source_location": { + "filename": "json/cJSON.h", + "line": 26, + "column": 1, + "source_line": "#ifdef __cplusplus" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "json/cJSON.h", + "line": 29, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "!defined(__WINDOWS__) && (defined(WIN32) || defined(WIN64) || defined(_MSC_VER) || defined(_WIN32))", + "source_location": { + "filename": "json/cJSON.h", + "line": 31, + "column": 1, + "source_line": "#if !defined(__WINDOWS__) && (defined(WIN32) || defined(WIN64) || defined(_MSC_VER) || defined(_WIN32))" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "json/cJSON.h", + "line": 33, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "__WINDOWS__", + "source_location": { + "filename": "json/cJSON.h", + "line": 35, + "column": 1, + "source_line": "#ifdef __WINDOWS__" + } + }, + { + "directive": "if", + "argument": "!defined(CJSON_HIDE_SYMBOLS) && !defined(CJSON_IMPORT_SYMBOLS) && !defined(CJSON_EXPORT_SYMBOLS)", + "source_location": { + "filename": "json/cJSON.h", + "line": 59, + "column": 1, + "source_line": "#if !defined(CJSON_HIDE_SYMBOLS) && !defined(CJSON_IMPORT_SYMBOLS) && !defined(CJSON_EXPORT_SYMBOLS)" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "json/cJSON.h", + "line": 61, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "defined(CJSON_HIDE_SYMBOLS)", + "source_location": { + "filename": "json/cJSON.h", + "line": 63, + "column": 1, + "source_line": "#if defined(CJSON_HIDE_SYMBOLS)" + } + }, + { + "directive": "elif", + "argument": "defined(CJSON_EXPORT_SYMBOLS)", + "source_location": { + "filename": "json/cJSON.h", + "line": 65, + "column": 1, + "source_line": "#elif defined(CJSON_EXPORT_SYMBOLS)" + } + }, + { + "directive": "elif", + "argument": "defined(CJSON_IMPORT_SYMBOLS)", + "source_location": { + "filename": "json/cJSON.h", + "line": 67, + "column": 1, + "source_line": "#elif defined(CJSON_IMPORT_SYMBOLS)" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "json/cJSON.h", + "line": 69, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "json/cJSON.h", + "line": 70, + "column": 1, + "source_line": "#else /* !__WINDOWS__ */" + } + }, + { + "directive": "if", + "argument": "(defined(__GNUC__) || defined(__SUNPRO_CC) || defined (__SUNPRO_C)) && defined(CJSON_API_VISIBILITY)", + "source_location": { + "filename": "json/cJSON.h", + "line": 74, + "column": 1, + "source_line": "#if (defined(__GNUC__) || defined(__SUNPRO_CC) || defined (__SUNPRO_C)) && defined(CJSON_API_VISIBILITY)" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "json/cJSON.h", + "line": 76, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "json/cJSON.h", + "line": 78, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "json/cJSON.h", + "line": 79, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "CJSON_NESTING_LIMIT", + "source_location": { + "filename": "json/cJSON.h", + "line": 136, + "column": 1, + "source_line": "#ifndef CJSON_NESTING_LIMIT" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "json/cJSON.h", + "line": 138, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "CJSON_CIRCULAR_LIMIT", + "source_location": { + "filename": "json/cJSON.h", + "line": 142, + "column": 1, + "source_line": "#ifndef CJSON_CIRCULAR_LIMIT" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "json/cJSON.h", + "line": 144, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "__cplusplus", + "source_location": { + "filename": "json/cJSON.h", + "line": 302, + "column": 1, + "source_line": "#ifdef __cplusplus" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "json/cJSON.h", + "line": 304, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "json/cJSON.h", + "line": 306, + "column": 1, + "source_line": "#endif" + } + } + ], + "macro_dependencies": [], + "diagnostics": [ + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'CJSON_PUBLIC' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "json/cJSON.h", + "line": 64, + "column": 1, + "source_line": "#define CJSON_PUBLIC(type) type CJSON_STDCALL" + }, + "unit_kind": "macro", + "unit_name": "CJSON_PUBLIC" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'CJSON_PUBLIC' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "json/cJSON.h", + "line": 66, + "column": 1, + "source_line": "#define CJSON_PUBLIC(type) __declspec(dllexport) type CJSON_STDCALL" + }, + "unit_kind": "macro", + "unit_name": "CJSON_PUBLIC" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'CJSON_PUBLIC' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "json/cJSON.h", + "line": 68, + "column": 1, + "source_line": "#define CJSON_PUBLIC(type) __declspec(dllimport) type CJSON_STDCALL" + }, + "unit_kind": "macro", + "unit_name": "CJSON_PUBLIC" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'CJSON_PUBLIC' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "json/cJSON.h", + "line": 75, + "column": 1, + "source_line": "#define CJSON_PUBLIC(type) __attribute__((visibility(\"default\"))) type" + }, + "unit_kind": "macro", + "unit_name": "CJSON_PUBLIC" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'CJSON_PUBLIC' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "json/cJSON.h", + "line": 77, + "column": 1, + "source_line": "#define CJSON_PUBLIC(type) type" + }, + "unit_kind": "macro", + "unit_name": "CJSON_PUBLIC" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'cJSON_SetIntValue' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "json/cJSON.h", + "line": 281, + "column": 1, + "source_line": "#define cJSON_SetIntValue(object, number) ((object) ? (object)->valueint = (object)->valuedouble = (number) : (number))" + }, + "unit_kind": "macro", + "unit_name": "cJSON_SetIntValue" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'cJSON_SetNumberValue' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "json/cJSON.h", + "line": 284, + "column": 1, + "source_line": "#define cJSON_SetNumberValue(object, number) ((object != NULL) ? cJSON_SetNumberHelper(object, (double)number) : (number))" + }, + "unit_kind": "macro", + "unit_name": "cJSON_SetNumberValue" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'cJSON_SetBoolValue' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "json/cJSON.h", + "line": 289, + "column": 1, + "source_line": "#define cJSON_SetBoolValue(object, boolValue) ( \\" + }, + "unit_kind": "macro", + "unit_name": "cJSON_SetBoolValue" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'cJSON_ArrayForEach' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "json/cJSON.h", + "line": 296, + "column": 1, + "source_line": "#define cJSON_ArrayForEach(element, array) for(element = (array != NULL) ? (array)->child : NULL; element != NULL; element = element->next)" + }, + "unit_kind": "macro", + "unit_name": "cJSON_ArrayForEach" + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '\"C\"'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.h", + "line": 27, + "column": 1, + "source_line": "extern \"C\"" + }, + "unit_kind": "declarator", + "unit_name": null + } + ] + } + }, + "functions": { + "case_insensitive_strcmp": { + "name": "case_insensitive_strcmp", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "string1", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const unsigned char *string1", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [ + "const" + ], + "source_text": "const unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const unsigned char *string1", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [ + "const" + ], + "source_text": "const unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "string2", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const unsigned char *string2", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [ + "const" + ], + "source_text": "const unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const unsigned char *string2", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [ + "const" + ], + "source_text": "const unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "json/cJSON.c", + "line": 133, + "column": 1, + "source_line": "static int case_insensitive_strcmp(const unsigned char *string1, const unsigned char *string2)" + }, + "start": { + "filename": "json/cJSON.c", + "line": 133, + "column": 1, + "source_line": "static int case_insensitive_strcmp(const unsigned char *string1, const unsigned char *string2)" + }, + "end": { + "filename": "json/cJSON.c", + "line": 154, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "cJSON_strdup": { + "name": "cJSON_strdup", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "parameters": [ + { + "name": "string", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const unsigned char * string", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [ + "const" + ], + "source_text": "const unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const unsigned char * string", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [ + "const" + ], + "source_text": "const unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "hooks", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const internal_hooks * const hooks", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "internal_hooks" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const internal_hooks * const hooks", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "internal_hooks" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "json/cJSON.c", + "line": 188, + "column": 1, + "source_line": "static unsigned char* cJSON_strdup(const unsigned char* string, const internal_hooks * const hooks)" + }, + "start": { + "filename": "json/cJSON.c", + "line": 188, + "column": 1, + "source_line": "static unsigned char* cJSON_strdup(const unsigned char* string, const internal_hooks * const hooks)" + }, + "end": { + "filename": "json/cJSON.c", + "line": 207, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "cJSON_New_Item": { + "name": "cJSON_New_Item", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "cJSON", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "parameters": [ + { + "name": "hooks", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const internal_hooks * const hooks", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "internal_hooks" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const internal_hooks * const hooks", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "internal_hooks" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "json/cJSON.c", + "line": 241, + "column": 1, + "source_line": "static cJSON *cJSON_New_Item(const internal_hooks * const hooks)" + }, + "start": { + "filename": "json/cJSON.c", + "line": 241, + "column": 1, + "source_line": "static cJSON *cJSON_New_Item(const internal_hooks * const hooks)" + }, + "end": { + "filename": "json/cJSON.c", + "line": 250, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "get_decimal_point": { + "name": "get_decimal_point", + "result_type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + }, + "parameters": [], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "json/cJSON.c", + "line": 279, + "column": 1, + "source_line": "static unsigned char get_decimal_point(void)" + }, + "start": { + "filename": "json/cJSON.c", + "line": 279, + "column": 1, + "source_line": "static unsigned char get_decimal_point(void)" + }, + "end": { + "filename": "json/cJSON.c", + "line": 287, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "parse_number": { + "name": "parse_number", + "result_type": { + "reference": "cJSON_bool" + }, + "parameters": [ + { + "name": "item", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "cJSON * const item", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "cJSON * const item", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "input_buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "parse_buffer * const input_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "parse_buffer" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "parse_buffer * const input_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "parse_buffer" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "json/cJSON.c", + "line": 307, + "column": 1, + "source_line": "static cJSON_bool parse_number(cJSON * const item, parse_buffer * const input_buffer)" + }, + "start": { + "filename": "json/cJSON.c", + "line": 307, + "column": 1, + "source_line": "static cJSON_bool parse_number(cJSON * const item, parse_buffer * const input_buffer)" + }, + "end": { + "filename": "json/cJSON.c", + "line": 408, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "ensure": { + "name": "ensure", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "printbuffer * const p", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "printbuffer" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "printbuffer * const p", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "printbuffer" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "needed", + "type": { + "reference": "size_t" + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "json/cJSON.c", + "line": 490, + "column": 1, + "source_line": "static unsigned char* ensure(printbuffer * const p, size_t needed)" + }, + "start": { + "filename": "json/cJSON.c", + "line": 490, + "column": 1, + "source_line": "static unsigned char* ensure(printbuffer * const p, size_t needed)" + }, + "end": { + "filename": "json/cJSON.c", + "line": 573, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "update_offset": { + "name": "update_offset", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "printbuffer * const buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "printbuffer" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "printbuffer * const buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "printbuffer" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "json/cJSON.c", + "line": 576, + "column": 1, + "source_line": "static void update_offset(printbuffer * const buffer)" + }, + "start": { + "filename": "json/cJSON.c", + "line": 576, + "column": 1, + "source_line": "static void update_offset(printbuffer * const buffer)" + }, + "end": { + "filename": "json/cJSON.c", + "line": 586, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "compare_double": { + "name": "compare_double", + "result_type": { + "reference": "cJSON_bool" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double a" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double a" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double b" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double b" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "json/cJSON.c", + "line": 589, + "column": 1, + "source_line": "static cJSON_bool compare_double(double a, double b)" + }, + "start": { + "filename": "json/cJSON.c", + "line": 589, + "column": 1, + "source_line": "static cJSON_bool compare_double(double a, double b)" + }, + "end": { + "filename": "json/cJSON.c", + "line": 593, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "print_number": { + "name": "print_number", + "result_type": { + "reference": "cJSON_bool" + }, + "parameters": [ + { + "name": "item", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const cJSON * const item", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const cJSON * const item", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "output_buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "printbuffer * const output_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "printbuffer" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "printbuffer * const output_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "printbuffer" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "json/cJSON.c", + "line": 596, + "column": 1, + "source_line": "static cJSON_bool print_number(const cJSON * const item, printbuffer * const output_buffer)" + }, + "start": { + "filename": "json/cJSON.c", + "line": 596, + "column": 1, + "source_line": "static cJSON_bool print_number(const cJSON * const item, printbuffer * const output_buffer)" + }, + "end": { + "filename": "json/cJSON.c", + "line": 663, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "parse_hex4": { + "name": "parse_hex4", + "result_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned" + }, + "parameters": [ + { + "name": "input", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const unsigned char * const input", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [ + "const" + ], + "source_text": "const unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const unsigned char * const input", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [ + "const" + ], + "source_text": "const unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "json/cJSON.c", + "line": 666, + "column": 1, + "source_line": "static unsigned parse_hex4(const unsigned char * const input)" + }, + "start": { + "filename": "json/cJSON.c", + "line": 666, + "column": 1, + "source_line": "static unsigned parse_hex4(const unsigned char * const input)" + }, + "end": { + "filename": "json/cJSON.c", + "line": 699, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "utf16_literal_to_utf8": { + "name": "utf16_literal_to_utf8", + "result_type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + }, + "parameters": [ + { + "name": "input_pointer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const unsigned char * const input_pointer", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [ + "const" + ], + "source_text": "const unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const unsigned char * const input_pointer", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [ + "const" + ], + "source_text": "const unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "input_end", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const unsigned char * const input_end", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [ + "const" + ], + "source_text": "const unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const unsigned char * const input_end", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [ + "const" + ], + "source_text": "const unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "output_pointer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char **output_pointer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char **output_pointer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "json/cJSON.c", + "line": 703, + "column": 1, + "source_line": "static unsigned char utf16_literal_to_utf8(const unsigned char * const input_pointer, const unsigned char * const input_end, unsigned char **output_pointer)" + }, + "start": { + "filename": "json/cJSON.c", + "line": 703, + "column": 1, + "source_line": "static unsigned char utf16_literal_to_utf8(const unsigned char * const input_pointer, const unsigned char * const input_end, unsigned char **output_pointer)" + }, + "end": { + "filename": "json/cJSON.c", + "line": 821, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "parse_string": { + "name": "parse_string", + "result_type": { + "reference": "cJSON_bool" + }, + "parameters": [ + { + "name": "item", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "cJSON * const item", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "cJSON * const item", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "input_buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "parse_buffer * const input_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "parse_buffer" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "parse_buffer * const input_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "parse_buffer" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "json/cJSON.c", + "line": 824, + "column": 1, + "source_line": "static cJSON_bool parse_string(cJSON * const item, parse_buffer * const input_buffer)" + }, + "start": { + "filename": "json/cJSON.c", + "line": 824, + "column": 1, + "source_line": "static cJSON_bool parse_string(cJSON * const item, parse_buffer * const input_buffer)" + }, + "end": { + "filename": "json/cJSON.c", + "line": 951, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "print_string_ptr": { + "name": "print_string_ptr", + "result_type": { + "reference": "cJSON_bool" + }, + "parameters": [ + { + "name": "input", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const unsigned char * const input", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [ + "const" + ], + "source_text": "const unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const unsigned char * const input", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [ + "const" + ], + "source_text": "const unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "output_buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "printbuffer * const output_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "printbuffer" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "printbuffer * const output_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "printbuffer" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "json/cJSON.c", + "line": 954, + "column": 1, + "source_line": "static cJSON_bool print_string_ptr(const unsigned char * const input, printbuffer * const output_buffer)" + }, + "start": { + "filename": "json/cJSON.c", + "line": 954, + "column": 1, + "source_line": "static cJSON_bool print_string_ptr(const unsigned char * const input, printbuffer * const output_buffer)" + }, + "end": { + "filename": "json/cJSON.c", + "line": 1073, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "print_string": { + "name": "print_string", + "result_type": { + "reference": "cJSON_bool" + }, + "parameters": [ + { + "name": "item", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const cJSON * const item", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const cJSON * const item", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "printbuffer * const p", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "printbuffer" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "printbuffer * const p", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "printbuffer" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "json/cJSON.c", + "line": 1076, + "column": 1, + "source_line": "static cJSON_bool print_string(const cJSON * const item, printbuffer * const p)" + }, + "start": { + "filename": "json/cJSON.c", + "line": 1076, + "column": 1, + "source_line": "static cJSON_bool print_string(const cJSON * const item, printbuffer * const p)" + }, + "end": { + "filename": "json/cJSON.c", + "line": 1079, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "parse_value": { + "name": "parse_value", + "result_type": { + "reference": "cJSON_bool" + }, + "parameters": [ + { + "name": "item", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "cJSON * const item", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "cJSON * const item", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "input_buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "parse_buffer * const input_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "parse_buffer" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "parse_buffer * const input_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "parse_buffer" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "json/cJSON.c", + "line": 1368, + "column": 1, + "source_line": "static cJSON_bool parse_value(cJSON * const item, parse_buffer * const input_buffer)" + }, + "start": { + "filename": "json/cJSON.c", + "line": 1368, + "column": 1, + "source_line": "static cJSON_bool parse_value(cJSON * const item, parse_buffer * const input_buffer)" + }, + "end": { + "filename": "json/cJSON.c", + "line": 1420, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "json/cJSON.c", + "line": 1082, + "column": 1, + "source_line": "static cJSON_bool parse_value(cJSON * const item, parse_buffer * const input_buffer);" + } + ] + }, + "print_value": { + "name": "print_value", + "result_type": { + "reference": "cJSON_bool" + }, + "parameters": [ + { + "name": "item", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const cJSON * const item", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const cJSON * const item", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "output_buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "printbuffer * const output_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "printbuffer" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "printbuffer * const output_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "printbuffer" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "json/cJSON.c", + "line": 1423, + "column": 1, + "source_line": "static cJSON_bool print_value(const cJSON * const item, printbuffer * const output_buffer)" + }, + "start": { + "filename": "json/cJSON.c", + "line": 1423, + "column": 1, + "source_line": "static cJSON_bool print_value(const cJSON * const item, printbuffer * const output_buffer)" + }, + "end": { + "filename": "json/cJSON.c", + "line": 1494, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "json/cJSON.c", + "line": 1083, + "column": 1, + "source_line": "static cJSON_bool print_value(const cJSON * const item, printbuffer * const output_buffer);" + } + ] + }, + "parse_array": { + "name": "parse_array", + "result_type": { + "reference": "cJSON_bool" + }, + "parameters": [ + { + "name": "item", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "cJSON * const item", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "cJSON * const item", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "input_buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "parse_buffer * const input_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "parse_buffer" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "parse_buffer * const input_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "parse_buffer" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "json/cJSON.c", + "line": 1497, + "column": 1, + "source_line": "static cJSON_bool parse_array(cJSON * const item, parse_buffer * const input_buffer)" + }, + "start": { + "filename": "json/cJSON.c", + "line": 1497, + "column": 1, + "source_line": "static cJSON_bool parse_array(cJSON * const item, parse_buffer * const input_buffer)" + }, + "end": { + "filename": "json/cJSON.c", + "line": 1592, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "json/cJSON.c", + "line": 1084, + "column": 1, + "source_line": "static cJSON_bool parse_array(cJSON * const item, parse_buffer * const input_buffer);" + } + ] + }, + "print_array": { + "name": "print_array", + "result_type": { + "reference": "cJSON_bool" + }, + "parameters": [ + { + "name": "item", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const cJSON * const item", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const cJSON * const item", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "output_buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "printbuffer * const output_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "printbuffer" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "printbuffer * const output_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "printbuffer" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "json/cJSON.c", + "line": 1595, + "column": 1, + "source_line": "static cJSON_bool print_array(const cJSON * const item, printbuffer * const output_buffer)" + }, + "start": { + "filename": "json/cJSON.c", + "line": 1595, + "column": 1, + "source_line": "static cJSON_bool print_array(const cJSON * const item, printbuffer * const output_buffer)" + }, + "end": { + "filename": "json/cJSON.c", + "line": 1659, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "json/cJSON.c", + "line": 1085, + "column": 1, + "source_line": "static cJSON_bool print_array(const cJSON * const item, printbuffer * const output_buffer);" + } + ] + }, + "parse_object": { + "name": "parse_object", + "result_type": { + "reference": "cJSON_bool" + }, + "parameters": [ + { + "name": "item", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "cJSON * const item", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "cJSON * const item", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "input_buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "parse_buffer * const input_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "parse_buffer" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "parse_buffer * const input_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "parse_buffer" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "json/cJSON.c", + "line": 1662, + "column": 1, + "source_line": "static cJSON_bool parse_object(cJSON * const item, parse_buffer * const input_buffer)" + }, + "start": { + "filename": "json/cJSON.c", + "line": 1662, + "column": 1, + "source_line": "static cJSON_bool parse_object(cJSON * const item, parse_buffer * const input_buffer)" + }, + "end": { + "filename": "json/cJSON.c", + "line": 1777, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "json/cJSON.c", + "line": 1086, + "column": 1, + "source_line": "static cJSON_bool parse_object(cJSON * const item, parse_buffer * const input_buffer);" + } + ] + }, + "print_object": { + "name": "print_object", + "result_type": { + "reference": "cJSON_bool" + }, + "parameters": [ + { + "name": "item", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const cJSON * const item", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const cJSON * const item", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "output_buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "printbuffer * const output_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "printbuffer" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "printbuffer * const output_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "printbuffer" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "json/cJSON.c", + "line": 1780, + "column": 1, + "source_line": "static cJSON_bool print_object(const cJSON * const item, printbuffer * const output_buffer)" + }, + "start": { + "filename": "json/cJSON.c", + "line": 1780, + "column": 1, + "source_line": "static cJSON_bool print_object(const cJSON * const item, printbuffer * const output_buffer)" + }, + "end": { + "filename": "json/cJSON.c", + "line": 1896, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "json/cJSON.c", + "line": 1087, + "column": 1, + "source_line": "static cJSON_bool print_object(const cJSON * const item, printbuffer * const output_buffer);" + } + ] + }, + "buffer_skip_whitespace": { + "name": "buffer_skip_whitespace", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "parse_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "parse_buffer" + } + ] + }, + "parameters": [ + { + "name": "buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "parse_buffer * const buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "parse_buffer" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "parse_buffer * const buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "parse_buffer" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "json/cJSON.c", + "line": 1090, + "column": 1, + "source_line": "static parse_buffer *buffer_skip_whitespace(parse_buffer * const buffer)" + }, + "start": { + "filename": "json/cJSON.c", + "line": 1090, + "column": 1, + "source_line": "static parse_buffer *buffer_skip_whitespace(parse_buffer * const buffer)" + }, + "end": { + "filename": "json/cJSON.c", + "line": 1113, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "skip_utf8_bom": { + "name": "skip_utf8_bom", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "parse_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "parse_buffer" + } + ] + }, + "parameters": [ + { + "name": "buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "parse_buffer * const buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "parse_buffer" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "parse_buffer * const buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "parse_buffer" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "json/cJSON.c", + "line": 1116, + "column": 1, + "source_line": "static parse_buffer *skip_utf8_bom(parse_buffer * const buffer)" + }, + "start": { + "filename": "json/cJSON.c", + "line": 1116, + "column": 1, + "source_line": "static parse_buffer *skip_utf8_bom(parse_buffer * const buffer)" + }, + "end": { + "filename": "json/cJSON.c", + "line": 1129, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "print": { + "name": "print", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "parameters": [ + { + "name": "item", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const cJSON * const item", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const cJSON * const item", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "format", + "type": { + "reference": "cJSON_bool" + }, + "declared_type": { + "reference": "cJSON_bool" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "hooks", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const internal_hooks * const hooks", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "internal_hooks" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const internal_hooks * const hooks", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "internal_hooks" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "json/cJSON.c", + "line": 1239, + "column": 1, + "source_line": "static unsigned char *print(const cJSON * const item, cJSON_bool format, const internal_hooks * const hooks)" + }, + "start": { + "filename": "json/cJSON.c", + "line": 1239, + "column": 1, + "source_line": "static unsigned char *print(const cJSON * const item, cJSON_bool format, const internal_hooks * const hooks)" + }, + "end": { + "filename": "json/cJSON.c", + "line": 1304, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "get_array_item": { + "name": "get_array_item", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "cJSON", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "parameters": [ + { + "name": "array", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const cJSON *array", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const cJSON *array", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "index", + "type": { + "reference": "size_t" + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "json/cJSON.c", + "line": 1922, + "column": 1, + "source_line": "static cJSON* get_array_item(const cJSON *array, size_t index)" + }, + "start": { + "filename": "json/cJSON.c", + "line": 1922, + "column": 1, + "source_line": "static cJSON* get_array_item(const cJSON *array, size_t index)" + }, + "end": { + "filename": "json/cJSON.c", + "line": 1939, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "get_object_item": { + "name": "get_object_item", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "cJSON", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "parameters": [ + { + "name": "object", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const cJSON * const object", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const cJSON * const object", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "name", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * const name", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * const name", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "case_sensitive", + "type": { + "reference": "cJSON_bool" + }, + "declared_type": { + "reference": "cJSON_bool" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "json/cJSON.c", + "line": 1951, + "column": 1, + "source_line": "static cJSON *get_object_item(const cJSON * const object, const char * const name, const cJSON_bool case_sensitive)" + }, + "start": { + "filename": "json/cJSON.c", + "line": 1951, + "column": 1, + "source_line": "static cJSON *get_object_item(const cJSON * const object, const char * const name, const cJSON_bool case_sensitive)" + }, + "end": { + "filename": "json/cJSON.c", + "line": 1981, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "suffix_object": { + "name": "suffix_object", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "prev", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "cJSON *prev", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "cJSON *prev", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "item", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "cJSON *item", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "cJSON *item", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "json/cJSON.c", + "line": 1999, + "column": 1, + "source_line": "static void suffix_object(cJSON *prev, cJSON *item)" + }, + "start": { + "filename": "json/cJSON.c", + "line": 1999, + "column": 1, + "source_line": "static void suffix_object(cJSON *prev, cJSON *item)" + }, + "end": { + "filename": "json/cJSON.c", + "line": 2003, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "create_reference": { + "name": "create_reference", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "cJSON", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "parameters": [ + { + "name": "item", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const cJSON *item", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const cJSON *item", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "hooks", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const internal_hooks * const hooks", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "internal_hooks" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const internal_hooks * const hooks", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "internal_hooks" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "json/cJSON.c", + "line": 2006, + "column": 1, + "source_line": "static cJSON *create_reference(const cJSON *item, const internal_hooks * const hooks)" + }, + "start": { + "filename": "json/cJSON.c", + "line": 2006, + "column": 1, + "source_line": "static cJSON *create_reference(const cJSON *item, const internal_hooks * const hooks)" + }, + "end": { + "filename": "json/cJSON.c", + "line": 2025, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "add_item_to_array": { + "name": "add_item_to_array", + "result_type": { + "reference": "cJSON_bool" + }, + "parameters": [ + { + "name": "array", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "cJSON *array", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "cJSON *array", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "item", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "cJSON *item", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "cJSON *item", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "json/cJSON.c", + "line": 2027, + "column": 1, + "source_line": "static cJSON_bool add_item_to_array(cJSON *array, cJSON *item)" + }, + "start": { + "filename": "json/cJSON.c", + "line": 2027, + "column": 1, + "source_line": "static cJSON_bool add_item_to_array(cJSON *array, cJSON *item)" + }, + "end": { + "filename": "json/cJSON.c", + "line": 2058, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "cast_away_const": { + "name": "cast_away_const", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "parameters": [ + { + "name": "string", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const void * string", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [ + "const" + ], + "source_text": "const void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const void * string", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [ + "const" + ], + "source_text": "const void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "json/cJSON.c", + "line": 2073, + "column": 1, + "source_line": "static void* cast_away_const(const void* string)" + }, + "start": { + "filename": "json/cJSON.c", + "line": 2073, + "column": 1, + "source_line": "static void* cast_away_const(const void* string)" + }, + "end": { + "filename": "json/cJSON.c", + "line": 2076, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "add_item_to_object": { + "name": "add_item_to_object", + "result_type": { + "reference": "cJSON_bool" + }, + "parameters": [ + { + "name": "object", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "cJSON * const object", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "cJSON * const object", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "string", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * const string", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * const string", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "item", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "cJSON * const item", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "cJSON * const item", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "hooks", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const internal_hooks * const hooks", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "internal_hooks" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const internal_hooks * const hooks", + "components": [ + { + "model": "CPointer", + "qualifiers": [ + "const" + ], + "source_text": "" + }, + { + "reference": "internal_hooks" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "constant_key", + "type": { + "reference": "cJSON_bool" + }, + "declared_type": { + "reference": "cJSON_bool" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "json/cJSON.c", + "line": 2082, + "column": 1, + "source_line": "static cJSON_bool add_item_to_object(cJSON * const object, const char * const string, cJSON * const item, const internal_hooks * const hooks, const cJSON_bool constant_key)" + }, + "start": { + "filename": "json/cJSON.c", + "line": 2082, + "column": 1, + "source_line": "static cJSON_bool add_item_to_object(cJSON * const object, const char * const string, cJSON * const item, const internal_hooks * const hooks, const cJSON_bool constant_key)" + }, + "end": { + "filename": "json/cJSON.c", + "line": 2117, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "replace_item_in_object": { + "name": "replace_item_in_object", + "result_type": { + "reference": "cJSON_bool" + }, + "parameters": [ + { + "name": "object", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "cJSON *object", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "cJSON *object", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "string", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *string", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *string", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "replacement", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "cJSON *replacement", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "cJSON *replacement", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "case_sensitive", + "type": { + "reference": "cJSON_bool" + }, + "declared_type": { + "reference": "cJSON_bool" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "json/cJSON.c", + "line": 2427, + "column": 1, + "source_line": "static cJSON_bool replace_item_in_object(cJSON *object, const char *string, cJSON *replacement, cJSON_bool case_sensitive)" + }, + "start": { + "filename": "json/cJSON.c", + "line": 2427, + "column": 1, + "source_line": "static cJSON_bool replace_item_in_object(cJSON *object, const char *string, cJSON *replacement, cJSON_bool case_sensitive)" + }, + "end": { + "filename": "json/cJSON.c", + "line": 2448, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "cJSON_Duplicate_rec": { + "name": "cJSON_Duplicate_rec", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "cJSON", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "parameters": [ + { + "name": "item", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const cJSON *item", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const cJSON *item", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "cJSON" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "depth", + "type": { + "reference": "size_t" + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "recurse", + "type": { + "reference": "cJSON_bool" + }, + "declared_type": { + "reference": "cJSON_bool" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "json/cJSON.c", + "line": 2789, + "column": 1, + "source_line": "cJSON * cJSON_Duplicate_rec(const cJSON *item, size_t depth, cJSON_bool recurse)" + }, + "start": { + "filename": "json/cJSON.c", + "line": 2789, + "column": 1, + "source_line": "cJSON * cJSON_Duplicate_rec(const cJSON *item, size_t depth, cJSON_bool recurse)" + }, + "end": { + "filename": "json/cJSON.c", + "line": 2873, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "json/cJSON.c", + "line": 2782, + "column": 1, + "source_line": "cJSON * cJSON_Duplicate_rec(const cJSON *item, size_t depth, cJSON_bool recurse);" + } + ] + }, + "skip_oneline_comment": { + "name": "skip_oneline_comment", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "input", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char **input", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char **input", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "json/cJSON.c", + "line": 2875, + "column": 1, + "source_line": "static void skip_oneline_comment(char **input)" + }, + "start": { + "filename": "json/cJSON.c", + "line": 2875, + "column": 1, + "source_line": "static void skip_oneline_comment(char **input)" + }, + "end": { + "filename": "json/cJSON.c", + "line": 2886, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "skip_multiline_comment": { + "name": "skip_multiline_comment", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "input", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char **input", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char **input", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "json/cJSON.c", + "line": 2888, + "column": 1, + "source_line": "static void skip_multiline_comment(char **input)" + }, + "start": { + "filename": "json/cJSON.c", + "line": 2888, + "column": 1, + "source_line": "static void skip_multiline_comment(char **input)" + }, + "end": { + "filename": "json/cJSON.c", + "line": 2900, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "minify_string": { + "name": "minify_string", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "input", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char **input", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char **input", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "output", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char **output", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char **output", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "json/cJSON.c", + "line": 2902, + "column": 1, + "source_line": "static void minify_string(char **input, char **output) {" + }, + "start": { + "filename": "json/cJSON.c", + "line": 2902, + "column": 1, + "source_line": "static void minify_string(char **input, char **output) {" + }, + "end": { + "filename": "json/cJSON.c", + "line": 2922, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + } + }, + "structs": { + "internal_hooks": { + "reference": "struct internal_hooks" + } + }, + "unions": {}, + "enums": {}, + "typedefs": { + "error": { + "reference": "error" + }, + "internal_hooks": { + "reference": "internal_hooks" + }, + "parse_buffer": { + "reference": "parse_buffer" + }, + "printbuffer": { + "reference": "printbuffer" + } + }, + "variables": {}, + "macros": { + "_CRT_SECURE_NO_DEPRECATE": { + "name": "_CRT_SECURE_NO_DEPRECATE", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "json/cJSON.c", + "line": 28, + "column": 1, + "source_line": "#define _CRT_SECURE_NO_DEPRECATE" + } + }, + "true": { + "name": "true", + "value": "((cJSON_bool)1)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "json/cJSON.c", + "line": 65, + "column": 1, + "source_line": "#define true ((cJSON_bool)1)" + } + }, + "false": { + "name": "false", + "value": "((cJSON_bool)0)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "json/cJSON.c", + "line": 70, + "column": 1, + "source_line": "#define false ((cJSON_bool)0)" + } + }, + "isinf": { + "name": "isinf", + "value": "(isnan((d - d)) && !isnan(d))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "json/cJSON.c", + "line": 74, + "column": 1, + "source_line": "#define isinf(d) (isnan((d - d)) && !isnan(d))" + } + }, + "isnan": { + "name": "isnan", + "value": "(d != d)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "json/cJSON.c", + "line": 77, + "column": 1, + "source_line": "#define isnan(d) (d != d)" + } + }, + "NAN": { + "name": "NAN", + "value": "0.0/0.0", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "json/cJSON.c", + "line": 84, + "column": 1, + "source_line": "#define NAN 0.0/0.0" + } + }, + "internal_malloc": { + "name": "internal_malloc", + "value": "malloc", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "json/cJSON.c", + "line": 178, + "column": 1, + "source_line": "#define internal_malloc malloc" + } + }, + "internal_free": { + "name": "internal_free", + "value": "free", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "json/cJSON.c", + "line": 179, + "column": 1, + "source_line": "#define internal_free free" + } + }, + "internal_realloc": { + "name": "internal_realloc", + "value": "realloc", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "json/cJSON.c", + "line": 180, + "column": 1, + "source_line": "#define internal_realloc realloc" + } + }, + "static_strlen": { + "name": "static_strlen", + "value": "(sizeof(string_literal) - sizeof(\"\"))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "json/cJSON.c", + "line": 184, + "column": 1, + "source_line": "#define static_strlen(string_literal) (sizeof(string_literal) - sizeof(\"\"))" + } + }, + "can_read": { + "name": "can_read", + "value": "((buffer != NULL) && (((buffer)->offset + size) <= (buffer)->length))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "json/cJSON.c", + "line": 299, + "column": 1, + "source_line": "#define can_read(buffer, size) ((buffer != NULL) && (((buffer)->offset + size) <= (buffer)->length))" + } + }, + "can_access_at_index": { + "name": "can_access_at_index", + "value": "((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "json/cJSON.c", + "line": 301, + "column": 1, + "source_line": "#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length))" + } + }, + "cannot_access_at_index": { + "name": "cannot_access_at_index", + "value": "(!can_access_at_index(buffer, index))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "json/cJSON.c", + "line": 302, + "column": 1, + "source_line": "#define cannot_access_at_index(buffer, index) (!can_access_at_index(buffer, index))" + } + }, + "buffer_at_offset": { + "name": "buffer_at_offset", + "value": "((buffer)->content + (buffer)->offset)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "json/cJSON.c", + "line": 304, + "column": 1, + "source_line": "#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset)" + } + }, + "cjson_min": { + "name": "cjson_min", + "value": "(((a) < (b)) ? (a) : (b))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "json/cJSON.c", + "line": 1237, + "column": 1, + "source_line": "#define cjson_min(a, b) (((a) < (b)) ? (a) : (b))" + } + }, + "cJSON__h": { + "name": "cJSON__h", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "json/cJSON.h", + "line": 24, + "column": 1, + "source_line": "#define cJSON__h" + } + }, + "__WINDOWS__": { + "name": "__WINDOWS__", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "json/cJSON.h", + "line": 32, + "column": 1, + "source_line": "#define __WINDOWS__" + } + }, + "CJSON_CDECL": { + "name": "CJSON_CDECL", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "json/cJSON.h", + "line": 71, + "column": 1, + "source_line": "#define CJSON_CDECL" + } + }, + "CJSON_STDCALL": { + "name": "CJSON_STDCALL", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "json/cJSON.h", + "line": 72, + "column": 1, + "source_line": "#define CJSON_STDCALL" + } + }, + "CJSON_EXPORT_SYMBOLS": { + "name": "CJSON_EXPORT_SYMBOLS", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "json/cJSON.h", + "line": 60, + "column": 1, + "source_line": "#define CJSON_EXPORT_SYMBOLS" + } + }, + "CJSON_PUBLIC": { + "name": "CJSON_PUBLIC", + "value": "type", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "json/cJSON.h", + "line": 77, + "column": 1, + "source_line": "#define CJSON_PUBLIC(type) type" + } + }, + "CJSON_VERSION_MAJOR": { + "name": "CJSON_VERSION_MAJOR", + "value": "1", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "json/cJSON.h", + "line": 82, + "column": 1, + "source_line": "#define CJSON_VERSION_MAJOR 1" + } + }, + "CJSON_VERSION_MINOR": { + "name": "CJSON_VERSION_MINOR", + "value": "7", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "json/cJSON.h", + "line": 83, + "column": 1, + "source_line": "#define CJSON_VERSION_MINOR 7" + } + }, + "CJSON_VERSION_PATCH": { + "name": "CJSON_VERSION_PATCH", + "value": "19", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "json/cJSON.h", + "line": 84, + "column": 1, + "source_line": "#define CJSON_VERSION_PATCH 19" + } + }, + "cJSON_Invalid": { + "name": "cJSON_Invalid", + "value": "(0)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "json/cJSON.h", + "line": 89, + "column": 1, + "source_line": "#define cJSON_Invalid (0)" + } + }, + "cJSON_False": { + "name": "cJSON_False", + "value": "(1 << 0)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "json/cJSON.h", + "line": 90, + "column": 1, + "source_line": "#define cJSON_False (1 << 0)" + } + }, + "cJSON_True": { + "name": "cJSON_True", + "value": "(1 << 1)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "json/cJSON.h", + "line": 91, + "column": 1, + "source_line": "#define cJSON_True (1 << 1)" + } + }, + "cJSON_NULL": { + "name": "cJSON_NULL", + "value": "(1 << 2)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "json/cJSON.h", + "line": 92, + "column": 1, + "source_line": "#define cJSON_NULL (1 << 2)" + } + }, + "cJSON_Number": { + "name": "cJSON_Number", + "value": "(1 << 3)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "json/cJSON.h", + "line": 93, + "column": 1, + "source_line": "#define cJSON_Number (1 << 3)" + } + }, + "cJSON_String": { + "name": "cJSON_String", + "value": "(1 << 4)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "json/cJSON.h", + "line": 94, + "column": 1, + "source_line": "#define cJSON_String (1 << 4)" + } + }, + "cJSON_Array": { + "name": "cJSON_Array", + "value": "(1 << 5)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "json/cJSON.h", + "line": 95, + "column": 1, + "source_line": "#define cJSON_Array (1 << 5)" + } + }, + "cJSON_Object": { + "name": "cJSON_Object", + "value": "(1 << 6)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "json/cJSON.h", + "line": 96, + "column": 1, + "source_line": "#define cJSON_Object (1 << 6)" + } + }, + "cJSON_Raw": { + "name": "cJSON_Raw", + "value": "(1 << 7)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "json/cJSON.h", + "line": 97, + "column": 1, + "source_line": "#define cJSON_Raw (1 << 7) /* raw json */" + } + }, + "cJSON_IsReference": { + "name": "cJSON_IsReference", + "value": "256", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "json/cJSON.h", + "line": 99, + "column": 1, + "source_line": "#define cJSON_IsReference 256" + } + }, + "cJSON_StringIsConst": { + "name": "cJSON_StringIsConst", + "value": "512", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "json/cJSON.h", + "line": 100, + "column": 1, + "source_line": "#define cJSON_StringIsConst 512" + } + }, + "CJSON_NESTING_LIMIT": { + "name": "CJSON_NESTING_LIMIT", + "value": "1000", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "json/cJSON.h", + "line": 137, + "column": 1, + "source_line": "#define CJSON_NESTING_LIMIT 1000" + } + }, + "CJSON_CIRCULAR_LIMIT": { + "name": "CJSON_CIRCULAR_LIMIT", + "value": "10000", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "json/cJSON.h", + "line": 143, + "column": 1, + "source_line": "#define CJSON_CIRCULAR_LIMIT 10000" + } + }, + "cJSON_SetIntValue": { + "name": "cJSON_SetIntValue", + "value": "((object) ? (object)->valueint = (object)->valuedouble = (number) : (number))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "json/cJSON.h", + "line": 281, + "column": 1, + "source_line": "#define cJSON_SetIntValue(object, number) ((object) ? (object)->valueint = (object)->valuedouble = (number) : (number))" + } + }, + "cJSON_SetNumberValue": { + "name": "cJSON_SetNumberValue", + "value": "((object != NULL) ? cJSON_SetNumberHelper(object, (double)number) : (number))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "json/cJSON.h", + "line": 284, + "column": 1, + "source_line": "#define cJSON_SetNumberValue(object, number) ((object != NULL) ? cJSON_SetNumberHelper(object, (double)number) : (number))" + } + }, + "cJSON_SetBoolValue": { + "name": "cJSON_SetBoolValue", + "value": "( (object != NULL && ((object)->type & (cJSON_False|cJSON_True))) ? (object)->type=((object)->type &(~(cJSON_False|cJSON_True)))|((boolValue)?cJSON_True:cJSON_False) : cJSON_Invalid )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "json/cJSON.h", + "line": 289, + "column": 1, + "source_line": "#define cJSON_SetBoolValue(object, boolValue) ( \\" + } + }, + "cJSON_ArrayForEach": { + "name": "cJSON_ArrayForEach", + "value": "for(element = (array != NULL) ? (array)->child : NULL; element != NULL; element = element->next)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "json/cJSON.h", + "line": 296, + "column": 1, + "source_line": "#define cJSON_ArrayForEach(element, array) for(element = (array != NULL) ? (array)->child : NULL; element != NULL; element = element->next)" + } + } + }, + "includes": { + "json/cJSON.c:string.h": { + "target": "string.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "json/cJSON.c", + "line": 40, + "column": 1, + "source_line": "#include " + } + }, + "json/cJSON.c:stdio.h": { + "target": "stdio.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "json/cJSON.c", + "line": 41, + "column": 1, + "source_line": "#include " + } + }, + "json/cJSON.c:math.h": { + "target": "math.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "json/cJSON.c", + "line": 42, + "column": 1, + "source_line": "#include " + } + }, + "json/cJSON.c:stdlib.h": { + "target": "stdlib.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "json/cJSON.c", + "line": 43, + "column": 1, + "source_line": "#include " + } + }, + "json/cJSON.c:limits.h": { + "target": "limits.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "json/cJSON.c", + "line": 44, + "column": 1, + "source_line": "#include " + } + }, + "json/cJSON.c:ctype.h": { + "target": "ctype.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "json/cJSON.c", + "line": 45, + "column": 1, + "source_line": "#include " + } + }, + "json/cJSON.c:float.h": { + "target": "float.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "json/cJSON.c", + "line": 46, + "column": 1, + "source_line": "#include " + } + }, + "json/cJSON.c:locale.h": { + "target": "locale.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "json/cJSON.c", + "line": 49, + "column": 1, + "source_line": "#include " + } + }, + "json/cJSON.c:cJSON.h": { + "target": "cJSON.h", + "kind": "local", + "resolved_path": "json/cJSON.h", + "source_location": { + "filename": "json/cJSON.c", + "line": 59, + "column": 1, + "source_line": "#include \"cJSON.h\"" + } + }, + "json/cJSON.h:stddef.h": { + "target": "stddef.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "json/cJSON.h", + "line": 86, + "column": 1, + "source_line": "#include " + } + } + }, + "functions_by_file": { + "json/cJSON.c": [ + "case_insensitive_strcmp", + "cJSON_strdup", + "cJSON_New_Item", + "get_decimal_point", + "parse_number", + "ensure", + "update_offset", + "compare_double", + "print_number", + "parse_hex4", + "utf16_literal_to_utf8", + "parse_string", + "print_string_ptr", + "print_string", + "parse_value", + "print_value", + "parse_array", + "print_array", + "parse_object", + "print_object", + "buffer_skip_whitespace", + "skip_utf8_bom", + "print", + "get_array_item", + "get_object_item", + "suffix_object", + "create_reference", + "add_item_to_array", + "cast_away_const", + "add_item_to_object", + "replace_item_in_object", + "cJSON_Duplicate_rec", + "skip_oneline_comment", + "skip_multiline_comment", + "minify_string" + ], + "json/cJSON.h": [] + }, + "enum_constants": {}, + "include_graph": { + "json/cJSON.c": [ + "json/cJSON.h" + ], + "json/cJSON.h": [] + }, + "system_includes": { + "json/cJSON.c": [ + "ctype.h", + "float.h", + "limits.h", + "locale.h", + "math.h", + "stdio.h", + "stdlib.h", + "string.h" + ], + "json/cJSON.h": [ + "stddef.h" + ] + }, + "unresolved_includes": { + "json/cJSON.c": [], + "json/cJSON.h": [] + }, + "header_source_pairs": { + "json/cJSON.h": [ + "json/cJSON.c" + ] + }, + "diagnostics": [ + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'isinf' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 74, + "column": 1, + "source_line": "#define isinf(d) (isnan((d - d)) && !isnan(d))" + }, + "unit_kind": "macro", + "unit_name": "isinf" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'isnan' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 77, + "column": 1, + "source_line": "#define isnan(d) (d != d)" + }, + "unit_kind": "macro", + "unit_name": "isnan" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'static_strlen' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 184, + "column": 1, + "source_line": "#define static_strlen(string_literal) (sizeof(string_literal) - sizeof(\"\"))" + }, + "unit_kind": "macro", + "unit_name": "static_strlen" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'can_read' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 299, + "column": 1, + "source_line": "#define can_read(buffer, size) ((buffer != NULL) && (((buffer)->offset + size) <= (buffer)->length))" + }, + "unit_kind": "macro", + "unit_name": "can_read" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'can_access_at_index' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 301, + "column": 1, + "source_line": "#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length))" + }, + "unit_kind": "macro", + "unit_name": "can_access_at_index" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'cannot_access_at_index' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 302, + "column": 1, + "source_line": "#define cannot_access_at_index(buffer, index) (!can_access_at_index(buffer, index))" + }, + "unit_kind": "macro", + "unit_name": "cannot_access_at_index" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'buffer_at_offset' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 304, + "column": 1, + "source_line": "#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset)" + }, + "unit_kind": "macro", + "unit_name": "buffer_at_offset" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'cjson_min' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 1237, + "column": 1, + "source_line": "#define cjson_min(a, b) (((a) < (b)) ? (a) : (b))" + }, + "unit_kind": "macro", + "unit_name": "cjson_min" + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 92, + "column": 1, + "source_line": "static error global_error = { NULL, 0 };" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'char *'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 94, + "column": 1, + "source_line": "CJSON_PUBLIC(const char *) cJSON_GetErrorPtr(void)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 99, + "column": 1, + "source_line": "CJSON_PUBLIC(char *) cJSON_GetStringValue(const cJSON * const item)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'cJSON_GetNumberValue(const cJSON * const item)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 109, + "column": 1, + "source_line": "CJSON_PUBLIC(double) cJSON_GetNumberValue(const cJSON * const item)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'char*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 124, + "column": 1, + "source_line": "CJSON_PUBLIC(const char*) cJSON_Version(void)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_FIELD_DECLARATION", + "message": "Unsupported declarator syntax after parsed type layers: '*allocate'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 158, + "column": 5, + "source_line": " void *(CJSON_CDECL *allocate)(size_t size);" + }, + "unit_kind": "struct_field", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_FIELD_DECLARATION", + "message": "Unsupported declarator syntax after parsed type layers: '*deallocate'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 159, + "column": 5, + "source_line": " void (CJSON_CDECL *deallocate)(void *pointer);" + }, + "unit_kind": "struct_field", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_FIELD_DECLARATION", + "message": "Unsupported declarator syntax after parsed type layers: '*reallocate'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 160, + "column": 5, + "source_line": " void *(CJSON_CDECL *reallocate)(void *pointer, size_t size);" + }, + "unit_kind": "struct_field", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'internal_malloc(size_t size)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 165, + "column": 1, + "source_line": "static void * CJSON_CDECL internal_malloc(size_t size)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'internal_free(void *pointer)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 169, + "column": 1, + "source_line": "static void CJSON_CDECL internal_free(void *pointer)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'internal_realloc(void *pointer, size_t size)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 173, + "column": 1, + "source_line": "static void * CJSON_CDECL internal_realloc(void *pointer, size_t size)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 186, + "column": 1, + "source_line": "static internal_hooks global_hooks = { internal_malloc, internal_free, internal_realloc };" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'cJSON_InitHooks(cJSON_Hooks* hooks)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 209, + "column": 1, + "source_line": "CJSON_PUBLIC(void) cJSON_InitHooks(cJSON_Hooks* hooks)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'cJSON_Delete(cJSON *item)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 253, + "column": 1, + "source_line": "CJSON_PUBLIC(void) cJSON_Delete(cJSON *item)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'cJSON_SetNumberHelper(cJSON *object, double number)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 411, + "column": 1, + "source_line": "CJSON_PUBLIC(double) cJSON_SetNumberHelper(cJSON *object, double number)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 435, + "column": 1, + "source_line": "CJSON_PUBLIC(char*) cJSON_SetValuestring(cJSON *object, const char *valuestring)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 1131, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON *) cJSON_ParseWithOpts(const char *value, const char **return_parse_end, cJSON_bool require_null_terminated)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 1147, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON *) cJSON_ParseWithLengthOpts(const char *value, size_t buffer_length, const char **return_parse_end, cJSON_bool require_null_terminated)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 1227, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON *) cJSON_Parse(const char *value)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 1232, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON *) cJSON_ParseWithLength(const char *value, size_t buffer_length)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 1307, + "column": 1, + "source_line": "CJSON_PUBLIC(char *) cJSON_Print(const cJSON *item)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 1312, + "column": 1, + "source_line": "CJSON_PUBLIC(char *) cJSON_PrintUnformatted(const cJSON *item)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 1317, + "column": 1, + "source_line": "CJSON_PUBLIC(char *) cJSON_PrintBuffered(const cJSON *item, int prebuffer, cJSON_bool fmt)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'cJSON_PrintPreallocated(cJSON *item, char *buffer, const int length, const cJSON_bool format)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 1348, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON_bool) cJSON_PrintPreallocated(cJSON *item, char *buffer, const int length, const cJSON_bool format)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'cJSON_GetArraySize(const cJSON *array)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 1899, + "column": 1, + "source_line": "CJSON_PUBLIC(int) cJSON_GetArraySize(const cJSON *array)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 1941, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON *) cJSON_GetArrayItem(const cJSON *array, int index)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 1983, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON *) cJSON_GetObjectItem(const cJSON * const object, const char * const string)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 1988, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON *) cJSON_GetObjectItemCaseSensitive(const cJSON * const object, const char * const string)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'cJSON_HasObjectItem(const cJSON *object, const char *string)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 1993, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON_bool) cJSON_HasObjectItem(const cJSON *object, const char *string)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'cJSON_AddItemToArray(cJSON *array, cJSON *item)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2061, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToArray(cJSON *array, cJSON *item)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'cJSON_AddItemToObject(cJSON *object, const char *string, cJSON *item)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2119, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToObject(cJSON *object, const char *string, cJSON *item)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'cJSON_AddItemToObjectCS(cJSON *object, const char *string, cJSON *item)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2125, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToObjectCS(cJSON *object, const char *string, cJSON *item)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2130, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON_bool) cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'cJSON_AddItemReferenceToObject(cJSON *object, const char *string, cJSON *item)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2140, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON_bool) cJSON_AddItemReferenceToObject(cJSON *object, const char *string, cJSON *item)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2150, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON*) cJSON_AddNullToObject(cJSON * const object, const char * const name)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2162, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON*) cJSON_AddTrueToObject(cJSON * const object, const char * const name)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2174, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON*) cJSON_AddFalseToObject(cJSON * const object, const char * const name)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2186, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON*) cJSON_AddBoolToObject(cJSON * const object, const char * const name, const cJSON_bool boolean)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2198, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON*) cJSON_AddNumberToObject(cJSON * const object, const char * const name, const double number)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2210, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON*) cJSON_AddStringToObject(cJSON * const object, const char * const name, const char * const string)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2222, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON*) cJSON_AddRawToObject(cJSON * const object, const char * const name, const char * const raw)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2234, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON*) cJSON_AddObjectToObject(cJSON * const object, const char * const name)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2246, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON*) cJSON_AddArrayToObject(cJSON * const object, const char * const name)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2258, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON *) cJSON_DetachItemViaPointer(cJSON *parent, cJSON * const item)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2294, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromArray(cJSON *array, int which)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'cJSON_DeleteItemFromArray(cJSON *array, int which)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2304, + "column": 1, + "source_line": "CJSON_PUBLIC(void) cJSON_DeleteItemFromArray(cJSON *array, int which)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2309, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObject(cJSON *object, const char *string)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2316, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObjectCaseSensitive(cJSON *object, const char *string)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'cJSON_DeleteItemFromObject(cJSON *object, const char *string)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2323, + "column": 1, + "source_line": "CJSON_PUBLIC(void) cJSON_DeleteItemFromObject(cJSON *object, const char *string)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'cJSON_DeleteItemFromObjectCaseSensitive(cJSON *object, const char *string)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2328, + "column": 1, + "source_line": "CJSON_PUBLIC(void) cJSON_DeleteItemFromObjectCaseSensitive(cJSON *object, const char *string)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'cJSON_InsertItemInArray(cJSON *array, int which, cJSON *newitem)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2334, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON_bool) cJSON_InsertItemInArray(cJSON *array, int which, cJSON *newitem)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'cJSON_ReplaceItemViaPointer(cJSON * const parent, cJSON * const item, cJSON * replacement)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2368, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemViaPointer(cJSON * const parent, cJSON * const item, cJSON * replacement)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'cJSON_ReplaceItemInArray(cJSON *array, int which, cJSON *newitem)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2417, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInArray(cJSON *array, int which, cJSON *newitem)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'cJSON_ReplaceItemInObject(cJSON *object, const char *string, cJSON *newitem)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2450, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInObject(cJSON *object, const char *string, cJSON *newitem)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'cJSON_ReplaceItemInObjectCaseSensitive(cJSON *object, const char *string, cJSON *newitem)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2455, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInObjectCaseSensitive(cJSON *object, const char *string, cJSON *newitem)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2461, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON *) cJSON_CreateNull(void)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2472, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON *) cJSON_CreateTrue(void)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2483, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON *) cJSON_CreateFalse(void)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2494, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON *) cJSON_CreateBool(cJSON_bool boolean)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2505, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON *) cJSON_CreateNumber(double num)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2531, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON *) cJSON_CreateString(const char *string)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2548, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON *) cJSON_CreateStringReference(const char *string)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2560, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON *) cJSON_CreateObjectReference(const cJSON *child)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2571, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON *) cJSON_CreateArrayReference(const cJSON *child) {" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2581, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON *) cJSON_CreateRaw(const char *raw)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2598, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON *) cJSON_CreateArray(void)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2609, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON *) cJSON_CreateObject(void)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2621, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON *) cJSON_CreateIntArray(const int *numbers, int count)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2661, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON *) cJSON_CreateFloatArray(const float *numbers, int count)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2701, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON *) cJSON_CreateDoubleArray(const double *numbers, int count)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2741, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON *) cJSON_CreateStringArray(const char *const *strings, int count)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2784, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON *) cJSON_Duplicate(const cJSON *item, cJSON_bool recurse)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'cJSON_Minify(char *json)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2924, + "column": 1, + "source_line": "CJSON_PUBLIC(void) cJSON_Minify(char *json)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'cJSON_IsInvalid(const cJSON * const item)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2972, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON_bool) cJSON_IsInvalid(const cJSON * const item)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'cJSON_IsFalse(const cJSON * const item)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2982, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON_bool) cJSON_IsFalse(const cJSON * const item)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'cJSON_IsTrue(const cJSON * const item)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 2992, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON_bool) cJSON_IsTrue(const cJSON * const item)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'cJSON_IsBool(const cJSON * const item)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 3003, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON_bool) cJSON_IsBool(const cJSON * const item)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'cJSON_IsNull(const cJSON * const item)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 3012, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON_bool) cJSON_IsNull(const cJSON * const item)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'cJSON_IsNumber(const cJSON * const item)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 3022, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON_bool) cJSON_IsNumber(const cJSON * const item)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'cJSON_IsString(const cJSON * const item)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 3032, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON_bool) cJSON_IsString(const cJSON * const item)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'cJSON_IsArray(const cJSON * const item)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 3042, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON_bool) cJSON_IsArray(const cJSON * const item)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'cJSON_IsObject(const cJSON * const item)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 3052, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON_bool) cJSON_IsObject(const cJSON * const item)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'cJSON_IsRaw(const cJSON * const item)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 3062, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON_bool) cJSON_IsRaw(const cJSON * const item)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'cJSON_Compare(const cJSON * const a, const cJSON * const b, const cJSON_bool case_sensitive)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 3072, + "column": 1, + "source_line": "CJSON_PUBLIC(cJSON_bool) cJSON_Compare(const cJSON * const a, const cJSON * const b, const cJSON_bool case_sensitive)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '*'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 3197, + "column": 1, + "source_line": "CJSON_PUBLIC(void *) cJSON_malloc(size_t size)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'cJSON_free(void *object)'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.c", + "line": 3202, + "column": 1, + "source_line": "CJSON_PUBLIC(void) cJSON_free(void *object)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'CJSON_PUBLIC' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "json/cJSON.h", + "line": 64, + "column": 1, + "source_line": "#define CJSON_PUBLIC(type) type CJSON_STDCALL" + }, + "unit_kind": "macro", + "unit_name": "CJSON_PUBLIC" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'CJSON_PUBLIC' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "json/cJSON.h", + "line": 66, + "column": 1, + "source_line": "#define CJSON_PUBLIC(type) __declspec(dllexport) type CJSON_STDCALL" + }, + "unit_kind": "macro", + "unit_name": "CJSON_PUBLIC" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'CJSON_PUBLIC' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "json/cJSON.h", + "line": 68, + "column": 1, + "source_line": "#define CJSON_PUBLIC(type) __declspec(dllimport) type CJSON_STDCALL" + }, + "unit_kind": "macro", + "unit_name": "CJSON_PUBLIC" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'CJSON_PUBLIC' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "json/cJSON.h", + "line": 75, + "column": 1, + "source_line": "#define CJSON_PUBLIC(type) __attribute__((visibility(\"default\"))) type" + }, + "unit_kind": "macro", + "unit_name": "CJSON_PUBLIC" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'CJSON_PUBLIC' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "json/cJSON.h", + "line": 77, + "column": 1, + "source_line": "#define CJSON_PUBLIC(type) type" + }, + "unit_kind": "macro", + "unit_name": "CJSON_PUBLIC" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'cJSON_SetIntValue' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "json/cJSON.h", + "line": 281, + "column": 1, + "source_line": "#define cJSON_SetIntValue(object, number) ((object) ? (object)->valueint = (object)->valuedouble = (number) : (number))" + }, + "unit_kind": "macro", + "unit_name": "cJSON_SetIntValue" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'cJSON_SetNumberValue' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "json/cJSON.h", + "line": 284, + "column": 1, + "source_line": "#define cJSON_SetNumberValue(object, number) ((object != NULL) ? cJSON_SetNumberHelper(object, (double)number) : (number))" + }, + "unit_kind": "macro", + "unit_name": "cJSON_SetNumberValue" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'cJSON_SetBoolValue' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "json/cJSON.h", + "line": 289, + "column": 1, + "source_line": "#define cJSON_SetBoolValue(object, boolValue) ( \\" + }, + "unit_kind": "macro", + "unit_name": "cJSON_SetBoolValue" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'cJSON_ArrayForEach' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "json/cJSON.h", + "line": 296, + "column": 1, + "source_line": "#define cJSON_ArrayForEach(element, array) for(element = (array != NULL) ? (array)->child : NULL; element != NULL; element = element->next)" + }, + "unit_kind": "macro", + "unit_name": "cJSON_ArrayForEach" + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '\"C\"'.", + "severity": "warning", + "location": { + "filename": "json/cJSON.h", + "line": 27, + "column": 1, + "source_line": "extern \"C\"" + }, + "unit_kind": "declarator", + "unit_name": null + } + ] +} diff --git a/tests/parser/c/fixtures/json/jsmn.json b/tests/parser/c/fixtures/json/jsmn.json new file mode 100644 index 000000000..e2130b8f4 --- /dev/null +++ b/tests/parser/c/fixtures/json/jsmn.json @@ -0,0 +1,543 @@ +{ + "files": { + "json/jsmn.h": { + "filename": "json/jsmn.h", + "language": "c", + "parser_status": "partial", + "preprocessing": "raw", + "functions": [], + "structs": [], + "unions": [], + "enums": [], + "typedefs": [], + "variables": [], + "macros": [ + { + "name": "JSMN_H", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "json/jsmn.h", + "line": 25, + "column": 1, + "source_line": "#define JSMN_H" + } + }, + { + "name": "JSMN_API", + "value": "static", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "json/jsmn.h", + "line": 34, + "column": 1, + "source_line": "#define JSMN_API static" + } + }, + { + "name": "JSMN_API", + "value": "extern", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "json/jsmn.h", + "line": 36, + "column": 1, + "source_line": "#define JSMN_API extern" + } + } + ], + "includes": [ + { + "target": "stddef.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "json/jsmn.h", + "line": 27, + "column": 1, + "source_line": "#include " + } + } + ], + "raw_directives": [ + { + "directive": "ifndef", + "argument": "JSMN_H", + "source_location": { + "filename": "json/jsmn.h", + "line": 24, + "column": 1, + "source_line": "#ifndef JSMN_H" + } + }, + { + "directive": "ifdef", + "argument": "__cplusplus", + "source_location": { + "filename": "json/jsmn.h", + "line": 29, + "column": 1, + "source_line": "#ifdef __cplusplus" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "json/jsmn.h", + "line": 31, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "JSMN_STATIC", + "source_location": { + "filename": "json/jsmn.h", + "line": 33, + "column": 1, + "source_line": "#ifdef JSMN_STATIC" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "json/jsmn.h", + "line": 35, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "json/jsmn.h", + "line": 37, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "JSMN_PARENT_LINKS", + "source_location": { + "filename": "json/jsmn.h", + "line": 74, + "column": 1, + "source_line": "#ifdef JSMN_PARENT_LINKS" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "json/jsmn.h", + "line": 76, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "JSMN_HEADER", + "source_location": { + "filename": "json/jsmn.h", + "line": 102, + "column": 1, + "source_line": "#ifndef JSMN_HEADER" + } + }, + { + "directive": "ifdef", + "argument": "JSMN_PARENT_LINKS", + "source_location": { + "filename": "json/jsmn.h", + "line": 115, + "column": 1, + "source_line": "#ifdef JSMN_PARENT_LINKS" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "json/jsmn.h", + "line": 117, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "JSMN_STRICT", + "source_location": { + "filename": "json/jsmn.h", + "line": 145, + "column": 1, + "source_line": "#ifndef JSMN_STRICT" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "json/jsmn.h", + "line": 148, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "JSMN_STRICT", + "source_location": { + "filename": "json/jsmn.h", + "line": 166, + "column": 1, + "source_line": "#ifdef JSMN_STRICT" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "json/jsmn.h", + "line": 170, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "JSMN_PARENT_LINKS", + "source_location": { + "filename": "json/jsmn.h", + "line": 183, + "column": 1, + "source_line": "#ifdef JSMN_PARENT_LINKS" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "json/jsmn.h", + "line": 185, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "JSMN_PARENT_LINKS", + "source_location": { + "filename": "json/jsmn.h", + "line": 217, + "column": 1, + "source_line": "#ifdef JSMN_PARENT_LINKS" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "json/jsmn.h", + "line": 219, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "JSMN_STRICT", + "source_location": { + "filename": "json/jsmn.h", + "line": 293, + "column": 1, + "source_line": "#ifdef JSMN_STRICT" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "json/jsmn.h", + "line": 298, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "JSMN_PARENT_LINKS", + "source_location": { + "filename": "json/jsmn.h", + "line": 300, + "column": 1, + "source_line": "#ifdef JSMN_PARENT_LINKS" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "json/jsmn.h", + "line": 302, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "JSMN_PARENT_LINKS", + "source_location": { + "filename": "json/jsmn.h", + "line": 314, + "column": 1, + "source_line": "#ifdef JSMN_PARENT_LINKS" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "json/jsmn.h", + "line": 336, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "json/jsmn.h", + "line": 359, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "JSMN_PARENT_LINKS", + "source_location": { + "filename": "json/jsmn.h", + "line": 383, + "column": 1, + "source_line": "#ifdef JSMN_PARENT_LINKS" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "json/jsmn.h", + "line": 385, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "json/jsmn.h", + "line": 394, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "JSMN_STRICT", + "source_location": { + "filename": "json/jsmn.h", + "line": 397, + "column": 1, + "source_line": "#ifdef JSMN_STRICT" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "json/jsmn.h", + "line": 421, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "json/jsmn.h", + "line": 424, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "JSMN_STRICT", + "source_location": { + "filename": "json/jsmn.h", + "line": 435, + "column": 1, + "source_line": "#ifdef JSMN_STRICT" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "json/jsmn.h", + "line": 439, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "json/jsmn.h", + "line": 465, + "column": 1, + "source_line": "#endif /* JSMN_HEADER */" + } + }, + { + "directive": "ifdef", + "argument": "__cplusplus", + "source_location": { + "filename": "json/jsmn.h", + "line": 467, + "column": 1, + "source_line": "#ifdef __cplusplus" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "json/jsmn.h", + "line": 469, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "json/jsmn.h", + "line": 471, + "column": 1, + "source_line": "#endif /* JSMN_H */" + } + } + ], + "macro_dependencies": [], + "diagnostics": [ + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '\"C\"'.", + "severity": "warning", + "location": { + "filename": "json/jsmn.h", + "line": 30, + "column": 1, + "source_line": "extern \"C\" {" + }, + "unit_kind": "declarator", + "unit_name": null + } + ] + } + }, + "functions": {}, + "structs": {}, + "unions": {}, + "enums": {}, + "typedefs": {}, + "variables": {}, + "macros": { + "JSMN_H": { + "name": "JSMN_H", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "json/jsmn.h", + "line": 25, + "column": 1, + "source_line": "#define JSMN_H" + } + }, + "JSMN_API": { + "name": "JSMN_API", + "value": "extern", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "json/jsmn.h", + "line": 36, + "column": 1, + "source_line": "#define JSMN_API extern" + } + } + }, + "includes": { + "json/jsmn.h:stddef.h": { + "target": "stddef.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "json/jsmn.h", + "line": 27, + "column": 1, + "source_line": "#include " + } + } + }, + "functions_by_file": { + "json/jsmn.h": [] + }, + "enum_constants": {}, + "include_graph": { + "json/jsmn.h": [] + }, + "system_includes": { + "json/jsmn.h": [ + "stddef.h" + ] + }, + "unresolved_includes": { + "json/jsmn.h": [] + }, + "header_source_pairs": { + "json/jsmn.h": [] + }, + "diagnostics": [ + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '\"C\"'.", + "severity": "warning", + "location": { + "filename": "json/jsmn.h", + "line": 30, + "column": 1, + "source_line": "extern \"C\" {" + }, + "unit_kind": "declarator", + "unit_name": null + } + ] +} diff --git a/tests/parser/c/fixtures/linmath/linmath.json b/tests/parser/c/fixtures/linmath/linmath.json new file mode 100644 index 000000000..5cf2d51f8 --- /dev/null +++ b/tests/parser/c/fixtures/linmath/linmath.json @@ -0,0 +1,1841 @@ +{ + "files": { + "linmath/linmath.h": { + "filename": "linmath/linmath.h", + "language": "c", + "parser_status": "partial", + "preprocessing": "raw", + "functions": [], + "structs": [], + "unions": [], + "enums": [], + "typedefs": [ + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "mat4x4", + "name": "mat4x4", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "typedef vec4 mat4x4[4]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "4", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "vec4", + "name": "vec4", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "source_location": { + "filename": "linmath/linmath.h", + "line": 105, + "column": 1, + "source_line": "typedef vec4 mat4x4[4];" + }, + "declaration_locations": [] + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "quat", + "name": "quat", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "typedef float quat[4]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "4", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": { + "filename": "linmath/linmath.h", + "line": 442, + "column": 1, + "source_line": "typedef float quat[4];" + }, + "declaration_locations": [] + } + ], + "variables": [], + "macros": [ + { + "name": "LINMATH_H", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "linmath/linmath.h", + "line": 2, + "column": 1, + "source_line": "#define LINMATH_H" + } + }, + { + "name": "LINMATH_H_FUNC", + "value": "static", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "linmath/linmath.h", + "line": 9, + "column": 1, + "source_line": "#define LINMATH_H_FUNC static" + } + }, + { + "name": "LINMATH_H_FUNC", + "value": "static inline", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "linmath/linmath.h", + "line": 11, + "column": 1, + "source_line": "#define LINMATH_H_FUNC static inline" + } + }, + { + "name": "LINMATH_H_DEFINE_VEC", + "value": "typedef float vec##n[n]; LINMATH_H_FUNC void vec##n##_add(vec##n r, vec##n const a, vec##n const b) { int i; for(i=0; ib[i] ? a[i] : b[i]; } LINMATH_H_FUNC void vec##n##_dup(vec##n r, vec##n const src) { int i; for(i=0; i" + } + }, + { + "target": "math.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "linmath/linmath.h", + "line": 5, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "string.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "linmath/linmath.h", + "line": 6, + "column": 1, + "source_line": "#include " + } + } + ], + "raw_directives": [ + { + "directive": "ifndef", + "argument": "LINMATH_H", + "source_location": { + "filename": "linmath/linmath.h", + "line": 1, + "column": 1, + "source_line": "#ifndef LINMATH_H" + } + }, + { + "directive": "ifdef", + "argument": "LINMATH_NO_INLINE", + "source_location": { + "filename": "linmath/linmath.h", + "line": 8, + "column": 1, + "source_line": "#ifdef LINMATH_NO_INLINE" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "linmath/linmath.h", + "line": 10, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "linmath/linmath.h", + "line": 12, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "linmath/linmath.h", + "line": 605, + "column": 1, + "source_line": "#endif" + } + } + ], + "macro_dependencies": [ + { + "name": "LINMATH_H_DEFINE_VEC", + "context": "declaration", + "source_location": { + "filename": "linmath/linmath.h", + "line": 70, + "column": 1, + "source_line": "LINMATH_H_DEFINE_VEC(2)" + }, + "source_text": "LINMATH_H_DEFINE_VEC(2)\nLINMATH_H_DEFINE_VEC(3)\nLINMATH_H_DEFINE_VEC(4)\n\nLINMATH_H_FUNC void vec3_mul_cross(vec3 r, vec3 const a, vec3 const b)" + }, + { + "name": "LINMATH_H_FUNC", + "context": "declaration", + "source_location": { + "filename": "linmath/linmath.h", + "line": 81, + "column": 1, + "source_line": "LINMATH_H_FUNC void vec3_reflect(vec3 r, vec3 const v, vec3 const n)" + }, + "source_text": "LINMATH_H_FUNC void vec3_reflect(vec3 r, vec3 const v, vec3 const n)" + }, + { + "name": "LINMATH_H_FUNC", + "context": "declaration", + "source_location": { + "filename": "linmath/linmath.h", + "line": 89, + "column": 1, + "source_line": "LINMATH_H_FUNC void vec4_mul_cross(vec4 r, vec4 const a, vec4 const b)" + }, + "source_text": "LINMATH_H_FUNC void vec4_mul_cross(vec4 r, vec4 const a, vec4 const b)" + }, + { + "name": "LINMATH_H_FUNC", + "context": "declaration", + "source_location": { + "filename": "linmath/linmath.h", + "line": 97, + "column": 1, + "source_line": "LINMATH_H_FUNC void vec4_reflect(vec4 r, vec4 const v, vec4 const n)" + }, + "source_text": "LINMATH_H_FUNC void vec4_reflect(vec4 r, vec4 const v, vec4 const n)" + }, + { + "name": "LINMATH_H_FUNC", + "context": "declaration", + "source_location": { + "filename": "linmath/linmath.h", + "line": 106, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_identity(mat4x4 M)" + }, + "source_text": "LINMATH_H_FUNC void mat4x4_identity(mat4x4 M)" + }, + { + "name": "LINMATH_H_FUNC", + "context": "declaration", + "source_location": { + "filename": "linmath/linmath.h", + "line": 113, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_dup(mat4x4 M, mat4x4 const N)" + }, + "source_text": "LINMATH_H_FUNC void mat4x4_dup(mat4x4 M, mat4x4 const N)" + }, + { + "name": "LINMATH_H_FUNC", + "context": "declaration", + "source_location": { + "filename": "linmath/linmath.h", + "line": 119, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_row(vec4 r, mat4x4 const M, int i)" + }, + "source_text": "LINMATH_H_FUNC void mat4x4_row(vec4 r, mat4x4 const M, int i)" + }, + { + "name": "LINMATH_H_FUNC", + "context": "declaration", + "source_location": { + "filename": "linmath/linmath.h", + "line": 125, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_col(vec4 r, mat4x4 const M, int i)" + }, + "source_text": "LINMATH_H_FUNC void mat4x4_col(vec4 r, mat4x4 const M, int i)" + }, + { + "name": "LINMATH_H_FUNC", + "context": "declaration", + "source_location": { + "filename": "linmath/linmath.h", + "line": 131, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_transpose(mat4x4 M, mat4x4 const N)" + }, + "source_text": "LINMATH_H_FUNC void mat4x4_transpose(mat4x4 M, mat4x4 const N)" + }, + { + "name": "LINMATH_H_FUNC", + "context": "declaration", + "source_location": { + "filename": "linmath/linmath.h", + "line": 140, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_add(mat4x4 M, mat4x4 const a, mat4x4 const b)" + }, + "source_text": "LINMATH_H_FUNC void mat4x4_add(mat4x4 M, mat4x4 const a, mat4x4 const b)" + }, + { + "name": "LINMATH_H_FUNC", + "context": "declaration", + "source_location": { + "filename": "linmath/linmath.h", + "line": 146, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_sub(mat4x4 M, mat4x4 const a, mat4x4 const b)" + }, + "source_text": "LINMATH_H_FUNC void mat4x4_sub(mat4x4 M, mat4x4 const a, mat4x4 const b)" + }, + { + "name": "LINMATH_H_FUNC", + "context": "declaration", + "source_location": { + "filename": "linmath/linmath.h", + "line": 152, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_scale(mat4x4 M, mat4x4 const a, float k)" + }, + "source_text": "LINMATH_H_FUNC void mat4x4_scale(mat4x4 M, mat4x4 const a, float k)" + }, + { + "name": "LINMATH_H_FUNC", + "context": "declaration", + "source_location": { + "filename": "linmath/linmath.h", + "line": 158, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_scale_aniso(mat4x4 M, mat4x4 const a, float x, float y, float z)" + }, + "source_text": "LINMATH_H_FUNC void mat4x4_scale_aniso(mat4x4 M, mat4x4 const a, float x, float y, float z)" + }, + { + "name": "LINMATH_H_FUNC", + "context": "declaration", + "source_location": { + "filename": "linmath/linmath.h", + "line": 165, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_mul(mat4x4 M, mat4x4 const a, mat4x4 const b)" + }, + "source_text": "LINMATH_H_FUNC void mat4x4_mul(mat4x4 M, mat4x4 const a, mat4x4 const b)" + }, + { + "name": "LINMATH_H_FUNC", + "context": "declaration", + "source_location": { + "filename": "linmath/linmath.h", + "line": 176, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_mul_vec4(vec4 r, mat4x4 const M, vec4 const v)" + }, + "source_text": "LINMATH_H_FUNC void mat4x4_mul_vec4(vec4 r, mat4x4 const M, vec4 const v)" + }, + { + "name": "LINMATH_H_FUNC", + "context": "declaration", + "source_location": { + "filename": "linmath/linmath.h", + "line": 185, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_translate(mat4x4 T, float x, float y, float z)" + }, + "source_text": "LINMATH_H_FUNC void mat4x4_translate(mat4x4 T, float x, float y, float z)" + }, + { + "name": "LINMATH_H_FUNC", + "context": "declaration", + "source_location": { + "filename": "linmath/linmath.h", + "line": 192, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_translate_in_place(mat4x4 M, float x, float y, float z)" + }, + "source_text": "LINMATH_H_FUNC void mat4x4_translate_in_place(mat4x4 M, float x, float y, float z)" + }, + { + "name": "LINMATH_H_FUNC", + "context": "declaration", + "source_location": { + "filename": "linmath/linmath.h", + "line": 202, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_from_vec3_mul_outer(mat4x4 M, vec3 const a, vec3 const b)" + }, + "source_text": "LINMATH_H_FUNC void mat4x4_from_vec3_mul_outer(mat4x4 M, vec3 const a, vec3 const b)" + }, + { + "name": "LINMATH_H_FUNC", + "context": "declaration", + "source_location": { + "filename": "linmath/linmath.h", + "line": 208, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_rotate(mat4x4 R, mat4x4 const M, float x, float y, float z, float angle)" + }, + "source_text": "LINMATH_H_FUNC void mat4x4_rotate(mat4x4 R, mat4x4 const M, float x, float y, float z, float angle)" + }, + { + "name": "LINMATH_H_FUNC", + "context": "declaration", + "source_location": { + "filename": "linmath/linmath.h", + "line": 242, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_rotate_X(mat4x4 Q, mat4x4 const M, float angle)" + }, + "source_text": "LINMATH_H_FUNC void mat4x4_rotate_X(mat4x4 Q, mat4x4 const M, float angle)" + }, + { + "name": "LINMATH_H_FUNC", + "context": "declaration", + "source_location": { + "filename": "linmath/linmath.h", + "line": 254, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_rotate_Y(mat4x4 Q, mat4x4 const M, float angle)" + }, + "source_text": "LINMATH_H_FUNC void mat4x4_rotate_Y(mat4x4 Q, mat4x4 const M, float angle)" + }, + { + "name": "LINMATH_H_FUNC", + "context": "declaration", + "source_location": { + "filename": "linmath/linmath.h", + "line": 266, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_rotate_Z(mat4x4 Q, mat4x4 const M, float angle)" + }, + "source_text": "LINMATH_H_FUNC void mat4x4_rotate_Z(mat4x4 Q, mat4x4 const M, float angle)" + }, + { + "name": "LINMATH_H_FUNC", + "context": "declaration", + "source_location": { + "filename": "linmath/linmath.h", + "line": 278, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_invert(mat4x4 T, mat4x4 const M)" + }, + "source_text": "LINMATH_H_FUNC void mat4x4_invert(mat4x4 T, mat4x4 const M)" + }, + { + "name": "LINMATH_H_FUNC", + "context": "declaration", + "source_location": { + "filename": "linmath/linmath.h", + "line": 319, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_orthonormalize(mat4x4 R, mat4x4 const M)" + }, + "source_text": "LINMATH_H_FUNC void mat4x4_orthonormalize(mat4x4 R, mat4x4 const M)" + }, + { + "name": "LINMATH_H_FUNC", + "context": "declaration", + "source_location": { + "filename": "linmath/linmath.h", + "line": 342, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_frustum(mat4x4 M, float l, float r, float b, float t, float n, float f)" + }, + "source_text": "LINMATH_H_FUNC void mat4x4_frustum(mat4x4 M, float l, float r, float b, float t, float n, float f)" + }, + { + "name": "LINMATH_H_FUNC", + "context": "declaration", + "source_location": { + "filename": "linmath/linmath.h", + "line": 358, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_ortho(mat4x4 M, float l, float r, float b, float t, float n, float f)" + }, + "source_text": "LINMATH_H_FUNC void mat4x4_ortho(mat4x4 M, float l, float r, float b, float t, float n, float f)" + }, + { + "name": "LINMATH_H_FUNC", + "context": "declaration", + "source_location": { + "filename": "linmath/linmath.h", + "line": 374, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_perspective(mat4x4 m, float y_fov, float aspect, float n, float f)" + }, + "source_text": "LINMATH_H_FUNC void mat4x4_perspective(mat4x4 m, float y_fov, float aspect, float n, float f)" + }, + { + "name": "LINMATH_H_FUNC", + "context": "declaration", + "source_location": { + "filename": "linmath/linmath.h", + "line": 400, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_look_at(mat4x4 m, vec3 const eye, vec3 const center, vec3 const up)" + }, + "source_text": "LINMATH_H_FUNC void mat4x4_look_at(mat4x4 m, vec3 const eye, vec3 const center, vec3 const up)" + }, + { + "name": "LINMATH_H_FUNC", + "context": "declaration", + "source_location": { + "filename": "linmath/linmath.h", + "line": 449, + "column": 1, + "source_line": "LINMATH_H_FUNC void quat_identity(quat q)" + }, + "source_text": "LINMATH_H_FUNC void quat_identity(quat q)" + }, + { + "name": "LINMATH_H_FUNC", + "context": "declaration", + "source_location": { + "filename": "linmath/linmath.h", + "line": 454, + "column": 1, + "source_line": "LINMATH_H_FUNC void quat_mul(quat r, quat const p, quat const q)" + }, + "source_text": "LINMATH_H_FUNC void quat_mul(quat r, quat const p, quat const q)" + }, + { + "name": "LINMATH_H_FUNC", + "context": "declaration", + "source_location": { + "filename": "linmath/linmath.h", + "line": 467, + "column": 1, + "source_line": "LINMATH_H_FUNC void quat_conj(quat r, quat const q)" + }, + "source_text": "LINMATH_H_FUNC void quat_conj(quat r, quat const q)" + }, + { + "name": "LINMATH_H_FUNC", + "context": "declaration", + "source_location": { + "filename": "linmath/linmath.h", + "line": 474, + "column": 1, + "source_line": "LINMATH_H_FUNC void quat_rotate(quat r, float angle, vec3 const axis) {" + }, + "source_text": "LINMATH_H_FUNC void quat_rotate(quat r, float angle, vec3 const axis)" + }, + { + "name": "LINMATH_H_FUNC", + "context": "declaration", + "source_location": { + "filename": "linmath/linmath.h", + "line": 482, + "column": 1, + "source_line": "LINMATH_H_FUNC void quat_mul_vec3(vec3 r, quat const q, vec3 const v)" + }, + "source_text": "LINMATH_H_FUNC void quat_mul_vec3(vec3 r, quat const q, vec3 const v)" + }, + { + "name": "LINMATH_H_FUNC", + "context": "declaration", + "source_location": { + "filename": "linmath/linmath.h", + "line": 502, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_from_quat(mat4x4 M, quat const q)" + }, + "source_text": "LINMATH_H_FUNC void mat4x4_from_quat(mat4x4 M, quat const q)" + }, + { + "name": "LINMATH_H_FUNC", + "context": "declaration", + "source_location": { + "filename": "linmath/linmath.h", + "line": 532, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4o_mul_quat(mat4x4 R, mat4x4 const M, quat const q)" + }, + "source_text": "LINMATH_H_FUNC void mat4x4o_mul_quat(mat4x4 R, mat4x4 const M, quat const q)" + }, + { + "name": "LINMATH_H_FUNC", + "context": "declaration", + "source_location": { + "filename": "linmath/linmath.h", + "line": 546, + "column": 1, + "source_line": "LINMATH_H_FUNC void quat_from_mat4x4(quat q, mat4x4 const M)" + }, + "source_text": "LINMATH_H_FUNC void quat_from_mat4x4(quat q, mat4x4 const M)" + }, + { + "name": "LINMATH_H_FUNC", + "context": "declaration", + "source_location": { + "filename": "linmath/linmath.h", + "line": 576, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_arcball(mat4x4 R, mat4x4 const M, vec2 const _a, vec2 const _b, float s)" + }, + "source_text": "LINMATH_H_FUNC void mat4x4_arcball(mat4x4 R, mat4x4 const M, vec2 const _a, vec2 const _b, float s)" + } + ], + "diagnostics": [ + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'LINMATH_H_DEFINE_VEC' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 14, + "column": 1, + "source_line": "#define LINMATH_H_DEFINE_VEC(n) \\" + }, + "unit_kind": "macro", + "unit_name": "LINMATH_H_DEFINE_VEC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'LINMATH_H_DEFINE_VEC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 70, + "column": 1, + "source_line": "LINMATH_H_DEFINE_VEC(2)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_DEFINE_VEC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 81, + "column": 1, + "source_line": "LINMATH_H_FUNC void vec3_reflect(vec3 r, vec3 const v, vec3 const n)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 89, + "column": 1, + "source_line": "LINMATH_H_FUNC void vec4_mul_cross(vec4 r, vec4 const a, vec4 const b)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 97, + "column": 1, + "source_line": "LINMATH_H_FUNC void vec4_reflect(vec4 r, vec4 const v, vec4 const n)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 106, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_identity(mat4x4 M)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 113, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_dup(mat4x4 M, mat4x4 const N)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 119, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_row(vec4 r, mat4x4 const M, int i)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 125, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_col(vec4 r, mat4x4 const M, int i)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 131, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_transpose(mat4x4 M, mat4x4 const N)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 140, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_add(mat4x4 M, mat4x4 const a, mat4x4 const b)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 146, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_sub(mat4x4 M, mat4x4 const a, mat4x4 const b)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 152, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_scale(mat4x4 M, mat4x4 const a, float k)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 158, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_scale_aniso(mat4x4 M, mat4x4 const a, float x, float y, float z)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 165, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_mul(mat4x4 M, mat4x4 const a, mat4x4 const b)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 176, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_mul_vec4(vec4 r, mat4x4 const M, vec4 const v)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 185, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_translate(mat4x4 T, float x, float y, float z)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 192, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_translate_in_place(mat4x4 M, float x, float y, float z)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 202, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_from_vec3_mul_outer(mat4x4 M, vec3 const a, vec3 const b)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 208, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_rotate(mat4x4 R, mat4x4 const M, float x, float y, float z, float angle)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 242, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_rotate_X(mat4x4 Q, mat4x4 const M, float angle)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 254, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_rotate_Y(mat4x4 Q, mat4x4 const M, float angle)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 266, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_rotate_Z(mat4x4 Q, mat4x4 const M, float angle)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 278, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_invert(mat4x4 T, mat4x4 const M)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 319, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_orthonormalize(mat4x4 R, mat4x4 const M)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 342, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_frustum(mat4x4 M, float l, float r, float b, float t, float n, float f)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 358, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_ortho(mat4x4 M, float l, float r, float b, float t, float n, float f)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 374, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_perspective(mat4x4 m, float y_fov, float aspect, float n, float f)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 400, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_look_at(mat4x4 m, vec3 const eye, vec3 const center, vec3 const up)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 449, + "column": 1, + "source_line": "LINMATH_H_FUNC void quat_identity(quat q)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 454, + "column": 1, + "source_line": "LINMATH_H_FUNC void quat_mul(quat r, quat const p, quat const q)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 467, + "column": 1, + "source_line": "LINMATH_H_FUNC void quat_conj(quat r, quat const q)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 474, + "column": 1, + "source_line": "LINMATH_H_FUNC void quat_rotate(quat r, float angle, vec3 const axis) {" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 482, + "column": 1, + "source_line": "LINMATH_H_FUNC void quat_mul_vec3(vec3 r, quat const q, vec3 const v)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 502, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_from_quat(mat4x4 M, quat const q)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 532, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4o_mul_quat(mat4x4 R, mat4x4 const M, quat const q)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 546, + "column": 1, + "source_line": "LINMATH_H_FUNC void quat_from_mat4x4(quat q, mat4x4 const M)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 576, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_arcball(mat4x4 R, mat4x4 const M, vec2 const _a, vec2 const _b, float s)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + } + ] + } + }, + "functions": {}, + "structs": {}, + "unions": {}, + "enums": {}, + "typedefs": { + "mat4x4": { + "reference": "mat4x4" + }, + "quat": { + "reference": "quat" + } + }, + "variables": {}, + "macros": { + "LINMATH_H": { + "name": "LINMATH_H", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "linmath/linmath.h", + "line": 2, + "column": 1, + "source_line": "#define LINMATH_H" + } + }, + "LINMATH_H_FUNC": { + "name": "LINMATH_H_FUNC", + "value": "static inline", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "linmath/linmath.h", + "line": 11, + "column": 1, + "source_line": "#define LINMATH_H_FUNC static inline" + } + }, + "LINMATH_H_DEFINE_VEC": { + "name": "LINMATH_H_DEFINE_VEC", + "value": "typedef float vec##n[n]; LINMATH_H_FUNC void vec##n##_add(vec##n r, vec##n const a, vec##n const b) { int i; for(i=0; ib[i] ? a[i] : b[i]; } LINMATH_H_FUNC void vec##n##_dup(vec##n r, vec##n const src) { int i; for(i=0; i" + } + }, + "linmath/linmath.h:math.h": { + "target": "math.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "linmath/linmath.h", + "line": 5, + "column": 1, + "source_line": "#include " + } + } + }, + "functions_by_file": { + "linmath/linmath.h": [] + }, + "enum_constants": {}, + "include_graph": { + "linmath/linmath.h": [] + }, + "system_includes": { + "linmath/linmath.h": [ + "math.h", + "string.h" + ] + }, + "unresolved_includes": { + "linmath/linmath.h": [] + }, + "header_source_pairs": { + "linmath/linmath.h": [] + }, + "diagnostics": [ + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'LINMATH_H_DEFINE_VEC' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 14, + "column": 1, + "source_line": "#define LINMATH_H_DEFINE_VEC(n) \\" + }, + "unit_kind": "macro", + "unit_name": "LINMATH_H_DEFINE_VEC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'LINMATH_H_DEFINE_VEC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 70, + "column": 1, + "source_line": "LINMATH_H_DEFINE_VEC(2)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_DEFINE_VEC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 81, + "column": 1, + "source_line": "LINMATH_H_FUNC void vec3_reflect(vec3 r, vec3 const v, vec3 const n)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 89, + "column": 1, + "source_line": "LINMATH_H_FUNC void vec4_mul_cross(vec4 r, vec4 const a, vec4 const b)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 97, + "column": 1, + "source_line": "LINMATH_H_FUNC void vec4_reflect(vec4 r, vec4 const v, vec4 const n)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 106, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_identity(mat4x4 M)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 113, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_dup(mat4x4 M, mat4x4 const N)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 119, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_row(vec4 r, mat4x4 const M, int i)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 125, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_col(vec4 r, mat4x4 const M, int i)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 131, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_transpose(mat4x4 M, mat4x4 const N)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 140, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_add(mat4x4 M, mat4x4 const a, mat4x4 const b)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 146, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_sub(mat4x4 M, mat4x4 const a, mat4x4 const b)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 152, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_scale(mat4x4 M, mat4x4 const a, float k)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 158, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_scale_aniso(mat4x4 M, mat4x4 const a, float x, float y, float z)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 165, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_mul(mat4x4 M, mat4x4 const a, mat4x4 const b)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 176, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_mul_vec4(vec4 r, mat4x4 const M, vec4 const v)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 185, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_translate(mat4x4 T, float x, float y, float z)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 192, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_translate_in_place(mat4x4 M, float x, float y, float z)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 202, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_from_vec3_mul_outer(mat4x4 M, vec3 const a, vec3 const b)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 208, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_rotate(mat4x4 R, mat4x4 const M, float x, float y, float z, float angle)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 242, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_rotate_X(mat4x4 Q, mat4x4 const M, float angle)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 254, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_rotate_Y(mat4x4 Q, mat4x4 const M, float angle)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 266, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_rotate_Z(mat4x4 Q, mat4x4 const M, float angle)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 278, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_invert(mat4x4 T, mat4x4 const M)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 319, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_orthonormalize(mat4x4 R, mat4x4 const M)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 342, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_frustum(mat4x4 M, float l, float r, float b, float t, float n, float f)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 358, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_ortho(mat4x4 M, float l, float r, float b, float t, float n, float f)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 374, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_perspective(mat4x4 m, float y_fov, float aspect, float n, float f)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 400, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_look_at(mat4x4 m, vec3 const eye, vec3 const center, vec3 const up)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 449, + "column": 1, + "source_line": "LINMATH_H_FUNC void quat_identity(quat q)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 454, + "column": 1, + "source_line": "LINMATH_H_FUNC void quat_mul(quat r, quat const p, quat const q)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 467, + "column": 1, + "source_line": "LINMATH_H_FUNC void quat_conj(quat r, quat const q)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 474, + "column": 1, + "source_line": "LINMATH_H_FUNC void quat_rotate(quat r, float angle, vec3 const axis) {" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 482, + "column": 1, + "source_line": "LINMATH_H_FUNC void quat_mul_vec3(vec3 r, quat const q, vec3 const v)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 502, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_from_quat(mat4x4 M, quat const q)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 532, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4o_mul_quat(mat4x4 R, mat4x4 const M, quat const q)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 546, + "column": 1, + "source_line": "LINMATH_H_FUNC void quat_from_mat4x4(quat q, mat4x4 const M)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'LINMATH_H_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "linmath/linmath.h", + "line": 576, + "column": 1, + "source_line": "LINMATH_H_FUNC void mat4x4_arcball(mat4x4 R, mat4x4 const M, vec2 const _a, vec2 const _b, float s)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "LINMATH_H_FUNC" + } + ] +} diff --git a/tests/parser/c/fixtures/nanosvg/nanosvg.json b/tests/parser/c/fixtures/nanosvg/nanosvg.json new file mode 100644 index 000000000..c66be4eff --- /dev/null +++ b/tests/parser/c/fixtures/nanosvg/nanosvg.json @@ -0,0 +1,45619 @@ +{ + "files": { + "nanosvg/nanosvg.h": { + "filename": "nanosvg/nanosvg.h", + "language": "c", + "parser_status": "partial", + "preprocessing": "raw", + "functions": [ + { + "name": "nsvg__isspace", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "c", + "type": { + "model": "CChar", + "qualifiers": [], + "source_text": "char c" + }, + "declared_type": { + "model": "CChar", + "qualifiers": [], + "source_text": "char c" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 228, + "column": 1, + "source_line": "static int nsvg__isspace(char c)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 228, + "column": 1, + "source_line": "static int nsvg__isspace(char c)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 231, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__isdigit", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "c", + "type": { + "model": "CChar", + "qualifiers": [], + "source_text": "char c" + }, + "declared_type": { + "model": "CChar", + "qualifiers": [], + "source_text": "char c" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 233, + "column": 1, + "source_line": "static int nsvg__isdigit(char c)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 233, + "column": 1, + "source_line": "static int nsvg__isdigit(char c)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 236, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__parseContent", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char * s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char * s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "contentCb", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void (*contentCb)(void* ud, const char* s)", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFunctionType", + "qualifiers": [], + "source_text": "void", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameter_types": [ + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * ud", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + } + ], + "is_variadic": false, + "prototype_style": "prototype" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void (*contentCb)(void* ud, const char* s)", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFunctionType", + "qualifiers": [], + "source_text": "void", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameter_types": [ + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * ud", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + } + ], + "is_variadic": false, + "prototype_style": "prototype" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ud", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * ud", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * ud", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 248, + "column": 1, + "source_line": "static void nsvg__parseContent(char* s," + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 248, + "column": 1, + "source_line": "static void nsvg__parseContent(char* s," + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 258, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__parseElement", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char * s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char * s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "startelCb", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void (*startelCb)(void* ud, const char* el, const char** attr)", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFunctionType", + "qualifiers": [], + "source_text": "void", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameter_types": [ + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * ud", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * el", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char ** attr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + } + ], + "is_variadic": false, + "prototype_style": "prototype" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void (*startelCb)(void* ud, const char* el, const char** attr)", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFunctionType", + "qualifiers": [], + "source_text": "void", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameter_types": [ + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * ud", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * el", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char ** attr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + } + ], + "is_variadic": false, + "prototype_style": "prototype" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "endelCb", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void (*endelCb)(void* ud, const char* el)", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFunctionType", + "qualifiers": [], + "source_text": "void", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameter_types": [ + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * ud", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * el", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + } + ], + "is_variadic": false, + "prototype_style": "prototype" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void (*endelCb)(void* ud, const char* el)", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFunctionType", + "qualifiers": [], + "source_text": "void", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameter_types": [ + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * ud", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * el", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + } + ], + "is_variadic": false, + "prototype_style": "prototype" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ud", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * ud", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * ud", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 260, + "column": 1, + "source_line": "static void nsvg__parseElement(char* s," + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 260, + "column": 1, + "source_line": "static void nsvg__parseElement(char* s," + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 334, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__parseXML", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "input", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char * input", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char * input", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "startelCb", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void (*startelCb)(void* ud, const char* el, const char** attr)", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFunctionType", + "qualifiers": [], + "source_text": "void", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameter_types": [ + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * ud", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * el", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char ** attr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + } + ], + "is_variadic": false, + "prototype_style": "prototype" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void (*startelCb)(void* ud, const char* el, const char** attr)", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFunctionType", + "qualifiers": [], + "source_text": "void", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameter_types": [ + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * ud", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * el", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char ** attr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + } + ], + "is_variadic": false, + "prototype_style": "prototype" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "endelCb", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void (*endelCb)(void* ud, const char* el)", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFunctionType", + "qualifiers": [], + "source_text": "void", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameter_types": [ + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * ud", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * el", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + } + ], + "is_variadic": false, + "prototype_style": "prototype" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void (*endelCb)(void* ud, const char* el)", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFunctionType", + "qualifiers": [], + "source_text": "void", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameter_types": [ + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * ud", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * el", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + } + ], + "is_variadic": false, + "prototype_style": "prototype" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "contentCb", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void (*contentCb)(void* ud, const char* s)", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFunctionType", + "qualifiers": [], + "source_text": "void", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameter_types": [ + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * ud", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + } + ], + "is_variadic": false, + "prototype_style": "prototype" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void (*contentCb)(void* ud, const char* s)", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFunctionType", + "qualifiers": [], + "source_text": "void", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameter_types": [ + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * ud", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + } + ], + "is_variadic": false, + "prototype_style": "prototype" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ud", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * ud", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * ud", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 336, + "column": 1, + "source_line": "int nsvg__parseXML(char* input," + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 336, + "column": 1, + "source_line": "int nsvg__parseXML(char* input," + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 364, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__xformIdentity", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "t", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * t", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * t", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 478, + "column": 1, + "source_line": "static void nsvg__xformIdentity(float* t)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 478, + "column": 1, + "source_line": "static void nsvg__xformIdentity(float* t)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 483, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__xformSetTranslation", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "t", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * t", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * t", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "tx", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float tx" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float tx" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ty", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float ty" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float ty" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 485, + "column": 1, + "source_line": "static void nsvg__xformSetTranslation(float* t, float tx, float ty)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 485, + "column": 1, + "source_line": "static void nsvg__xformSetTranslation(float* t, float tx, float ty)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 490, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__xformSetScale", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "t", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * t", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * t", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "sx", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float sx" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float sx" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "sy", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float sy" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float sy" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 492, + "column": 1, + "source_line": "static void nsvg__xformSetScale(float* t, float sx, float sy)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 492, + "column": 1, + "source_line": "static void nsvg__xformSetScale(float* t, float sx, float sy)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 497, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__xformSetSkewX", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "t", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * t", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * t", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "a", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float a" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float a" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 499, + "column": 1, + "source_line": "static void nsvg__xformSetSkewX(float* t, float a)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 499, + "column": 1, + "source_line": "static void nsvg__xformSetSkewX(float* t, float a)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 504, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__xformSetSkewY", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "t", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * t", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * t", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "a", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float a" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float a" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 506, + "column": 1, + "source_line": "static void nsvg__xformSetSkewY(float* t, float a)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 506, + "column": 1, + "source_line": "static void nsvg__xformSetSkewY(float* t, float a)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 511, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__xformSetRotation", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "t", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * t", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * t", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "a", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float a" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float a" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 513, + "column": 1, + "source_line": "static void nsvg__xformSetRotation(float* t, float a)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 513, + "column": 1, + "source_line": "static void nsvg__xformSetRotation(float* t, float a)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 519, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__xformMultiply", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "t", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * t", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * t", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 521, + "column": 1, + "source_line": "static void nsvg__xformMultiply(float* t, float* s)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 521, + "column": 1, + "source_line": "static void nsvg__xformMultiply(float* t, float* s)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 532, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__xformInverse", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "inv", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * inv", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * inv", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "t", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * t", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * t", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 534, + "column": 1, + "source_line": "static void nsvg__xformInverse(float* inv, float* t)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 534, + "column": 1, + "source_line": "static void nsvg__xformInverse(float* inv, float* t)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 548, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__xformPremultiply", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "t", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * t", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * t", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 550, + "column": 1, + "source_line": "static void nsvg__xformPremultiply(float* t, float* s)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 550, + "column": 1, + "source_line": "static void nsvg__xformPremultiply(float* t, float* s)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 556, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__xformPoint", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "dx", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * dx", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * dx", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dy", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * dy", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * dy", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "t", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * t", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * t", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 558, + "column": 1, + "source_line": "static void nsvg__xformPoint(float* dx, float* dy, float x, float y, float* t)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 558, + "column": 1, + "source_line": "static void nsvg__xformPoint(float* dx, float* dy, float x, float y, float* t)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 562, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__xformVec", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "dx", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * dx", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * dx", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dy", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * dy", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * dy", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "t", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * t", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * t", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 564, + "column": 1, + "source_line": "static void nsvg__xformVec(float* dx, float* dy, float x, float y, float* t)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 564, + "column": 1, + "source_line": "static void nsvg__xformVec(float* dx, float* dy, float x, float y, float* t)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 568, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__ptInBounds", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "pt", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * pt", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * pt", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "bounds", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * bounds", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * bounds", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 572, + "column": 1, + "source_line": "static int nsvg__ptInBounds(float* pt, float* bounds)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 572, + "column": 1, + "source_line": "static int nsvg__ptInBounds(float* pt, float* bounds)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 575, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__evalBezier", + "result_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + }, + "parameters": [ + { + "name": "t", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double t" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double t" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p0", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double p0" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double p0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p1", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double p1" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double p1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p2", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double p2" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double p2" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p3", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double p3" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double p3" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 578, + "column": 1, + "source_line": "static double nsvg__evalBezier(double t, double p0, double p1, double p2, double p3)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 578, + "column": 1, + "source_line": "static double nsvg__evalBezier(double t, double p0, double p1, double p2, double p3)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 582, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__curveBounds", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "bounds", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * bounds", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * bounds", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "curve", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * curve", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * curve", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 584, + "column": 1, + "source_line": "static void nsvg__curveBounds(float* bounds, float* curve)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 584, + "column": 1, + "source_line": "static void nsvg__curveBounds(float* bounds, float* curve)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 633, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__encodePaintOrder", + "result_type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CEnum", + "qualifiers": [], + "source_text": "enum NSVGpaintOrder a", + "name": "NSVGpaintOrder", + "constants": [], + "anonymous_id": null, + "source_location": null + }, + "declared_type": { + "reference": "enum NSVGpaintOrder" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CEnum", + "qualifiers": [], + "source_text": "enum NSVGpaintOrder b", + "name": "NSVGpaintOrder", + "constants": [], + "anonymous_id": null, + "source_location": null + }, + "declared_type": { + "reference": "enum NSVGpaintOrder" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c", + "type": { + "model": "CEnum", + "qualifiers": [], + "source_text": "enum NSVGpaintOrder c", + "name": "NSVGpaintOrder", + "constants": [], + "anonymous_id": null, + "source_location": null + }, + "declared_type": { + "reference": "enum NSVGpaintOrder" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 635, + "column": 1, + "source_line": "static unsigned char nsvg__encodePaintOrder(enum NSVGpaintOrder a, enum NSVGpaintOrder b, enum NSVGpaintOrder c) {" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 635, + "column": 1, + "source_line": "static unsigned char nsvg__encodePaintOrder(enum NSVGpaintOrder a, enum NSVGpaintOrder b, enum NSVGpaintOrder c) {" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 637, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__createParser", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "NSVGparser", + "name": "NSVGparser", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": "NSVGparser", + "members": [ + { + "name": "attr", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGattrib attr[NSVG_MAX_ATTR]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "NSVG_MAX_ATTR", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "NSVGattrib", + "name": "NSVGattrib", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": "NSVGattrib", + "members": [ + { + "name": "id", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char id[64]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "64", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 424, + "column": 2, + "source_line": "\tchar id[64];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "xform", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float xform[6]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "6", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 425, + "column": 2, + "source_line": "\tfloat xform[6];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "fillColor", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int fillColor" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 426, + "column": 2, + "source_line": "\tunsigned int fillColor;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "strokeColor", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int strokeColor" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 427, + "column": 2, + "source_line": "\tunsigned int strokeColor;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "opacity", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float opacity" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 428, + "column": 2, + "source_line": "\tfloat opacity;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "fillOpacity", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float fillOpacity" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 429, + "column": 2, + "source_line": "\tfloat fillOpacity;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "strokeOpacity", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float strokeOpacity" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 430, + "column": 2, + "source_line": "\tfloat strokeOpacity;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "fillGradient", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char fillGradient[64]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "64", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 431, + "column": 2, + "source_line": "\tchar fillGradient[64];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "strokeGradient", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char strokeGradient[64]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "64", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 432, + "column": 2, + "source_line": "\tchar strokeGradient[64];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "strokeWidth", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float strokeWidth" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 433, + "column": 2, + "source_line": "\tfloat strokeWidth;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "strokeDashOffset", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float strokeDashOffset" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 434, + "column": 2, + "source_line": "\tfloat strokeDashOffset;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "strokeDashArray", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float strokeDashArray[NSVG_MAX_DASHES]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "NSVG_MAX_DASHES", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 435, + "column": 2, + "source_line": "\tfloat strokeDashArray[NSVG_MAX_DASHES];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "strokeDashCount", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int strokeDashCount" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 436, + "column": 2, + "source_line": "\tint strokeDashCount;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "strokeLineJoin", + "type": { + "model": "CChar", + "qualifiers": [], + "source_text": "char strokeLineJoin" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 437, + "column": 2, + "source_line": "\tchar strokeLineJoin;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "strokeLineCap", + "type": { + "model": "CChar", + "qualifiers": [], + "source_text": "char strokeLineCap" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 438, + "column": 2, + "source_line": "\tchar strokeLineCap;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "miterLimit", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float miterLimit" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 439, + "column": 2, + "source_line": "\tfloat miterLimit;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "fillRule", + "type": { + "model": "CChar", + "qualifiers": [], + "source_text": "char fillRule" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 440, + "column": 2, + "source_line": "\tchar fillRule;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "fontSize", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float fontSize" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 441, + "column": 2, + "source_line": "\tfloat fontSize;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "stopColor", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int stopColor" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 442, + "column": 2, + "source_line": "\tunsigned int stopColor;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "stopOpacity", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float stopOpacity" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 443, + "column": 2, + "source_line": "\tfloat stopOpacity;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "stopOffset", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float stopOffset" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 444, + "column": 2, + "source_line": "\tfloat stopOffset;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "hasFill", + "type": { + "model": "CChar", + "qualifiers": [], + "source_text": "char hasFill" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 445, + "column": 2, + "source_line": "\tchar hasFill;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "hasStroke", + "type": { + "model": "CChar", + "qualifiers": [], + "source_text": "char hasStroke" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 446, + "column": 2, + "source_line": "\tchar hasStroke;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "visible", + "type": { + "model": "CChar", + "qualifiers": [], + "source_text": "char visible" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 447, + "column": 2, + "source_line": "\tchar visible;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "paintOrder", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char paintOrder" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 448, + "column": 5, + "source_line": " unsigned char paintOrder;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": null, + "is_incomplete": false, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 422, + "column": 1, + "source_line": "typedef struct NSVGattrib" + } + }, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 422, + "column": 1, + "source_line": "typedef struct NSVGattrib" + }, + "declaration_locations": [] + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 460, + "column": 2, + "source_line": "\tNSVGattrib attr[NSVG_MAX_ATTR];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "attrHead", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int attrHead" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 461, + "column": 2, + "source_line": "\tint attrHead;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "pts", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * pts", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 462, + "column": 2, + "source_line": "\tfloat* pts;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "npts", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int npts" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 463, + "column": 2, + "source_line": "\tint npts;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "cpts", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int cpts" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 464, + "column": 2, + "source_line": "\tint cpts;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "plist", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpath * plist", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "NSVGpath", + "name": "NSVGpath", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 465, + "column": 2, + "source_line": "\tNSVGpath* plist;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "image", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGimage * image", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "NSVGimage", + "name": "NSVGimage", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 466, + "column": 2, + "source_line": "\tNSVGimage* image;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "styles", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGstyleDeclaration * styles", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "NSVGstyleDeclaration", + "name": "NSVGstyleDeclaration", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": "NSVGstyleDeclaration", + "members": [ + { + "name": "className", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char * className", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 453, + "column": 2, + "source_line": "\tchar* className;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "propertiesText", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char * propertiesText", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 454, + "column": 2, + "source_line": "\tchar* propertiesText;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "next", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "struct NSVGstyleDeclaration * next", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "struct NSVGstyleDeclaration" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 455, + "column": 2, + "source_line": "\tstruct NSVGstyleDeclaration* next;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": null, + "is_incomplete": false, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 451, + "column": 1, + "source_line": "typedef struct NSVGstyleDeclaration" + } + }, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 451, + "column": 1, + "source_line": "typedef struct NSVGstyleDeclaration" + }, + "declaration_locations": [] + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 467, + "column": 2, + "source_line": "\tNSVGstyleDeclaration* styles;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "gradients", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGgradientData * gradients", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "NSVGgradientData", + "name": "NSVGgradientData", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": "NSVGgradientData", + "members": [ + { + "name": "id", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char id[64]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "64", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 407, + "column": 2, + "source_line": "\tchar id[64];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "ref", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char ref[64]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "64", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 408, + "column": 2, + "source_line": "\tchar ref[64];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "type", + "type": { + "model": "CSignedChar", + "qualifiers": [], + "source_text": "signed char type" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 409, + "column": 2, + "source_line": "\tsigned char type;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "spread", + "type": { + "model": "CChar", + "qualifiers": [], + "source_text": "char spread" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 414, + "column": 2, + "source_line": "\tchar spread;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "units", + "type": { + "model": "CChar", + "qualifiers": [], + "source_text": "char units" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 415, + "column": 2, + "source_line": "\tchar units;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "xform", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float xform[6]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "6", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 416, + "column": 2, + "source_line": "\tfloat xform[6];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "nstops", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int nstops" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 417, + "column": 2, + "source_line": "\tint nstops;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "stops", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGgradientStop * stops", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "NSVGgradientStop", + "name": "NSVGgradientStop", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 418, + "column": 2, + "source_line": "\tNSVGgradientStop* stops;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "next", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "struct NSVGgradientData * next", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "struct NSVGgradientData" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 419, + "column": 2, + "source_line": "\tstruct NSVGgradientData* next;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": null, + "is_incomplete": false, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 405, + "column": 1, + "source_line": "typedef struct NSVGgradientData" + } + }, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 405, + "column": 1, + "source_line": "typedef struct NSVGgradientData" + }, + "declaration_locations": [] + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 468, + "column": 2, + "source_line": "\tNSVGgradientData* gradients;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "shapesTail", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGshape * shapesTail", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "NSVGshape", + "name": "NSVGshape", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 469, + "column": 2, + "source_line": "\tNSVGshape* shapesTail;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "viewMinx", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float viewMinx" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 470, + "column": 2, + "source_line": "\tfloat viewMinx, viewMiny, viewWidth, viewHeight;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "viewMiny", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float viewMiny" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 470, + "column": 2, + "source_line": "\tfloat viewMinx, viewMiny, viewWidth, viewHeight;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "viewWidth", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float viewWidth" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 470, + "column": 2, + "source_line": "\tfloat viewMinx, viewMiny, viewWidth, viewHeight;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "viewHeight", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float viewHeight" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 470, + "column": 2, + "source_line": "\tfloat viewMinx, viewMiny, viewWidth, viewHeight;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "alignX", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int alignX" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 471, + "column": 2, + "source_line": "\tint alignX, alignY, alignType;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "alignY", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int alignY" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 471, + "column": 2, + "source_line": "\tint alignX, alignY, alignType;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "alignType", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int alignType" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 471, + "column": 2, + "source_line": "\tint alignX, alignY, alignType;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "dpi", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dpi" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 472, + "column": 2, + "source_line": "\tfloat dpi;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "pathFlag", + "type": { + "model": "CChar", + "qualifiers": [], + "source_text": "char pathFlag" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 473, + "column": 2, + "source_line": "\tchar pathFlag;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "defsFlag", + "type": { + "model": "CChar", + "qualifiers": [], + "source_text": "char defsFlag" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 474, + "column": 2, + "source_line": "\tchar defsFlag;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "styleFlag", + "type": { + "model": "CChar", + "qualifiers": [], + "source_text": "char styleFlag" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 475, + "column": 2, + "source_line": "\tchar styleFlag;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": null, + "is_incomplete": false, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 458, + "column": 1, + "source_line": "typedef struct NSVGparser" + } + }, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 458, + "column": 1, + "source_line": "typedef struct NSVGparser" + }, + "declaration_locations": [] + } + ] + }, + "parameters": [], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 639, + "column": 1, + "source_line": "static NSVGparser* nsvg__createParser(void)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 639, + "column": 1, + "source_line": "static NSVGparser* nsvg__createParser(void)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 676, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__deleteStyles", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "style", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGstyleDeclaration * style", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGstyleDeclaration" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGstyleDeclaration * style", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGstyleDeclaration" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 677, + "column": 1, + "source_line": "static void nsvg__deleteStyles(NSVGstyleDeclaration* style) {" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 677, + "column": 1, + "source_line": "static void nsvg__deleteStyles(NSVGstyleDeclaration* style) {" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 685, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__deletePaths", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "path", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpath * path", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "NSVGpath", + "name": "NSVGpath", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpath * path", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpath" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 687, + "column": 1, + "source_line": "static void nsvg__deletePaths(NSVGpath* path)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 687, + "column": 1, + "source_line": "static void nsvg__deletePaths(NSVGpath* path)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 696, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__deletePaint", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "paint", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpaint * paint", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "NSVGpaint", + "name": "NSVGpaint", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpaint * paint", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpaint" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 698, + "column": 1, + "source_line": "static void nsvg__deletePaint(NSVGpaint* paint)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 698, + "column": 1, + "source_line": "static void nsvg__deletePaint(NSVGpaint* paint)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 702, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__deleteGradientData", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "grad", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGgradientData * grad", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGgradientData" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGgradientData * grad", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGgradientData" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 704, + "column": 1, + "source_line": "static void nsvg__deleteGradientData(NSVGgradientData* grad)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 704, + "column": 1, + "source_line": "static void nsvg__deleteGradientData(NSVGgradientData* grad)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 713, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__deleteParser", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 715, + "column": 1, + "source_line": "static void nsvg__deleteParser(NSVGparser* p)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 715, + "column": 1, + "source_line": "static void nsvg__deleteParser(NSVGparser* p)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 725, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__resetPath", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 727, + "column": 1, + "source_line": "static void nsvg__resetPath(NSVGparser* p)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 727, + "column": 1, + "source_line": "static void nsvg__resetPath(NSVGparser* p)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 730, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__addPoint", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 732, + "column": 1, + "source_line": "static void nsvg__addPoint(NSVGparser* p, float x, float y)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 732, + "column": 1, + "source_line": "static void nsvg__addPoint(NSVGparser* p, float x, float y)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 742, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__moveTo", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 744, + "column": 1, + "source_line": "static void nsvg__moveTo(NSVGparser* p, float x, float y)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 744, + "column": 1, + "source_line": "static void nsvg__moveTo(NSVGparser* p, float x, float y)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 752, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__lineTo", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 754, + "column": 1, + "source_line": "static void nsvg__lineTo(NSVGparser* p, float x, float y)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 754, + "column": 1, + "source_line": "static void nsvg__lineTo(NSVGparser* p, float x, float y)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 766, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__cubicBezTo", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cpx1", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float cpx1" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float cpx1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cpy1", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float cpy1" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float cpy1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cpx2", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float cpx2" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float cpx2" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cpy2", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float cpy2" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float cpy2" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 768, + "column": 1, + "source_line": "static void nsvg__cubicBezTo(NSVGparser* p, float cpx1, float cpy1, float cpx2, float cpy2, float x, float y)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 768, + "column": 1, + "source_line": "static void nsvg__cubicBezTo(NSVGparser* p, float cpx1, float cpy1, float cpx2, float cpy2, float x, float y)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 775, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__getAttr", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGattrib", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGattrib" + } + ] + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 777, + "column": 1, + "source_line": "static NSVGattrib* nsvg__getAttr(NSVGparser* p)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 777, + "column": 1, + "source_line": "static NSVGattrib* nsvg__getAttr(NSVGparser* p)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 780, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__pushAttr", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 782, + "column": 1, + "source_line": "static void nsvg__pushAttr(NSVGparser* p)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 782, + "column": 1, + "source_line": "static void nsvg__pushAttr(NSVGparser* p)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 788, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__popAttr", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 790, + "column": 1, + "source_line": "static void nsvg__popAttr(NSVGparser* p)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 790, + "column": 1, + "source_line": "static void nsvg__popAttr(NSVGparser* p)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 794, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__actualOrigX", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 796, + "column": 1, + "source_line": "static float nsvg__actualOrigX(NSVGparser* p)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 796, + "column": 1, + "source_line": "static float nsvg__actualOrigX(NSVGparser* p)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 799, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__actualOrigY", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 801, + "column": 1, + "source_line": "static float nsvg__actualOrigY(NSVGparser* p)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 801, + "column": 1, + "source_line": "static float nsvg__actualOrigY(NSVGparser* p)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 804, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__actualWidth", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 806, + "column": 1, + "source_line": "static float nsvg__actualWidth(NSVGparser* p)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 806, + "column": 1, + "source_line": "static float nsvg__actualWidth(NSVGparser* p)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 809, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__actualHeight", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 811, + "column": 1, + "source_line": "static float nsvg__actualHeight(NSVGparser* p)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 811, + "column": 1, + "source_line": "static float nsvg__actualHeight(NSVGparser* p)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 814, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__actualLength", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 816, + "column": 1, + "source_line": "static float nsvg__actualLength(NSVGparser* p)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 816, + "column": 1, + "source_line": "static float nsvg__actualLength(NSVGparser* p)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 820, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__convertToPixels", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "NSVGcoordinate", + "name": "NSVGcoordinate", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": "NSVGcoordinate", + "members": [ + { + "name": "value", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float value" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 393, + "column": 2, + "source_line": "\tfloat value;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "units", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int units" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 394, + "column": 2, + "source_line": "\tint units;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": null, + "is_incomplete": false, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 392, + "column": 1, + "source_line": "typedef struct NSVGcoordinate {" + } + }, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 392, + "column": 1, + "source_line": "typedef struct NSVGcoordinate {" + }, + "declaration_locations": [] + }, + "declared_type": { + "reference": "NSVGcoordinate" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "orig", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float orig" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float orig" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "length", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float length" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float length" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 822, + "column": 1, + "source_line": "static float nsvg__convertToPixels(NSVGparser* p, NSVGcoordinate c, float orig, float length)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 822, + "column": 1, + "source_line": "static float nsvg__convertToPixels(NSVGparser* p, NSVGcoordinate c, float orig, float length)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 839, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__findGradientData", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGgradientData", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGgradientData" + } + ] + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "id", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * id", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * id", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 841, + "column": 1, + "source_line": "static NSVGgradientData* nsvg__findGradientData(NSVGparser* p, const char* id)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 841, + "column": 1, + "source_line": "static NSVGgradientData* nsvg__findGradientData(NSVGparser* p, const char* id)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 852, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__createGradient", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGgradient", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "NSVGgradient", + "name": "NSVGgradient", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "id", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * id", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * id", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "localBounds", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const float * localBounds", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [ + "const" + ], + "source_text": "const float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const float * localBounds", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [ + "const" + ], + "source_text": "const float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "xform", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *xform", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *xform", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "paintType", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "signed char * paintType", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CSignedChar", + "qualifiers": [], + "source_text": "signed char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "signed char * paintType", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CSignedChar", + "qualifiers": [], + "source_text": "signed char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 854, + "column": 1, + "source_line": "static NSVGgradient* nsvg__createGradient(NSVGparser* p, const char* id, const float* localBounds, float *xform, signed char* paintType)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 854, + "column": 1, + "source_line": "static NSVGgradient* nsvg__createGradient(NSVGparser* p, const char* id, const float* localBounds, float *xform, signed char* paintType)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 939, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__getAverageScale", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "t", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * t", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * t", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 941, + "column": 1, + "source_line": "static float nsvg__getAverageScale(float* t)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 941, + "column": 1, + "source_line": "static float nsvg__getAverageScale(float* t)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 946, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__getLocalBounds", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "bounds", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * bounds", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * bounds", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "shape", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGshape *shape", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "NSVGshape", + "name": "NSVGshape", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGshape *shape", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGshape" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "xform", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * xform", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * xform", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 948, + "column": 1, + "source_line": "static void nsvg__getLocalBounds(float* bounds, NSVGshape *shape, float* xform)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 948, + "column": 1, + "source_line": "static void nsvg__getLocalBounds(float* bounds, NSVGshape *shape, float* xform)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 976, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__addShape", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 978, + "column": 1, + "source_line": "static void nsvg__addShape(NSVGparser* p)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 978, + "column": 1, + "source_line": "static void nsvg__addShape(NSVGparser* p)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1061, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__addPath", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "closed", + "type": { + "model": "CChar", + "qualifiers": [], + "source_text": "char closed" + }, + "declared_type": { + "model": "CChar", + "qualifiers": [], + "source_text": "char closed" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1063, + "column": 1, + "source_line": "static void nsvg__addPath(NSVGparser* p, char closed)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1063, + "column": 1, + "source_line": "static void nsvg__addPath(NSVGparser* p, char closed)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1121, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__atof", + "result_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1124, + "column": 1, + "source_line": "static double nsvg__atof(const char* s)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1124, + "column": 1, + "source_line": "static double nsvg__atof(const char* s)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1180, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__parseNumber", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "it", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char * it", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char * it", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "size", + "type": { + "model": "CInt", + "qualifiers": [ + "const" + ], + "source_text": "const int size" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [ + "const" + ], + "source_text": "const int size" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1183, + "column": 1, + "source_line": "static const char* nsvg__parseNumber(const char* s, char* it, const int size)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1183, + "column": 1, + "source_line": "static const char* nsvg__parseNumber(const char* s, char* it, const int size)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1224, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__getNextPathItemWhenArcFlag", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "it", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char * it", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char * it", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1226, + "column": 1, + "source_line": "static const char* nsvg__getNextPathItemWhenArcFlag(const char* s, char* it)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1226, + "column": 1, + "source_line": "static const char* nsvg__getNextPathItemWhenArcFlag(const char* s, char* it)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1237, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__getNextPathItem", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "it", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char * it", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char * it", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1239, + "column": 1, + "source_line": "static const char* nsvg__getNextPathItem(const char* s, char* it)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1239, + "column": 1, + "source_line": "static const char* nsvg__getNextPathItem(const char* s, char* it)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1255, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__parseColorHex", + "result_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int" + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1257, + "column": 1, + "source_line": "static unsigned int nsvg__parseColorHex(const char* str)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1257, + "column": 1, + "source_line": "static unsigned int nsvg__parseColorHex(const char* str)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1265, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__parseColorRGB", + "result_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int" + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1271, + "column": 1, + "source_line": "static unsigned int nsvg__parseColorRGB(const char* str)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1271, + "column": 1, + "source_line": "static unsigned int nsvg__parseColorRGB(const char* str)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1319, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__parseColorName", + "result_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int" + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1480, + "column": 1, + "source_line": "static unsigned int nsvg__parseColorName(const char* str)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1480, + "column": 1, + "source_line": "static unsigned int nsvg__parseColorName(const char* str)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1491, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__parseColor", + "result_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int" + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1493, + "column": 1, + "source_line": "static unsigned int nsvg__parseColor(const char* str)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1493, + "column": 1, + "source_line": "static unsigned int nsvg__parseColor(const char* str)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1503, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__parseOpacity", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1505, + "column": 1, + "source_line": "static float nsvg__parseOpacity(const char* str)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1505, + "column": 1, + "source_line": "static float nsvg__parseOpacity(const char* str)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1511, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__parseMiterLimit", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1513, + "column": 1, + "source_line": "static float nsvg__parseMiterLimit(const char* str)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1513, + "column": 1, + "source_line": "static float nsvg__parseMiterLimit(const char* str)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1518, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__parseUnits", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "units", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * units", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * units", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1520, + "column": 1, + "source_line": "static int nsvg__parseUnits(const char* units)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1520, + "column": 1, + "source_line": "static int nsvg__parseUnits(const char* units)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1541, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__isCoordinate", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1543, + "column": 1, + "source_line": "static int nsvg__isCoordinate(const char* s)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1543, + "column": 1, + "source_line": "static int nsvg__isCoordinate(const char* s)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1550, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__parseCoordinateRaw", + "result_type": { + "reference": "NSVGcoordinate" + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1552, + "column": 1, + "source_line": "static NSVGcoordinate nsvg__parseCoordinateRaw(const char* str)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1552, + "column": 1, + "source_line": "static NSVGcoordinate nsvg__parseCoordinateRaw(const char* str)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1559, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__coord", + "result_type": { + "reference": "NSVGcoordinate" + }, + "parameters": [ + { + "name": "v", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float v" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float v" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "units", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int units" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int units" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1561, + "column": 1, + "source_line": "static NSVGcoordinate nsvg__coord(float v, int units)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1561, + "column": 1, + "source_line": "static NSVGcoordinate nsvg__coord(float v, int units)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1565, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__parseCoordinate", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "orig", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float orig" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float orig" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "length", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float length" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float length" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1567, + "column": 1, + "source_line": "static float nsvg__parseCoordinate(NSVGparser* p, const char* str, float orig, float length)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1567, + "column": 1, + "source_line": "static float nsvg__parseCoordinate(NSVGparser* p, const char* str, float orig, float length)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1571, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__parseTransformArgs", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "args", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * args", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * args", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "maxNa", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int maxNa" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int maxNa" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "na", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int * na", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int * na", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1573, + "column": 1, + "source_line": "static int nsvg__parseTransformArgs(const char* str, float* args, int maxNa, int* na)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1573, + "column": 1, + "source_line": "static int nsvg__parseTransformArgs(const char* str, float* args, int maxNa, int* na)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1599, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__parseMatrix", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "xform", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * xform", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * xform", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1602, + "column": 1, + "source_line": "static int nsvg__parseMatrix(float* xform, const char* str)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1602, + "column": 1, + "source_line": "static int nsvg__parseMatrix(float* xform, const char* str)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1610, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__parseTranslate", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "xform", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * xform", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * xform", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1612, + "column": 1, + "source_line": "static int nsvg__parseTranslate(float* xform, const char* str)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1612, + "column": 1, + "source_line": "static int nsvg__parseTranslate(float* xform, const char* str)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1623, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__parseScale", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "xform", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * xform", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * xform", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1625, + "column": 1, + "source_line": "static int nsvg__parseScale(float* xform, const char* str)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1625, + "column": 1, + "source_line": "static int nsvg__parseScale(float* xform, const char* str)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1635, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__parseSkewX", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "xform", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * xform", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * xform", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1637, + "column": 1, + "source_line": "static int nsvg__parseSkewX(float* xform, const char* str)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1637, + "column": 1, + "source_line": "static int nsvg__parseSkewX(float* xform, const char* str)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1646, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__parseSkewY", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "xform", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * xform", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * xform", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1648, + "column": 1, + "source_line": "static int nsvg__parseSkewY(float* xform, const char* str)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1648, + "column": 1, + "source_line": "static int nsvg__parseSkewY(float* xform, const char* str)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1657, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__parseRotate", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "xform", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * xform", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * xform", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1659, + "column": 1, + "source_line": "static int nsvg__parseRotate(float* xform, const char* str)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1659, + "column": 1, + "source_line": "static int nsvg__parseRotate(float* xform, const char* str)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1686, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__parseTransform", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "xform", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * xform", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * xform", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1688, + "column": 1, + "source_line": "static void nsvg__parseTransform(float* xform, const char* str)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1688, + "column": 1, + "source_line": "static void nsvg__parseTransform(float* xform, const char* str)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1720, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__parseUrl", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "id", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char * id", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char * id", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1722, + "column": 1, + "source_line": "static void nsvg__parseUrl(char* id, const char* str)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1722, + "column": 1, + "source_line": "static void nsvg__parseUrl(char* id, const char* str)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1733, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__parseLineCap", + "result_type": { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1735, + "column": 1, + "source_line": "static char nsvg__parseLineCap(const char* str)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1735, + "column": 1, + "source_line": "static char nsvg__parseLineCap(const char* str)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1745, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__parseLineJoin", + "result_type": { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1747, + "column": 1, + "source_line": "static char nsvg__parseLineJoin(const char* str)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1747, + "column": 1, + "source_line": "static char nsvg__parseLineJoin(const char* str)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1757, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__parseFillRule", + "result_type": { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1759, + "column": 1, + "source_line": "static char nsvg__parseFillRule(const char* str)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1759, + "column": 1, + "source_line": "static char nsvg__parseFillRule(const char* str)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1767, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__parsePaintOrder", + "result_type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1769, + "column": 1, + "source_line": "static unsigned char nsvg__parsePaintOrder(const char* str)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1769, + "column": 1, + "source_line": "static unsigned char nsvg__parsePaintOrder(const char* str)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1785, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__getNextDashItem", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "it", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char * it", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char * it", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1787, + "column": 1, + "source_line": "static const char* nsvg__getNextDashItem(const char* s, char* it)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1787, + "column": 1, + "source_line": "static const char* nsvg__getNextDashItem(const char* s, char* it)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1801, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__parseStrokeDashArray", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "strokeDashArray", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * strokeDashArray", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * strokeDashArray", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1803, + "column": 1, + "source_line": "static int nsvg__parseStrokeDashArray(NSVGparser* p, const char* str, float* strokeDashArray)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1803, + "column": 1, + "source_line": "static int nsvg__parseStrokeDashArray(NSVGparser* p, const char* str, float* strokeDashArray)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1827, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__parseStyle", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1969, + "column": 1, + "source_line": "static void nsvg__parseStyle(NSVGparser* p, const char* str)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1969, + "column": 1, + "source_line": "static void nsvg__parseStyle(NSVGparser* p, const char* str)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1988, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "nanosvg/nanosvg.h", + "line": 1829, + "column": 1, + "source_line": "static void nsvg__parseStyle(NSVGparser* p, const char* str);" + } + ] + }, + { + "name": "nsvg__applyClassStyles", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "value", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * value", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * value", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1833, + "column": 1, + "source_line": "static void nsvg__applyClassStyles(NSVGparser* p, const char* value)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1833, + "column": 1, + "source_line": "static void nsvg__applyClassStyles(NSVGparser* p, const char* value)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1857, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__parseAttr", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "name", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * name", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * name", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "value", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * value", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * value", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1859, + "column": 1, + "source_line": "static int nsvg__parseAttr(NSVGparser* p, const char* name, const char* value)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1859, + "column": 1, + "source_line": "static int nsvg__parseAttr(NSVGparser* p, const char* name, const char* value)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1935, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__parseNameValue", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "start", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * start", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * start", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "end", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * end", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * end", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1937, + "column": 1, + "source_line": "static int nsvg__parseNameValue(NSVGparser* p, const char* start, const char* end)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1937, + "column": 1, + "source_line": "static int nsvg__parseNameValue(NSVGparser* p, const char* start, const char* end)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1967, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__parseAttribs", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "attr", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char ** attr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char ** attr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1990, + "column": 1, + "source_line": "static void nsvg__parseAttribs(NSVGparser* p, const char** attr)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1990, + "column": 1, + "source_line": "static void nsvg__parseAttribs(NSVGparser* p, const char** attr)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 2000, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__getArgsPerElement", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "cmd", + "type": { + "model": "CChar", + "qualifiers": [], + "source_text": "char cmd" + }, + "declared_type": { + "model": "CChar", + "qualifiers": [], + "source_text": "char cmd" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 2002, + "column": 1, + "source_line": "static int nsvg__getArgsPerElement(char cmd)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 2002, + "column": 1, + "source_line": "static int nsvg__getArgsPerElement(char cmd)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 2033, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__pathMoveTo", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cpx", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpx", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpx", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cpy", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpy", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpy", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "args", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * args", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * args", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "rel", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int rel" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int rel" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 2035, + "column": 1, + "source_line": "static void nsvg__pathMoveTo(NSVGparser* p, float* cpx, float* cpy, float* args, int rel)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 2035, + "column": 1, + "source_line": "static void nsvg__pathMoveTo(NSVGparser* p, float* cpx, float* cpy, float* args, int rel)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 2045, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__pathLineTo", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cpx", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpx", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpx", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cpy", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpy", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpy", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "args", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * args", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * args", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "rel", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int rel" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int rel" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 2047, + "column": 1, + "source_line": "static void nsvg__pathLineTo(NSVGparser* p, float* cpx, float* cpy, float* args, int rel)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 2047, + "column": 1, + "source_line": "static void nsvg__pathLineTo(NSVGparser* p, float* cpx, float* cpy, float* args, int rel)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 2057, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__pathHLineTo", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cpx", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpx", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpx", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cpy", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpy", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpy", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "args", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * args", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * args", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "rel", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int rel" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int rel" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 2059, + "column": 1, + "source_line": "static void nsvg__pathHLineTo(NSVGparser* p, float* cpx, float* cpy, float* args, int rel)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 2059, + "column": 1, + "source_line": "static void nsvg__pathHLineTo(NSVGparser* p, float* cpx, float* cpy, float* args, int rel)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 2066, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__pathVLineTo", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cpx", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpx", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpx", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cpy", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpy", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpy", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "args", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * args", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * args", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "rel", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int rel" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int rel" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 2068, + "column": 1, + "source_line": "static void nsvg__pathVLineTo(NSVGparser* p, float* cpx, float* cpy, float* args, int rel)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 2068, + "column": 1, + "source_line": "static void nsvg__pathVLineTo(NSVGparser* p, float* cpx, float* cpy, float* args, int rel)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 2075, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__pathCubicBezTo", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cpx", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpx", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpx", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cpy", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpy", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpy", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cpx2", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpx2", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpx2", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cpy2", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpy2", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpy2", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "args", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * args", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * args", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "rel", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int rel" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int rel" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 2077, + "column": 1, + "source_line": "static void nsvg__pathCubicBezTo(NSVGparser* p, float* cpx, float* cpy," + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 2077, + "column": 1, + "source_line": "static void nsvg__pathCubicBezTo(NSVGparser* p, float* cpx, float* cpy," + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 2104, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__pathCubicBezShortTo", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cpx", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpx", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpx", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cpy", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpy", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpy", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cpx2", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpx2", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpx2", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cpy2", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpy2", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpy2", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "args", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * args", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * args", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "rel", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int rel" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int rel" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 2106, + "column": 1, + "source_line": "static void nsvg__pathCubicBezShortTo(NSVGparser* p, float* cpx, float* cpy," + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 2106, + "column": 1, + "source_line": "static void nsvg__pathCubicBezShortTo(NSVGparser* p, float* cpx, float* cpy," + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 2134, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__pathQuadBezTo", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cpx", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpx", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpx", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cpy", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpy", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpy", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cpx2", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpx2", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpx2", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cpy2", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpy2", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpy2", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "args", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * args", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * args", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "rel", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int rel" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int rel" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 2136, + "column": 1, + "source_line": "static void nsvg__pathQuadBezTo(NSVGparser* p, float* cpx, float* cpy," + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 2136, + "column": 1, + "source_line": "static void nsvg__pathQuadBezTo(NSVGparser* p, float* cpx, float* cpy," + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 2168, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__pathQuadBezShortTo", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cpx", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpx", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpx", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cpy", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpy", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpy", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cpx2", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpx2", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpx2", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cpy2", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpy2", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpy2", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "args", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * args", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * args", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "rel", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int rel" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int rel" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 2170, + "column": 1, + "source_line": "static void nsvg__pathQuadBezShortTo(NSVGparser* p, float* cpx, float* cpy," + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 2170, + "column": 1, + "source_line": "static void nsvg__pathQuadBezShortTo(NSVGparser* p, float* cpx, float* cpy," + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 2201, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__sqr", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 2203, + "column": 1, + "source_line": "static float nsvg__sqr(float x) { return x*x; }" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 2203, + "column": 1, + "source_line": "static float nsvg__sqr(float x) { return x*x; }" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 2203, + "column": 47, + "source_line": "static float nsvg__sqr(float x) { return x*x; }" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__vmag", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 2204, + "column": 1, + "source_line": "static float nsvg__vmag(float x, float y) { return sqrtf(x*x + y*y); }" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 2204, + "column": 1, + "source_line": "static float nsvg__vmag(float x, float y) { return sqrtf(x*x + y*y); }" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 2204, + "column": 70, + "source_line": "static float nsvg__vmag(float x, float y) { return sqrtf(x*x + y*y); }" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__vecrat", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "ux", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float ux" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float ux" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "uy", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float uy" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float uy" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "vx", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float vx" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float vx" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "vy", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float vy" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float vy" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 2206, + "column": 1, + "source_line": "static float nsvg__vecrat(float ux, float uy, float vx, float vy)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 2206, + "column": 1, + "source_line": "static float nsvg__vecrat(float ux, float uy, float vx, float vy)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 2209, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__vecang", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "ux", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float ux" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float ux" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "uy", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float uy" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float uy" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "vx", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float vx" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float vx" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "vy", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float vy" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float vy" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 2211, + "column": 1, + "source_line": "static float nsvg__vecang(float ux, float uy, float vx, float vy)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 2211, + "column": 1, + "source_line": "static float nsvg__vecang(float ux, float uy, float vx, float vy)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 2217, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__pathArcTo", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cpx", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpx", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpx", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cpy", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpy", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpy", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "args", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * args", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * args", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "rel", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int rel" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int rel" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 2219, + "column": 1, + "source_line": "static void nsvg__pathArcTo(NSVGparser* p, float* cpx, float* cpy, float* args, int rel)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 2219, + "column": 1, + "source_line": "static void nsvg__pathArcTo(NSVGparser* p, float* cpx, float* cpy, float* args, int rel)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 2338, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__parsePath", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "attr", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char ** attr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char ** attr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 2340, + "column": 1, + "source_line": "static void nsvg__parsePath(NSVGparser* p, const char** attr)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 2340, + "column": 1, + "source_line": "static void nsvg__parsePath(NSVGparser* p, const char** attr)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 2486, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__parseRect", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "attr", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char ** attr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char ** attr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 2488, + "column": 1, + "source_line": "static void nsvg__parseRect(NSVGparser* p, const char** attr)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 2488, + "column": 1, + "source_line": "static void nsvg__parseRect(NSVGparser* p, const char** attr)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 2541, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__parseCircle", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "attr", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char ** attr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char ** attr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 2543, + "column": 1, + "source_line": "static void nsvg__parseCircle(NSVGparser* p, const char** attr)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 2543, + "column": 1, + "source_line": "static void nsvg__parseCircle(NSVGparser* p, const char** attr)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 2571, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__parseEllipse", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "attr", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char ** attr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char ** attr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 2573, + "column": 1, + "source_line": "static void nsvg__parseEllipse(NSVGparser* p, const char** attr)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 2573, + "column": 1, + "source_line": "static void nsvg__parseEllipse(NSVGparser* p, const char** attr)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 2604, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__parseLine", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "attr", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char ** attr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char ** attr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 2606, + "column": 1, + "source_line": "static void nsvg__parseLine(NSVGparser* p, const char** attr)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 2606, + "column": 1, + "source_line": "static void nsvg__parseLine(NSVGparser* p, const char** attr)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 2631, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__parsePoly", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "attr", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char ** attr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char ** attr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "closeFlag", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int closeFlag" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int closeFlag" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 2633, + "column": 1, + "source_line": "static void nsvg__parsePoly(NSVGparser* p, const char** attr, int closeFlag)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 2633, + "column": 1, + "source_line": "static void nsvg__parsePoly(NSVGparser* p, const char** attr, int closeFlag)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 2667, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__parseSVG", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "attr", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char ** attr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char ** attr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 2669, + "column": 1, + "source_line": "static void nsvg__parseSVG(NSVGparser* p, const char** attr)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 2669, + "column": 1, + "source_line": "static void nsvg__parseSVG(NSVGparser* p, const char** attr)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 2722, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__parseGradient", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "attr", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char ** attr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char ** attr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "type", + "type": { + "model": "CSignedChar", + "qualifiers": [], + "source_text": "signed char type" + }, + "declared_type": { + "model": "CSignedChar", + "qualifiers": [], + "source_text": "signed char type" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 2724, + "column": 1, + "source_line": "static void nsvg__parseGradient(NSVGparser* p, const char** attr, signed char type)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 2724, + "column": 1, + "source_line": "static void nsvg__parseGradient(NSVGparser* p, const char** attr, signed char type)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 2792, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__parseGradientStop", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "attr", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char ** attr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char ** attr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 2794, + "column": 1, + "source_line": "static void nsvg__parseGradientStop(NSVGparser* p, const char** attr)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 2794, + "column": 1, + "source_line": "static void nsvg__parseGradientStop(NSVGparser* p, const char** attr)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 2834, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__startElement", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "ud", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * ud", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * ud", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "el", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * el", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * el", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "attr", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char ** attr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char ** attr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 2836, + "column": 1, + "source_line": "static void nsvg__startElement(void* ud, const char* el, const char** attr)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 2836, + "column": 1, + "source_line": "static void nsvg__startElement(void* ud, const char* el, const char** attr)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 2900, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__endElement", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "ud", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * ud", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * ud", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "el", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * el", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * el", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 2902, + "column": 1, + "source_line": "static void nsvg__endElement(void* ud, const char* el)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 2902, + "column": 1, + "source_line": "static void nsvg__endElement(void* ud, const char* el)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 2915, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__strndup", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t n", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 2917, + "column": 1, + "source_line": "static char *nsvg__strndup(const char *s, size_t n)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 2917, + "column": 1, + "source_line": "static char *nsvg__strndup(const char *s, size_t n)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 2926, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__content", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "ud", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * ud", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * ud", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 2928, + "column": 1, + "source_line": "static void nsvg__content(void* ud, const char* s)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 2928, + "column": 1, + "source_line": "static void nsvg__content(void* ud, const char* s)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 3010, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__imageBounds", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "bounds", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * bounds", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * bounds", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 3012, + "column": 1, + "source_line": "static void nsvg__imageBounds(NSVGparser* p, float* bounds)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 3012, + "column": 1, + "source_line": "static void nsvg__imageBounds(NSVGparser* p, float* bounds)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 3030, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__viewAlign", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "content", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float content" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float content" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "container", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float container" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float container" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "type", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int type" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int type" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 3032, + "column": 1, + "source_line": "static float nsvg__viewAlign(float content, float container, int type)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 3032, + "column": 1, + "source_line": "static float nsvg__viewAlign(float content, float container, int type)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 3040, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__scaleGradient", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "grad", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGgradient * grad", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "NSVGgradient", + "name": "NSVGgradient", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGgradient * grad", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGgradient" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "tx", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float tx" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float tx" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ty", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float ty" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float ty" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "sx", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float sx" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float sx" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "sy", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float sy" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float sy" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 3042, + "column": 1, + "source_line": "static void nsvg__scaleGradient(NSVGgradient* grad, float tx, float ty, float sx, float sy)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 3042, + "column": 1, + "source_line": "static void nsvg__scaleGradient(NSVGgradient* grad, float tx, float ty, float sx, float sy)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 3050, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__scaleToViewbox", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "units", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * units", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * units", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 3052, + "column": 1, + "source_line": "static void nsvg__scaleToViewbox(NSVGparser* p, const char* units)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 3052, + "column": 1, + "source_line": "static void nsvg__scaleToViewbox(NSVGparser* p, const char* units)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 3141, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__createGradients", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 3143, + "column": 1, + "source_line": "static void nsvg__createGradients(NSVGparser* p)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 3143, + "column": 1, + "source_line": "static void nsvg__createGradients(NSVGparser* p)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 3171, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvgParse", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGimage", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "NSVGimage", + "name": "NSVGimage", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "parameters": [ + { + "name": "input", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char * input", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char * input", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "units", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * units", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * units", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dpi", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dpi" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dpi" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 3173, + "column": 1, + "source_line": "NSVGimage* nsvgParse(char* input, const char* units, float dpi)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 3173, + "column": 1, + "source_line": "NSVGimage* nsvgParse(char* input, const char* units, float dpi)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 3198, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvgParseFromFile", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGimage", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "NSVGimage", + "name": "NSVGimage", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "parameters": [ + { + "name": "filename", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * filename", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * filename", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "units", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * units", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * units", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dpi", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dpi" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dpi" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 3200, + "column": 1, + "source_line": "NSVGimage* nsvgParseFromFile(const char* filename, const char* units, float dpi)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 3200, + "column": 1, + "source_line": "NSVGimage* nsvgParseFromFile(const char* filename, const char* units, float dpi)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 3227, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvgDuplicatePath", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpath", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "NSVGpath", + "name": "NSVGpath", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpath * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "NSVGpath", + "name": "NSVGpath", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpath * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpath" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 3229, + "column": 1, + "source_line": "NSVGpath* nsvgDuplicatePath(NSVGpath* p)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 3229, + "column": 1, + "source_line": "NSVGpath* nsvgDuplicatePath(NSVGpath* p)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 3257, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvgDelete", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "image", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGimage * image", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "NSVGimage", + "name": "NSVGimage", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGimage * image", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGimage" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 3259, + "column": 1, + "source_line": "void nsvgDelete(NSVGimage* image)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 3259, + "column": 1, + "source_line": "void nsvgDelete(NSVGimage* image)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 3273, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + } + ], + "structs": [ + { + "reference": "struct NSVGcoordinate" + }, + { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": "NSVGlinearData", + "members": [ + { + "name": "x1", + "type": { + "reference": "NSVGcoordinate" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 398, + "column": 2, + "source_line": "\tNSVGcoordinate x1, y1, x2, y2;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "y1", + "type": { + "reference": "NSVGcoordinate" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 398, + "column": 2, + "source_line": "\tNSVGcoordinate x1, y1, x2, y2;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "x2", + "type": { + "reference": "NSVGcoordinate" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 398, + "column": 2, + "source_line": "\tNSVGcoordinate x1, y1, x2, y2;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "y2", + "type": { + "reference": "NSVGcoordinate" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 398, + "column": 2, + "source_line": "\tNSVGcoordinate x1, y1, x2, y2;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": null, + "is_incomplete": false, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 397, + "column": 1, + "source_line": "typedef struct NSVGlinearData {" + } + }, + { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": "NSVGradialData", + "members": [ + { + "name": "cx", + "type": { + "reference": "NSVGcoordinate" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 402, + "column": 2, + "source_line": "\tNSVGcoordinate cx, cy, r, fx, fy;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "cy", + "type": { + "reference": "NSVGcoordinate" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 402, + "column": 2, + "source_line": "\tNSVGcoordinate cx, cy, r, fx, fy;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "r", + "type": { + "reference": "NSVGcoordinate" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 402, + "column": 2, + "source_line": "\tNSVGcoordinate cx, cy, r, fx, fy;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "fx", + "type": { + "reference": "NSVGcoordinate" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 402, + "column": 2, + "source_line": "\tNSVGcoordinate cx, cy, r, fx, fy;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "fy", + "type": { + "reference": "NSVGcoordinate" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 402, + "column": 2, + "source_line": "\tNSVGcoordinate cx, cy, r, fx, fy;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": null, + "is_incomplete": false, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 401, + "column": 1, + "source_line": "typedef struct NSVGradialData {" + } + }, + { + "reference": "struct NSVGgradientData" + }, + { + "reference": "struct NSVGattrib" + }, + { + "reference": "struct NSVGstyleDeclaration" + }, + { + "reference": "struct NSVGparser" + }, + { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": "NSVGNamedColor", + "members": [ + { + "name": "name", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * name", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1322, + "column": 2, + "source_line": "\tconst char* name;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "color", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int color" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1323, + "column": 2, + "source_line": "\tunsigned int color;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": null, + "is_incomplete": false, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1321, + "column": 1, + "source_line": "typedef struct NSVGNamedColor {" + } + } + ], + "unions": [], + "enums": [ + { + "model": "CEnum", + "qualifiers": [], + "source_text": "", + "name": "NSVGgradientUnits", + "constants": [ + { + "name": "NSVG_USER_SPACE", + "value": "0", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 371, + "column": 1, + "source_line": "enum NSVGgradientUnits {" + } + }, + { + "name": "NSVG_OBJECT_SPACE", + "value": "1", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 371, + "column": 1, + "source_line": "enum NSVGgradientUnits {" + } + } + ], + "anonymous_id": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 371, + "column": 1, + "source_line": "enum NSVGgradientUnits {" + } + }, + { + "model": "CEnum", + "qualifiers": [], + "source_text": "", + "name": "NSVGunits", + "constants": [ + { + "name": "NSVG_UNITS_USER", + "value": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 379, + "column": 1, + "source_line": "enum NSVGunits {" + } + }, + { + "name": "NSVG_UNITS_PX", + "value": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 379, + "column": 1, + "source_line": "enum NSVGunits {" + } + }, + { + "name": "NSVG_UNITS_PT", + "value": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 379, + "column": 1, + "source_line": "enum NSVGunits {" + } + }, + { + "name": "NSVG_UNITS_PC", + "value": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 379, + "column": 1, + "source_line": "enum NSVGunits {" + } + }, + { + "name": "NSVG_UNITS_MM", + "value": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 379, + "column": 1, + "source_line": "enum NSVGunits {" + } + }, + { + "name": "NSVG_UNITS_CM", + "value": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 379, + "column": 1, + "source_line": "enum NSVGunits {" + } + }, + { + "name": "NSVG_UNITS_IN", + "value": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 379, + "column": 1, + "source_line": "enum NSVGunits {" + } + }, + { + "name": "NSVG_UNITS_PERCENT", + "value": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 379, + "column": 1, + "source_line": "enum NSVGunits {" + } + }, + { + "name": "NSVG_UNITS_EM", + "value": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 379, + "column": 1, + "source_line": "enum NSVGunits {" + } + }, + { + "name": "NSVG_UNITS_EX", + "value": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 379, + "column": 1, + "source_line": "enum NSVGunits {" + } + } + ], + "anonymous_id": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 379, + "column": 1, + "source_line": "enum NSVGunits {" + } + } + ], + "typedefs": [ + { + "reference": "NSVGcoordinate" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "NSVGlinearData", + "name": "NSVGlinearData", + "type": { + "reference": "struct NSVGlinearData" + }, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 397, + "column": 1, + "source_line": "typedef struct NSVGlinearData {" + }, + "declaration_locations": [] + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "NSVGradialData", + "name": "NSVGradialData", + "type": { + "reference": "struct NSVGradialData" + }, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 401, + "column": 1, + "source_line": "typedef struct NSVGradialData {" + }, + "declaration_locations": [] + }, + { + "reference": "NSVGgradientData" + }, + { + "reference": "NSVGattrib" + }, + { + "reference": "NSVGstyleDeclaration" + }, + { + "reference": "NSVGparser" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "NSVGNamedColor", + "name": "NSVGNamedColor", + "type": { + "reference": "struct NSVGNamedColor" + }, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1321, + "column": 1, + "source_line": "typedef struct NSVGNamedColor {" + }, + "declaration_locations": [] + } + ], + "variables": [], + "macros": [ + { + "name": "NANOSVG_H", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 30, + "column": 1, + "source_line": "#define NANOSVG_H" + } + }, + { + "name": "NSVG_PI", + "value": "(3.14159265358979323846264338327f)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 202, + "column": 1, + "source_line": "#define NSVG_PI (3.14159265358979323846264338327f)" + } + }, + { + "name": "NSVG_KAPPA90", + "value": "(0.5522847493f)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 203, + "column": 1, + "source_line": "#define NSVG_KAPPA90 (0.5522847493f)\t// Length proportional to radius of a cubic bezier handle for 90deg arcs." + } + }, + { + "name": "NSVG_ALIGN_MIN", + "value": "0", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 205, + "column": 1, + "source_line": "#define NSVG_ALIGN_MIN 0" + } + }, + { + "name": "NSVG_ALIGN_MID", + "value": "1", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 206, + "column": 1, + "source_line": "#define NSVG_ALIGN_MID 1" + } + }, + { + "name": "NSVG_ALIGN_MAX", + "value": "2", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 207, + "column": 1, + "source_line": "#define NSVG_ALIGN_MAX 2" + } + }, + { + "name": "NSVG_ALIGN_NONE", + "value": "0", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 208, + "column": 1, + "source_line": "#define NSVG_ALIGN_NONE 0" + } + }, + { + "name": "NSVG_ALIGN_MEET", + "value": "1", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 209, + "column": 1, + "source_line": "#define NSVG_ALIGN_MEET 1" + } + }, + { + "name": "NSVG_ALIGN_SLICE", + "value": "2", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 210, + "column": 1, + "source_line": "#define NSVG_ALIGN_SLICE 2" + } + }, + { + "name": "NSVG_NOTUSED", + "value": "do { (void)(1 ? (void)0 : ( (void)(v) ) ); } while(0)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 212, + "column": 1, + "source_line": "#define NSVG_NOTUSED(v) do { (void)(1 ? (void)0 : ( (void)(v) ) ); } while(0)" + } + }, + { + "name": "NSVG_RGB", + "value": "(((unsigned int)r) | ((unsigned int)g << 8) | ((unsigned int)b << 16))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 213, + "column": 1, + "source_line": "#define NSVG_RGB(r, g, b) (((unsigned int)r) | ((unsigned int)g << 8) | ((unsigned int)b << 16))" + } + }, + { + "name": "NSVG_INLINE", + "value": "inline", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 219, + "column": 2, + "source_line": "\t#define NSVG_INLINE inline" + } + }, + { + "name": "NSVG_INLINE", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 221, + "column": 2, + "source_line": "\t#define NSVG_INLINE" + } + }, + { + "name": "NSVG_INLINE", + "value": "inline", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 224, + "column": 2, + "source_line": "\t#define NSVG_INLINE inline" + } + }, + { + "name": "NSVG_XML_TAG", + "value": "1", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 244, + "column": 1, + "source_line": "#define NSVG_XML_TAG 1" + } + }, + { + "name": "NSVG_XML_CONTENT", + "value": "2", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 245, + "column": 1, + "source_line": "#define NSVG_XML_CONTENT 2" + } + }, + { + "name": "NSVG_XML_MAX_ATTRIBS", + "value": "256", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 246, + "column": 1, + "source_line": "#define NSVG_XML_MAX_ATTRIBS 256" + } + }, + { + "name": "NSVG_MAX_ATTR", + "value": "128", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 369, + "column": 1, + "source_line": "#define NSVG_MAX_ATTR 128" + } + }, + { + "name": "NSVG_MAX_DASHES", + "value": "8", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 376, + "column": 1, + "source_line": "#define NSVG_MAX_DASHES 8" + } + }, + { + "name": "NSVG_MAX_CLASSES", + "value": "32", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 377, + "column": 1, + "source_line": "#define NSVG_MAX_CLASSES 32" + } + }, + { + "name": "NSVG_EPSILON", + "value": "(1e-12)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 570, + "column": 1, + "source_line": "#define NSVG_EPSILON (1e-12)" + } + } + ], + "includes": [ + { + "target": "string.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 197, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "stdlib.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 198, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "stdio.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 199, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "math.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 200, + "column": 1, + "source_line": "#include " + } + } + ], + "raw_directives": [ + { + "directive": "ifndef", + "argument": "NANOSVG_H", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 29, + "column": 1, + "source_line": "#ifndef NANOSVG_H" + } + }, + { + "directive": "ifndef", + "argument": "NANOSVG_CPLUSPLUS", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 32, + "column": 1, + "source_line": "#ifndef NANOSVG_CPLUSPLUS" + } + }, + { + "directive": "ifdef", + "argument": "__cplusplus", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 33, + "column": 1, + "source_line": "#ifdef __cplusplus" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 35, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 36, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "NANOSVG_CPLUSPLUS", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 189, + "column": 1, + "source_line": "#ifndef NANOSVG_CPLUSPLUS" + } + }, + { + "directive": "ifdef", + "argument": "__cplusplus", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 190, + "column": 1, + "source_line": "#ifdef __cplusplus" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 192, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 193, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "NANOSVG_IMPLEMENTATION", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 195, + "column": 1, + "source_line": "#ifdef NANOSVG_IMPLEMENTATION" + } + }, + { + "directive": "ifdef", + "argument": "_MSC_VER", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 215, + "column": 1, + "source_line": "#ifdef _MSC_VER" + } + }, + { + "directive": "pragma", + "argument": "warning (disable: 4996)", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 216, + "column": 2, + "source_line": "\t#pragma warning (disable: 4996) // Switch off security warnings" + } + }, + { + "directive": "pragma", + "argument": "warning (disable: 4100)", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 217, + "column": 2, + "source_line": "\t#pragma warning (disable: 4100) // Switch off unreferenced formal parameter warnings" + } + }, + { + "directive": "ifdef", + "argument": "__cplusplus", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 218, + "column": 2, + "source_line": "\t#ifdef __cplusplus" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 220, + "column": 2, + "source_line": "\t#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 222, + "column": 2, + "source_line": "\t#endif" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 223, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 225, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "NANOSVG_ALL_COLOR_KEYWORDS", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1339, + "column": 1, + "source_line": "#ifdef NANOSVG_ALL_COLOR_KEYWORDS" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1477, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 3275, + "column": 1, + "source_line": "#endif // NANOSVG_IMPLEMENTATION" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 3277, + "column": 1, + "source_line": "#endif // NANOSVG_H" + } + } + ], + "macro_dependencies": [ + { + "name": "NSVG_INLINE", + "context": "declaration", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 238, + "column": 1, + "source_line": "static NSVG_INLINE float nsvg__minf(float a, float b) { return a < b ? a : b; }" + }, + "source_text": "static NSVG_INLINE float nsvg__minf(float a, float b)" + }, + { + "name": "NSVG_INLINE", + "context": "declaration", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 239, + "column": 1, + "source_line": "static NSVG_INLINE float nsvg__maxf(float a, float b) { return a > b ? a : b; }" + }, + "source_text": "static NSVG_INLINE float nsvg__maxf(float a, float b)" + } + ], + "diagnostics": [ + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'NSVG_NOTUSED' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "nanosvg/nanosvg.h", + "line": 212, + "column": 1, + "source_line": "#define NSVG_NOTUSED(v) do { (void)(1 ? (void)0 : ( (void)(v) ) ); } while(0)" + }, + "unit_kind": "macro", + "unit_name": "NSVG_NOTUSED" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'NSVG_RGB' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "nanosvg/nanosvg.h", + "line": 213, + "column": 1, + "source_line": "#define NSVG_RGB(r, g, b) (((unsigned int)r) | ((unsigned int)g << 8) | ((unsigned int)b << 16))" + }, + "unit_kind": "macro", + "unit_name": "NSVG_RGB" + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '\"C\"'.", + "severity": "warning", + "location": { + "filename": "nanosvg/nanosvg.h", + "line": 34, + "column": 1, + "source_line": "extern \"C\" {" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'NSVG_INLINE'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "nanosvg/nanosvg.h", + "line": 238, + "column": 1, + "source_line": "static NSVG_INLINE float nsvg__minf(float a, float b) { return a < b ? a : b; }" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "NSVG_INLINE" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'NSVG_INLINE'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "nanosvg/nanosvg.h", + "line": 239, + "column": 1, + "source_line": "static NSVG_INLINE float nsvg__maxf(float a, float b) { return a > b ? a : b; }" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "NSVG_INLINE" + }, + { + "code": "C_UNSUPPORTED_FIELD_DECLARATION", + "message": "Nested aggregate field definitions are not supported yet.", + "severity": "warning", + "location": { + "filename": "nanosvg/nanosvg.h", + "line": 410, + "column": 2, + "source_line": "\tunion {" + }, + "unit_kind": "struct_field", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "nanosvg/nanosvg.h", + "line": 1326, + "column": 1, + "source_line": "NSVGNamedColor nsvg__colors[] = {" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + } + ] + }, + "nanosvg/nanosvgrast.h": { + "filename": "nanosvg/nanosvgrast.h", + "language": "c", + "parser_status": "partial", + "preprocessing": "raw", + "functions": [ + { + "name": "nsvgCreateRasterizer", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "NSVGrasterizer", + "name": "NSVGrasterizer", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "parameters": [], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 153, + "column": 1, + "source_line": "NSVGrasterizer* nsvgCreateRasterizer(void)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 153, + "column": 1, + "source_line": "NSVGrasterizer* nsvgCreateRasterizer(void)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 167, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvgDeleteRasterizer", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "r", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "NSVGrasterizer", + "name": "NSVGrasterizer", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 169, + "column": 1, + "source_line": "void nsvgDeleteRasterizer(NSVGrasterizer* r)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 169, + "column": 1, + "source_line": "void nsvgDeleteRasterizer(NSVGrasterizer* r)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 188, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__nextPage", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGmemPage", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "NSVGmemPage", + "name": "NSVGmemPage", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": "NSVGmemPage", + "members": [ + { + "name": "mem", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char mem[NSVG__MEMPAGE_SIZE]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "NSVG__MEMPAGE_SIZE", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 111, + "column": 2, + "source_line": "\tunsigned char mem[NSVG__MEMPAGE_SIZE];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "size", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int size" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 112, + "column": 2, + "source_line": "\tint size;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "next", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "struct NSVGmemPage * next", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "struct NSVGmemPage" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 113, + "column": 2, + "source_line": "\tstruct NSVGmemPage* next;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": null, + "is_incomplete": false, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 110, + "column": 1, + "source_line": "typedef struct NSVGmemPage {" + } + }, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 110, + "column": 1, + "source_line": "typedef struct NSVGmemPage {" + }, + "declaration_locations": [] + } + ] + }, + "parameters": [ + { + "name": "r", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "NSVGrasterizer", + "name": "NSVGrasterizer", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cur", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGmemPage * cur", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGmemPage" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGmemPage * cur", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGmemPage" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 190, + "column": 1, + "source_line": "static NSVGmemPage* nsvg__nextPage(NSVGrasterizer* r, NSVGmemPage* cur)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 190, + "column": 1, + "source_line": "static NSVGmemPage* nsvg__nextPage(NSVGrasterizer* r, NSVGmemPage* cur)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 211, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__resetPool", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "r", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "NSVGrasterizer", + "name": "NSVGrasterizer", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 213, + "column": 1, + "source_line": "static void nsvg__resetPool(NSVGrasterizer* r)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 213, + "column": 1, + "source_line": "static void nsvg__resetPool(NSVGrasterizer* r)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 221, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__alloc", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "parameters": [ + { + "name": "r", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "NSVGrasterizer", + "name": "NSVGrasterizer", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "size", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int size" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int size" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 223, + "column": 1, + "source_line": "static unsigned char* nsvg__alloc(NSVGrasterizer* r, int size)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 223, + "column": 1, + "source_line": "static unsigned char* nsvg__alloc(NSVGrasterizer* r, int size)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 233, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__ptEquals", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "x1", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x1" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y1", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y1" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x2", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x2" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x2" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y2", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y2" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y2" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "tol", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float tol" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float tol" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 235, + "column": 1, + "source_line": "static int nsvg__ptEquals(float x1, float y1, float x2, float y2, float tol)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 235, + "column": 1, + "source_line": "static int nsvg__ptEquals(float x1, float y1, float x2, float y2, float tol)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 240, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__addPathPoint", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "r", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "NSVGrasterizer", + "name": "NSVGrasterizer", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "flags", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int flags" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int flags" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 242, + "column": 1, + "source_line": "static void nsvg__addPathPoint(NSVGrasterizer* r, float x, float y, int flags)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 242, + "column": 1, + "source_line": "static void nsvg__addPathPoint(NSVGrasterizer* r, float x, float y, int flags)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 265, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__appendPathPoint", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "r", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "NSVGrasterizer", + "name": "NSVGrasterizer", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "pt", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "NSVGpoint", + "name": "NSVGpoint", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": "NSVGpoint", + "members": [ + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 96, + "column": 2, + "source_line": "\tfloat x, y;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "y", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 96, + "column": 2, + "source_line": "\tfloat x, y;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "dx", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dx" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 97, + "column": 2, + "source_line": "\tfloat dx, dy;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "dy", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dy" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 97, + "column": 2, + "source_line": "\tfloat dx, dy;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "len", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float len" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 98, + "column": 2, + "source_line": "\tfloat len;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "dmx", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dmx" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 99, + "column": 2, + "source_line": "\tfloat dmx, dmy;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "dmy", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dmy" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 99, + "column": 2, + "source_line": "\tfloat dmx, dmy;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "flags", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char flags" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 100, + "column": 2, + "source_line": "\tunsigned char flags;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": null, + "is_incomplete": false, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 95, + "column": 1, + "source_line": "typedef struct NSVGpoint {" + } + }, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 95, + "column": 1, + "source_line": "typedef struct NSVGpoint {" + }, + "declaration_locations": [] + }, + "declared_type": { + "reference": "NSVGpoint" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 267, + "column": 1, + "source_line": "static void nsvg__appendPathPoint(NSVGrasterizer* r, NSVGpoint pt)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 267, + "column": 1, + "source_line": "static void nsvg__appendPathPoint(NSVGrasterizer* r, NSVGpoint pt)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 276, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__duplicatePoints", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "r", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "NSVGrasterizer", + "name": "NSVGrasterizer", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 278, + "column": 1, + "source_line": "static void nsvg__duplicatePoints(NSVGrasterizer* r)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 278, + "column": 1, + "source_line": "static void nsvg__duplicatePoints(NSVGrasterizer* r)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 288, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__addEdge", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "r", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "NSVGrasterizer", + "name": "NSVGrasterizer", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x0", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x0" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y0", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y0" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x1", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x1" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y1", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y1" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y1" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 290, + "column": 1, + "source_line": "static void nsvg__addEdge(NSVGrasterizer* r, float x0, float y0, float x1, float y1)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 290, + "column": 1, + "source_line": "static void nsvg__addEdge(NSVGrasterizer* r, float x0, float y0, float x1, float y1)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 320, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__normalize", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 322, + "column": 1, + "source_line": "static float nsvg__normalize(float *x, float* y)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 322, + "column": 1, + "source_line": "static float nsvg__normalize(float *x, float* y)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 331, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__absf", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 333, + "column": 1, + "source_line": "static float nsvg__absf(float x) { return x < 0 ? -x : x; }" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 333, + "column": 1, + "source_line": "static float nsvg__absf(float x) { return x < 0 ? -x : x; }" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 333, + "column": 59, + "source_line": "static float nsvg__absf(float x) { return x < 0 ? -x : x; }" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__roundf", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 334, + "column": 1, + "source_line": "static float nsvg__roundf(float x) { return (x >= 0) ? floorf(x + 0.5) : ceilf(x - 0.5); }" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 334, + "column": 1, + "source_line": "static float nsvg__roundf(float x) { return (x >= 0) ? floorf(x + 0.5) : ceilf(x - 0.5); }" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 334, + "column": 90, + "source_line": "static float nsvg__roundf(float x) { return (x >= 0) ? floorf(x + 0.5) : ceilf(x - 0.5); }" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__flattenCubicBez", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "r", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "NSVGrasterizer", + "name": "NSVGrasterizer", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x1", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x1" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y1", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y1" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x2", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x2" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x2" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y2", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y2" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y2" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x3", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x3" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x3" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y3", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y3" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y3" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x4", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x4" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x4" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y4", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y4" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y4" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "level", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int level" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int level" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "type", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int type" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int type" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 336, + "column": 1, + "source_line": "static void nsvg__flattenCubicBez(NSVGrasterizer* r," + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 336, + "column": 1, + "source_line": "static void nsvg__flattenCubicBez(NSVGrasterizer* r," + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 372, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__flattenShape", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "r", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "NSVGrasterizer", + "name": "NSVGrasterizer", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "shape", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGshape * shape", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "NSVGshape", + "name": "NSVGshape", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGshape * shape", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGshape" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "scale", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float scale" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float scale" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 374, + "column": 1, + "source_line": "static void nsvg__flattenShape(NSVGrasterizer* r, NSVGshape* shape, float scale)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 374, + "column": 1, + "source_line": "static void nsvg__flattenShape(NSVGrasterizer* r, NSVGshape* shape, float scale)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 393, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__initClosed", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "left", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * left", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * left", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "right", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * right", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * right", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p0", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * p0", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * p0", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p1", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * p1", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * p1", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "lineWidth", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float lineWidth" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float lineWidth" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 402, + "column": 1, + "source_line": "static void nsvg__initClosed(NSVGpoint* left, NSVGpoint* right, NSVGpoint* p0, NSVGpoint* p1, float lineWidth)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 402, + "column": 1, + "source_line": "static void nsvg__initClosed(NSVGpoint* left, NSVGpoint* right, NSVGpoint* p0, NSVGpoint* p1, float lineWidth)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 414, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__buttCap", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "r", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "NSVGrasterizer", + "name": "NSVGrasterizer", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "left", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * left", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * left", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "right", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * right", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * right", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dx", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dx" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dx" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dy", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dy" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dy" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "lineWidth", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float lineWidth" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float lineWidth" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "connect", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int connect" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int connect" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 416, + "column": 1, + "source_line": "static void nsvg__buttCap(NSVGrasterizer* r, NSVGpoint* left, NSVGpoint* right, NSVGpoint* p, float dx, float dy, float lineWidth, int connect)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 416, + "column": 1, + "source_line": "static void nsvg__buttCap(NSVGrasterizer* r, NSVGpoint* left, NSVGpoint* right, NSVGpoint* p, float dx, float dy, float lineWidth, int connect)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 432, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__squareCap", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "r", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "NSVGrasterizer", + "name": "NSVGrasterizer", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "left", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * left", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * left", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "right", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * right", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * right", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dx", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dx" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dx" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dy", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dy" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dy" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "lineWidth", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float lineWidth" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float lineWidth" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "connect", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int connect" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int connect" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 434, + "column": 1, + "source_line": "static void nsvg__squareCap(NSVGrasterizer* r, NSVGpoint* left, NSVGpoint* right, NSVGpoint* p, float dx, float dy, float lineWidth, int connect)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 434, + "column": 1, + "source_line": "static void nsvg__squareCap(NSVGrasterizer* r, NSVGpoint* left, NSVGpoint* right, NSVGpoint* p, float dx, float dy, float lineWidth, int connect)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 450, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__roundCap", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "r", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "NSVGrasterizer", + "name": "NSVGrasterizer", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "left", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * left", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * left", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "right", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * right", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * right", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dx", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dx" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dx" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dy", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dy" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dy" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "lineWidth", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float lineWidth" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float lineWidth" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ncap", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ncap" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ncap" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "connect", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int connect" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int connect" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 456, + "column": 1, + "source_line": "static void nsvg__roundCap(NSVGrasterizer* r, NSVGpoint* left, NSVGpoint* right, NSVGpoint* p, float dx, float dy, float lineWidth, int ncap, int connect)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 456, + "column": 1, + "source_line": "static void nsvg__roundCap(NSVGrasterizer* r, NSVGpoint* left, NSVGpoint* right, NSVGpoint* p, float dx, float dy, float lineWidth, int ncap, int connect)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 490, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__bevelJoin", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "r", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "NSVGrasterizer", + "name": "NSVGrasterizer", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "left", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * left", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * left", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "right", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * right", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * right", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p0", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * p0", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * p0", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p1", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * p1", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * p1", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "lineWidth", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float lineWidth" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float lineWidth" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 492, + "column": 1, + "source_line": "static void nsvg__bevelJoin(NSVGrasterizer* r, NSVGpoint* left, NSVGpoint* right, NSVGpoint* p0, NSVGpoint* p1, float lineWidth)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 492, + "column": 1, + "source_line": "static void nsvg__bevelJoin(NSVGrasterizer* r, NSVGpoint* left, NSVGpoint* right, NSVGpoint* p0, NSVGpoint* p1, float lineWidth)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 510, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__miterJoin", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "r", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "NSVGrasterizer", + "name": "NSVGrasterizer", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "left", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * left", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * left", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "right", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * right", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * right", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p0", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * p0", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * p0", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p1", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * p1", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * p1", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "lineWidth", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float lineWidth" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float lineWidth" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 512, + "column": 1, + "source_line": "static void nsvg__miterJoin(NSVGrasterizer* r, NSVGpoint* left, NSVGpoint* right, NSVGpoint* p0, NSVGpoint* p1, float lineWidth)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 512, + "column": 1, + "source_line": "static void nsvg__miterJoin(NSVGrasterizer* r, NSVGpoint* left, NSVGpoint* right, NSVGpoint* p0, NSVGpoint* p1, float lineWidth)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 546, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__roundJoin", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "r", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "NSVGrasterizer", + "name": "NSVGrasterizer", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "left", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * left", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * left", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "right", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * right", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * right", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p0", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * p0", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * p0", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p1", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * p1", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * p1", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "lineWidth", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float lineWidth" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float lineWidth" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ncap", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ncap" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ncap" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 548, + "column": 1, + "source_line": "static void nsvg__roundJoin(NSVGrasterizer* r, NSVGpoint* left, NSVGpoint* right, NSVGpoint* p0, NSVGpoint* p1, float lineWidth, int ncap)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 548, + "column": 1, + "source_line": "static void nsvg__roundJoin(NSVGrasterizer* r, NSVGpoint* left, NSVGpoint* right, NSVGpoint* p0, NSVGpoint* p1, float lineWidth, int ncap)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 587, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__straightJoin", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "r", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "NSVGrasterizer", + "name": "NSVGrasterizer", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "left", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * left", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * left", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "right", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * right", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * right", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p1", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * p1", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * p1", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "lineWidth", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float lineWidth" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float lineWidth" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 589, + "column": 1, + "source_line": "static void nsvg__straightJoin(NSVGrasterizer* r, NSVGpoint* left, NSVGpoint* right, NSVGpoint* p1, float lineWidth)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 589, + "column": 1, + "source_line": "static void nsvg__straightJoin(NSVGrasterizer* r, NSVGpoint* left, NSVGpoint* right, NSVGpoint* p1, float lineWidth)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 600, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__curveDivs", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "r", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float r" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float r" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "arc", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float arc" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float arc" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "tol", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float tol" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float tol" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 602, + "column": 1, + "source_line": "static int nsvg__curveDivs(float r, float arc, float tol)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 602, + "column": 1, + "source_line": "static int nsvg__curveDivs(float r, float arc, float tol)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 608, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__expandStroke", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "r", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "NSVGrasterizer", + "name": "NSVGrasterizer", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "points", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * points", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * points", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "npoints", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int npoints" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int npoints" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "closed", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int closed" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int closed" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "lineJoin", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int lineJoin" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int lineJoin" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "lineCap", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int lineCap" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int lineCap" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "lineWidth", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float lineWidth" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float lineWidth" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 610, + "column": 1, + "source_line": "static void nsvg__expandStroke(NSVGrasterizer* r, NSVGpoint* points, int npoints, int closed, int lineJoin, int lineCap, float lineWidth)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 610, + "column": 1, + "source_line": "static void nsvg__expandStroke(NSVGrasterizer* r, NSVGpoint* points, int npoints, int closed, int lineJoin, int lineCap, float lineWidth)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 679, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__prepareStroke", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "r", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "NSVGrasterizer", + "name": "NSVGrasterizer", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "miterLimit", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float miterLimit" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float miterLimit" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "lineJoin", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int lineJoin" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int lineJoin" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 681, + "column": 1, + "source_line": "static void nsvg__prepareStroke(NSVGrasterizer* r, float miterLimit, int lineJoin)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 681, + "column": 1, + "source_line": "static void nsvg__prepareStroke(NSVGrasterizer* r, float miterLimit, int lineJoin)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 736, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__flattenShapeStroke", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "r", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "NSVGrasterizer", + "name": "NSVGrasterizer", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "shape", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGshape * shape", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "NSVGshape", + "name": "NSVGshape", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGshape * shape", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGshape" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "scale", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float scale" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float scale" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 738, + "column": 1, + "source_line": "static void nsvg__flattenShapeStroke(NSVGrasterizer* r, NSVGshape* shape, float scale)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 738, + "column": 1, + "source_line": "static void nsvg__flattenShapeStroke(NSVGrasterizer* r, NSVGshape* shape, float scale)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 847, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__cmpEdge", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const void *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [ + "const" + ], + "source_text": "const void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const void *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [ + "const" + ], + "source_text": "const void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "q", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const void *q", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [ + "const" + ], + "source_text": "const void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const void *q", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [ + "const" + ], + "source_text": "const void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 849, + "column": 1, + "source_line": "static int nsvg__cmpEdge(const void *p, const void *q)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 849, + "column": 1, + "source_line": "static int nsvg__cmpEdge(const void *p, const void *q)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 857, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__addActive", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGactiveEdge", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "NSVGactiveEdge", + "name": "NSVGactiveEdge", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": "NSVGactiveEdge", + "members": [ + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 104, + "column": 2, + "source_line": "\tint x,dx;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "dx", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int dx" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 104, + "column": 2, + "source_line": "\tint x,dx;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "ey", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float ey" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 105, + "column": 2, + "source_line": "\tfloat ey;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "dir", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int dir" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 106, + "column": 2, + "source_line": "\tint dir;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "next", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "struct NSVGactiveEdge *next", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "struct NSVGactiveEdge" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 107, + "column": 2, + "source_line": "\tstruct NSVGactiveEdge *next;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": null, + "is_incomplete": false, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 103, + "column": 1, + "source_line": "typedef struct NSVGactiveEdge {" + } + }, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 103, + "column": 1, + "source_line": "typedef struct NSVGactiveEdge {" + }, + "declaration_locations": [] + } + ] + }, + "parameters": [ + { + "name": "r", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "NSVGrasterizer", + "name": "NSVGrasterizer", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "e", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGedge * e", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "NSVGedge", + "name": "NSVGedge", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": "NSVGedge", + "members": [ + { + "name": "x0", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x0" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 90, + "column": 2, + "source_line": "\tfloat x0,y0, x1,y1;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "y0", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y0" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 90, + "column": 2, + "source_line": "\tfloat x0,y0, x1,y1;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "x1", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x1" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 90, + "column": 2, + "source_line": "\tfloat x0,y0, x1,y1;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "y1", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y1" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 90, + "column": 2, + "source_line": "\tfloat x0,y0, x1,y1;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "dir", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int dir" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 91, + "column": 2, + "source_line": "\tint dir;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "next", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "struct NSVGedge * next", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "struct NSVGedge" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 92, + "column": 2, + "source_line": "\tstruct NSVGedge* next;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": null, + "is_incomplete": false, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 89, + "column": 1, + "source_line": "typedef struct NSVGedge {" + } + }, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 89, + "column": 1, + "source_line": "typedef struct NSVGedge {" + }, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGedge * e", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGedge" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "startPoint", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float startPoint" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float startPoint" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 860, + "column": 1, + "source_line": "static NSVGactiveEdge* nsvg__addActive(NSVGrasterizer* r, NSVGedge* e, float startPoint)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 860, + "column": 1, + "source_line": "static NSVGactiveEdge* nsvg__addActive(NSVGrasterizer* r, NSVGedge* e, float startPoint)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 888, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__freeActive", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "r", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "NSVGrasterizer", + "name": "NSVGrasterizer", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "z", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGactiveEdge * z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGactiveEdge" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGactiveEdge * z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGactiveEdge" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 890, + "column": 1, + "source_line": "static void nsvg__freeActive(NSVGrasterizer* r, NSVGactiveEdge* z)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 890, + "column": 1, + "source_line": "static void nsvg__freeActive(NSVGrasterizer* r, NSVGactiveEdge* z)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 894, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__fillScanline", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "scanline", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char * scanline", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char * scanline", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "maxWeight", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int maxWeight" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int maxWeight" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "xmin", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int * xmin", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int * xmin", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "xmax", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int * xmax", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int * xmax", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 896, + "column": 1, + "source_line": "static void nsvg__fillScanline(unsigned char* scanline, int len, int x0, int x1, int maxWeight, int* xmin, int* xmax)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 896, + "column": 1, + "source_line": "static void nsvg__fillScanline(unsigned char* scanline, int len, int x0, int x1, int maxWeight, int* xmin, int* xmax)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 921, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__fillActiveEdges", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "scanline", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char * scanline", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char * scanline", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "e", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGactiveEdge * e", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGactiveEdge" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGactiveEdge * e", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGactiveEdge" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "maxWeight", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int maxWeight" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int maxWeight" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "xmin", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int * xmin", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int * xmin", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "xmax", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int * xmax", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int * xmax", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "fillRule", + "type": { + "model": "CChar", + "qualifiers": [], + "source_text": "char fillRule" + }, + "declared_type": { + "model": "CChar", + "qualifiers": [], + "source_text": "char fillRule" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 926, + "column": 1, + "source_line": "static void nsvg__fillActiveEdges(unsigned char* scanline, int len, NSVGactiveEdge* e, int maxWeight, int* xmin, int* xmax, char fillRule)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 926, + "column": 1, + "source_line": "static void nsvg__fillActiveEdges(unsigned char* scanline, int len, NSVGactiveEdge* e, int maxWeight, int* xmin, int* xmax, char fillRule)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 958, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__clampf", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float a" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float a" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mn", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float mn" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float mn" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mx", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float mx" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float mx" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 960, + "column": 1, + "source_line": "static float nsvg__clampf(float a, float mn, float mx) {" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 960, + "column": 1, + "source_line": "static float nsvg__clampf(float a, float mn, float mx) {" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 964, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__RGBA", + "result_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int" + }, + "parameters": [ + { + "name": "r", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char r" + }, + "declared_type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char r" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "g", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char g" + }, + "declared_type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char g" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char b" + }, + "declared_type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char b" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "a", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char a" + }, + "declared_type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char a" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 966, + "column": 1, + "source_line": "static unsigned int nsvg__RGBA(unsigned char r, unsigned char g, unsigned char b, unsigned char a)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 966, + "column": 1, + "source_line": "static unsigned int nsvg__RGBA(unsigned char r, unsigned char g, unsigned char b, unsigned char a)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 969, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__lerpRGBA", + "result_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int" + }, + "parameters": [ + { + "name": "c0", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int c0" + }, + "declared_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int c0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c1", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int c1" + }, + "declared_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int c1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "u", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float u" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float u" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 971, + "column": 1, + "source_line": "static unsigned int nsvg__lerpRGBA(unsigned int c0, unsigned int c1, float u)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 971, + "column": 1, + "source_line": "static unsigned int nsvg__lerpRGBA(unsigned int c0, unsigned int c1, float u)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 979, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__applyOpacity", + "result_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int" + }, + "parameters": [ + { + "name": "c", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int c" + }, + "declared_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int c" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "u", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float u" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float u" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 981, + "column": 1, + "source_line": "static unsigned int nsvg__applyOpacity(unsigned int c, float u)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 981, + "column": 1, + "source_line": "static unsigned int nsvg__applyOpacity(unsigned int c, float u)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 989, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__div255", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [ + "inline" + ], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 991, + "column": 1, + "source_line": "static inline int nsvg__div255(int x)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 991, + "column": 1, + "source_line": "static inline int nsvg__div255(int x)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 994, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__scanlineSolid", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "dst", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char * dst", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char * dst", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "count", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int count" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int count" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cover", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char * cover", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char * cover", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "tx", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float tx" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float tx" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ty", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float ty" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float ty" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "scale", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float scale" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float scale" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cache", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGcachedPaint * cache", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "NSVGcachedPaint", + "name": "NSVGcachedPaint", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": "NSVGcachedPaint", + "members": [ + { + "name": "type", + "type": { + "model": "CSignedChar", + "qualifiers": [], + "source_text": "signed char type" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 117, + "column": 2, + "source_line": "\tsigned char type;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "spread", + "type": { + "model": "CChar", + "qualifiers": [], + "source_text": "char spread" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 118, + "column": 2, + "source_line": "\tchar spread;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "xform", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float xform[6]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "6", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 119, + "column": 2, + "source_line": "\tfloat xform[6];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "colors", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned int colors[256]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "256", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 120, + "column": 2, + "source_line": "\tunsigned int colors[256];" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": null, + "is_incomplete": false, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 116, + "column": 1, + "source_line": "typedef struct NSVGcachedPaint {" + } + }, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 116, + "column": 1, + "source_line": "typedef struct NSVGcachedPaint {" + }, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGcachedPaint * cache", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGcachedPaint" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 996, + "column": 1, + "source_line": "static void nsvg__scanlineSolid(unsigned char* dst, int count, unsigned char* cover, int x, int y," + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 996, + "column": 1, + "source_line": "static void nsvg__scanlineSolid(unsigned char* dst, int count, unsigned char* cover, int x, int y," + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 1122, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__rasterizeSortedEdges", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "r", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer *r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "NSVGrasterizer", + "name": "NSVGrasterizer", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer *r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "tx", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float tx" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float tx" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ty", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float ty" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float ty" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "scale", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float scale" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float scale" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cache", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGcachedPaint * cache", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGcachedPaint" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGcachedPaint * cache", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGcachedPaint" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "fillRule", + "type": { + "model": "CChar", + "qualifiers": [], + "source_text": "char fillRule" + }, + "declared_type": { + "model": "CChar", + "qualifiers": [], + "source_text": "char fillRule" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 1124, + "column": 1, + "source_line": "static void nsvg__rasterizeSortedEdges(NSVGrasterizer *r, float tx, float ty, float scale, NSVGcachedPaint* cache, char fillRule)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 1124, + "column": 1, + "source_line": "static void nsvg__rasterizeSortedEdges(NSVGrasterizer *r, float tx, float ty, float scale, NSVGcachedPaint* cache, char fillRule)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 1210, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__unpremultiplyAlpha", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "image", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char * image", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char * image", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "w", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "h", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "stride", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int stride" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int stride" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 1212, + "column": 1, + "source_line": "static void nsvg__unpremultiplyAlpha(unsigned char* image, int w, int h, int stride)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 1212, + "column": 1, + "source_line": "static void nsvg__unpremultiplyAlpha(unsigned char* image, int w, int h, int stride)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 1269, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvg__initPaint", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "cache", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGcachedPaint * cache", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGcachedPaint" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGcachedPaint * cache", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGcachedPaint" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "paint", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpaint * paint", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "NSVGpaint", + "name": "NSVGpaint", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpaint * paint", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpaint" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "opacity", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float opacity" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float opacity" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 1272, + "column": 1, + "source_line": "static void nsvg__initPaint(NSVGcachedPaint* cache, NSVGpaint* paint, float opacity)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 1272, + "column": 1, + "source_line": "static void nsvg__initPaint(NSVGcachedPaint* cache, NSVGpaint* paint, float opacity)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 1331, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "nsvgRasterize", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "r", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "NSVGrasterizer", + "name": "NSVGrasterizer", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "image", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGimage * image", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "NSVGimage", + "name": "NSVGimage", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGimage * image", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGimage" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "tx", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float tx" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float tx" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ty", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float ty" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float ty" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "scale", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float scale" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float scale" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dst", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char * dst", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char * dst", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "w", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "h", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "stride", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int stride" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int stride" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 1375, + "column": 1, + "source_line": "void nsvgRasterize(NSVGrasterizer* r," + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 1375, + "column": 1, + "source_line": "void nsvgRasterize(NSVGrasterizer* r," + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 1468, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + } + ], + "structs": [ + { + "reference": "struct NSVGedge" + }, + { + "reference": "struct NSVGpoint" + }, + { + "reference": "struct NSVGactiveEdge" + }, + { + "reference": "struct NSVGmemPage" + }, + { + "reference": "struct NSVGcachedPaint" + }, + { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": "NSVGrasterizer", + "members": [ + { + "name": "px", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float px" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 125, + "column": 2, + "source_line": "\tfloat px, py;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "py", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float py" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 125, + "column": 2, + "source_line": "\tfloat px, py;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "tessTol", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float tessTol" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 127, + "column": 2, + "source_line": "\tfloat tessTol;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "distTol", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float distTol" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 128, + "column": 2, + "source_line": "\tfloat distTol;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "edges", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGedge * edges", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGedge" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 130, + "column": 2, + "source_line": "\tNSVGedge* edges;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "nedges", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int nedges" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 131, + "column": 2, + "source_line": "\tint nedges;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "cedges", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int cedges" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 132, + "column": 2, + "source_line": "\tint cedges;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "points", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * points", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 134, + "column": 2, + "source_line": "\tNSVGpoint* points;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "npoints", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int npoints" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 135, + "column": 2, + "source_line": "\tint npoints;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "cpoints", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int cpoints" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 136, + "column": 2, + "source_line": "\tint cpoints;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "points2", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * points2", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 138, + "column": 2, + "source_line": "\tNSVGpoint* points2;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "npoints2", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int npoints2" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 139, + "column": 2, + "source_line": "\tint npoints2;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "cpoints2", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int cpoints2" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 140, + "column": 2, + "source_line": "\tint cpoints2;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "freelist", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGactiveEdge * freelist", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGactiveEdge" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 142, + "column": 2, + "source_line": "\tNSVGactiveEdge* freelist;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "pages", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGmemPage * pages", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGmemPage" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 143, + "column": 2, + "source_line": "\tNSVGmemPage* pages;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "curpage", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGmemPage * curpage", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGmemPage" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 144, + "column": 2, + "source_line": "\tNSVGmemPage* curpage;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "scanline", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char * scanline", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 146, + "column": 2, + "source_line": "\tunsigned char* scanline;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "cscanline", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int cscanline" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 147, + "column": 2, + "source_line": "\tint cscanline;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "bitmap", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char * bitmap", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 149, + "column": 2, + "source_line": "\tunsigned char* bitmap;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "width", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 150, + "column": 2, + "source_line": "\tint width, height, stride;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "height", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int height" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 150, + "column": 2, + "source_line": "\tint width, height, stride;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "stride", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int stride" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 150, + "column": 2, + "source_line": "\tint width, height, stride;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": null, + "is_incomplete": false, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 123, + "column": 1, + "source_line": "struct NSVGrasterizer" + } + } + ], + "unions": [], + "enums": [ + { + "model": "CEnum", + "qualifiers": [], + "source_text": "", + "name": "NSVGpointFlags", + "constants": [ + { + "name": "NSVG_PT_CORNER", + "value": "0x01", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 395, + "column": 1, + "source_line": "enum NSVGpointFlags" + } + }, + { + "name": "NSVG_PT_BEVEL", + "value": "0x02", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 395, + "column": 1, + "source_line": "enum NSVGpointFlags" + } + }, + { + "name": "NSVG_PT_LEFT", + "value": "0x04", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 395, + "column": 1, + "source_line": "enum NSVGpointFlags" + } + } + ], + "anonymous_id": null, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 395, + "column": 1, + "source_line": "enum NSVGpointFlags" + } + } + ], + "typedefs": [ + { + "reference": "NSVGedge" + }, + { + "reference": "NSVGpoint" + }, + { + "reference": "NSVGactiveEdge" + }, + { + "reference": "NSVGmemPage" + }, + { + "reference": "NSVGcachedPaint" + } + ], + "variables": [], + "macros": [ + { + "name": "NANOSVGRAST_H", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 26, + "column": 1, + "source_line": "#define NANOSVGRAST_H" + } + }, + { + "name": "NSVG__SUBSAMPLES", + "value": "5", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 83, + "column": 1, + "source_line": "#define NSVG__SUBSAMPLES\t5" + } + }, + { + "name": "NSVG__FIXSHIFT", + "value": "10", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 84, + "column": 1, + "source_line": "#define NSVG__FIXSHIFT\t\t10" + } + }, + { + "name": "NSVG__FIX", + "value": "(1 << NSVG__FIXSHIFT)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 85, + "column": 1, + "source_line": "#define NSVG__FIX\t\t\t(1 << NSVG__FIXSHIFT)" + } + }, + { + "name": "NSVG__FIXMASK", + "value": "(NSVG__FIX-1)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 86, + "column": 1, + "source_line": "#define NSVG__FIXMASK\t\t(NSVG__FIX-1)" + } + }, + { + "name": "NSVG__MEMPAGE_SIZE", + "value": "1024", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 87, + "column": 1, + "source_line": "#define NSVG__MEMPAGE_SIZE\t1024" + } + }, + { + "name": "NSVG_PI", + "value": "(3.14159265358979323846264338327f)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 453, + "column": 1, + "source_line": "#define NSVG_PI (3.14159265358979323846264338327f)" + } + } + ], + "includes": [ + { + "target": "nanosvg.h", + "kind": "local", + "resolved_path": "nanosvg/nanosvg.h", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 28, + "column": 1, + "source_line": "#include \"nanosvg.h\"" + } + }, + { + "target": "math.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 79, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "stdlib.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 80, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "string.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 81, + "column": 1, + "source_line": "#include " + } + } + ], + "raw_directives": [ + { + "directive": "ifndef", + "argument": "NANOSVGRAST_H", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 25, + "column": 1, + "source_line": "#ifndef NANOSVGRAST_H" + } + }, + { + "directive": "ifndef", + "argument": "NANOSVGRAST_CPLUSPLUS", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 30, + "column": 1, + "source_line": "#ifndef NANOSVGRAST_CPLUSPLUS" + } + }, + { + "directive": "ifdef", + "argument": "__cplusplus", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 31, + "column": 1, + "source_line": "#ifdef __cplusplus" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 33, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 34, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "NANOSVGRAST_CPLUSPLUS", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 71, + "column": 1, + "source_line": "#ifndef NANOSVGRAST_CPLUSPLUS" + } + }, + { + "directive": "ifdef", + "argument": "__cplusplus", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 72, + "column": 1, + "source_line": "#ifdef __cplusplus" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 74, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 75, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "NANOSVGRAST_IMPLEMENTATION", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 77, + "column": 1, + "source_line": "#ifdef NANOSVGRAST_IMPLEMENTATION" + } + }, + { + "directive": "ifndef", + "argument": "NSVG_PI", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 452, + "column": 1, + "source_line": "#ifndef NSVG_PI" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 454, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 1470, + "column": 1, + "source_line": "#endif // NANOSVGRAST_IMPLEMENTATION" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 1472, + "column": 1, + "source_line": "#endif // NANOSVGRAST_H" + } + } + ], + "macro_dependencies": [], + "diagnostics": [ + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '\"C\"'.", + "severity": "warning", + "location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 32, + "column": 1, + "source_line": "extern \"C\" {" + }, + "unit_kind": "declarator", + "unit_name": null + } + ] + } + }, + "functions": { + "nsvg__isspace": { + "name": "nsvg__isspace", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "c", + "type": { + "model": "CChar", + "qualifiers": [], + "source_text": "char c" + }, + "declared_type": { + "model": "CChar", + "qualifiers": [], + "source_text": "char c" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 228, + "column": 1, + "source_line": "static int nsvg__isspace(char c)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 228, + "column": 1, + "source_line": "static int nsvg__isspace(char c)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 231, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__isdigit": { + "name": "nsvg__isdigit", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "c", + "type": { + "model": "CChar", + "qualifiers": [], + "source_text": "char c" + }, + "declared_type": { + "model": "CChar", + "qualifiers": [], + "source_text": "char c" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 233, + "column": 1, + "source_line": "static int nsvg__isdigit(char c)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 233, + "column": 1, + "source_line": "static int nsvg__isdigit(char c)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 236, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__parseContent": { + "name": "nsvg__parseContent", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char * s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char * s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "contentCb", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void (*contentCb)(void* ud, const char* s)", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFunctionType", + "qualifiers": [], + "source_text": "void", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameter_types": [ + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * ud", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + } + ], + "is_variadic": false, + "prototype_style": "prototype" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void (*contentCb)(void* ud, const char* s)", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFunctionType", + "qualifiers": [], + "source_text": "void", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameter_types": [ + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * ud", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + } + ], + "is_variadic": false, + "prototype_style": "prototype" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ud", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * ud", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * ud", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 248, + "column": 1, + "source_line": "static void nsvg__parseContent(char* s," + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 248, + "column": 1, + "source_line": "static void nsvg__parseContent(char* s," + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 258, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__parseElement": { + "name": "nsvg__parseElement", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char * s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char * s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "startelCb", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void (*startelCb)(void* ud, const char* el, const char** attr)", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFunctionType", + "qualifiers": [], + "source_text": "void", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameter_types": [ + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * ud", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * el", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char ** attr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + } + ], + "is_variadic": false, + "prototype_style": "prototype" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void (*startelCb)(void* ud, const char* el, const char** attr)", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFunctionType", + "qualifiers": [], + "source_text": "void", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameter_types": [ + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * ud", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * el", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char ** attr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + } + ], + "is_variadic": false, + "prototype_style": "prototype" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "endelCb", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void (*endelCb)(void* ud, const char* el)", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFunctionType", + "qualifiers": [], + "source_text": "void", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameter_types": [ + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * ud", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * el", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + } + ], + "is_variadic": false, + "prototype_style": "prototype" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void (*endelCb)(void* ud, const char* el)", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFunctionType", + "qualifiers": [], + "source_text": "void", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameter_types": [ + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * ud", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * el", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + } + ], + "is_variadic": false, + "prototype_style": "prototype" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ud", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * ud", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * ud", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 260, + "column": 1, + "source_line": "static void nsvg__parseElement(char* s," + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 260, + "column": 1, + "source_line": "static void nsvg__parseElement(char* s," + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 334, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__parseXML": { + "name": "nsvg__parseXML", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "input", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char * input", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char * input", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "startelCb", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void (*startelCb)(void* ud, const char* el, const char** attr)", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFunctionType", + "qualifiers": [], + "source_text": "void", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameter_types": [ + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * ud", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * el", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char ** attr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + } + ], + "is_variadic": false, + "prototype_style": "prototype" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void (*startelCb)(void* ud, const char* el, const char** attr)", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFunctionType", + "qualifiers": [], + "source_text": "void", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameter_types": [ + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * ud", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * el", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char ** attr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + } + ], + "is_variadic": false, + "prototype_style": "prototype" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "endelCb", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void (*endelCb)(void* ud, const char* el)", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFunctionType", + "qualifiers": [], + "source_text": "void", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameter_types": [ + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * ud", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * el", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + } + ], + "is_variadic": false, + "prototype_style": "prototype" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void (*endelCb)(void* ud, const char* el)", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFunctionType", + "qualifiers": [], + "source_text": "void", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameter_types": [ + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * ud", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * el", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + } + ], + "is_variadic": false, + "prototype_style": "prototype" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "contentCb", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void (*contentCb)(void* ud, const char* s)", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFunctionType", + "qualifiers": [], + "source_text": "void", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameter_types": [ + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * ud", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + } + ], + "is_variadic": false, + "prototype_style": "prototype" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void (*contentCb)(void* ud, const char* s)", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFunctionType", + "qualifiers": [], + "source_text": "void", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameter_types": [ + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * ud", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + } + ], + "is_variadic": false, + "prototype_style": "prototype" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ud", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * ud", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * ud", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 336, + "column": 1, + "source_line": "int nsvg__parseXML(char* input," + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 336, + "column": 1, + "source_line": "int nsvg__parseXML(char* input," + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 364, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__xformIdentity": { + "name": "nsvg__xformIdentity", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "t", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * t", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * t", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 478, + "column": 1, + "source_line": "static void nsvg__xformIdentity(float* t)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 478, + "column": 1, + "source_line": "static void nsvg__xformIdentity(float* t)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 483, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__xformSetTranslation": { + "name": "nsvg__xformSetTranslation", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "t", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * t", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * t", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "tx", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float tx" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float tx" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ty", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float ty" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float ty" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 485, + "column": 1, + "source_line": "static void nsvg__xformSetTranslation(float* t, float tx, float ty)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 485, + "column": 1, + "source_line": "static void nsvg__xformSetTranslation(float* t, float tx, float ty)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 490, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__xformSetScale": { + "name": "nsvg__xformSetScale", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "t", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * t", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * t", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "sx", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float sx" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float sx" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "sy", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float sy" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float sy" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 492, + "column": 1, + "source_line": "static void nsvg__xformSetScale(float* t, float sx, float sy)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 492, + "column": 1, + "source_line": "static void nsvg__xformSetScale(float* t, float sx, float sy)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 497, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__xformSetSkewX": { + "name": "nsvg__xformSetSkewX", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "t", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * t", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * t", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "a", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float a" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float a" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 499, + "column": 1, + "source_line": "static void nsvg__xformSetSkewX(float* t, float a)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 499, + "column": 1, + "source_line": "static void nsvg__xformSetSkewX(float* t, float a)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 504, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__xformSetSkewY": { + "name": "nsvg__xformSetSkewY", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "t", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * t", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * t", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "a", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float a" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float a" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 506, + "column": 1, + "source_line": "static void nsvg__xformSetSkewY(float* t, float a)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 506, + "column": 1, + "source_line": "static void nsvg__xformSetSkewY(float* t, float a)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 511, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__xformSetRotation": { + "name": "nsvg__xformSetRotation", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "t", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * t", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * t", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "a", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float a" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float a" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 513, + "column": 1, + "source_line": "static void nsvg__xformSetRotation(float* t, float a)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 513, + "column": 1, + "source_line": "static void nsvg__xformSetRotation(float* t, float a)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 519, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__xformMultiply": { + "name": "nsvg__xformMultiply", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "t", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * t", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * t", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 521, + "column": 1, + "source_line": "static void nsvg__xformMultiply(float* t, float* s)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 521, + "column": 1, + "source_line": "static void nsvg__xformMultiply(float* t, float* s)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 532, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__xformInverse": { + "name": "nsvg__xformInverse", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "inv", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * inv", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * inv", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "t", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * t", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * t", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 534, + "column": 1, + "source_line": "static void nsvg__xformInverse(float* inv, float* t)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 534, + "column": 1, + "source_line": "static void nsvg__xformInverse(float* inv, float* t)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 548, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__xformPremultiply": { + "name": "nsvg__xformPremultiply", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "t", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * t", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * t", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 550, + "column": 1, + "source_line": "static void nsvg__xformPremultiply(float* t, float* s)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 550, + "column": 1, + "source_line": "static void nsvg__xformPremultiply(float* t, float* s)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 556, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__xformPoint": { + "name": "nsvg__xformPoint", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "dx", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * dx", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * dx", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dy", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * dy", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * dy", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "t", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * t", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * t", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 558, + "column": 1, + "source_line": "static void nsvg__xformPoint(float* dx, float* dy, float x, float y, float* t)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 558, + "column": 1, + "source_line": "static void nsvg__xformPoint(float* dx, float* dy, float x, float y, float* t)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 562, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__xformVec": { + "name": "nsvg__xformVec", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "dx", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * dx", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * dx", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dy", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * dy", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * dy", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "t", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * t", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * t", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 564, + "column": 1, + "source_line": "static void nsvg__xformVec(float* dx, float* dy, float x, float y, float* t)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 564, + "column": 1, + "source_line": "static void nsvg__xformVec(float* dx, float* dy, float x, float y, float* t)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 568, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__ptInBounds": { + "name": "nsvg__ptInBounds", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "pt", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * pt", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * pt", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "bounds", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * bounds", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * bounds", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 572, + "column": 1, + "source_line": "static int nsvg__ptInBounds(float* pt, float* bounds)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 572, + "column": 1, + "source_line": "static int nsvg__ptInBounds(float* pt, float* bounds)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 575, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__evalBezier": { + "name": "nsvg__evalBezier", + "result_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + }, + "parameters": [ + { + "name": "t", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double t" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double t" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p0", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double p0" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double p0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p1", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double p1" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double p1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p2", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double p2" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double p2" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p3", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double p3" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double p3" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 578, + "column": 1, + "source_line": "static double nsvg__evalBezier(double t, double p0, double p1, double p2, double p3)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 578, + "column": 1, + "source_line": "static double nsvg__evalBezier(double t, double p0, double p1, double p2, double p3)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 582, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__curveBounds": { + "name": "nsvg__curveBounds", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "bounds", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * bounds", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * bounds", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "curve", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * curve", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * curve", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 584, + "column": 1, + "source_line": "static void nsvg__curveBounds(float* bounds, float* curve)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 584, + "column": 1, + "source_line": "static void nsvg__curveBounds(float* bounds, float* curve)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 633, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__encodePaintOrder": { + "name": "nsvg__encodePaintOrder", + "result_type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + }, + "parameters": [ + { + "name": "a", + "type": { + "reference": "enum NSVGpaintOrder" + }, + "declared_type": { + "reference": "enum NSVGpaintOrder" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "reference": "enum NSVGpaintOrder" + }, + "declared_type": { + "reference": "enum NSVGpaintOrder" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c", + "type": { + "reference": "enum NSVGpaintOrder" + }, + "declared_type": { + "reference": "enum NSVGpaintOrder" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 635, + "column": 1, + "source_line": "static unsigned char nsvg__encodePaintOrder(enum NSVGpaintOrder a, enum NSVGpaintOrder b, enum NSVGpaintOrder c) {" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 635, + "column": 1, + "source_line": "static unsigned char nsvg__encodePaintOrder(enum NSVGpaintOrder a, enum NSVGpaintOrder b, enum NSVGpaintOrder c) {" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 637, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__createParser": { + "name": "nsvg__createParser", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "parameters": [], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 639, + "column": 1, + "source_line": "static NSVGparser* nsvg__createParser(void)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 639, + "column": 1, + "source_line": "static NSVGparser* nsvg__createParser(void)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 676, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__deleteStyles": { + "name": "nsvg__deleteStyles", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "style", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGstyleDeclaration * style", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGstyleDeclaration" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGstyleDeclaration * style", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGstyleDeclaration" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 677, + "column": 1, + "source_line": "static void nsvg__deleteStyles(NSVGstyleDeclaration* style) {" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 677, + "column": 1, + "source_line": "static void nsvg__deleteStyles(NSVGstyleDeclaration* style) {" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 685, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__deletePaths": { + "name": "nsvg__deletePaths", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "path", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpath * path", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpath" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpath * path", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpath" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 687, + "column": 1, + "source_line": "static void nsvg__deletePaths(NSVGpath* path)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 687, + "column": 1, + "source_line": "static void nsvg__deletePaths(NSVGpath* path)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 696, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__deletePaint": { + "name": "nsvg__deletePaint", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "paint", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpaint * paint", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpaint" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpaint * paint", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpaint" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 698, + "column": 1, + "source_line": "static void nsvg__deletePaint(NSVGpaint* paint)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 698, + "column": 1, + "source_line": "static void nsvg__deletePaint(NSVGpaint* paint)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 702, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__deleteGradientData": { + "name": "nsvg__deleteGradientData", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "grad", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGgradientData * grad", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGgradientData" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGgradientData * grad", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGgradientData" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 704, + "column": 1, + "source_line": "static void nsvg__deleteGradientData(NSVGgradientData* grad)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 704, + "column": 1, + "source_line": "static void nsvg__deleteGradientData(NSVGgradientData* grad)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 713, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__deleteParser": { + "name": "nsvg__deleteParser", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 715, + "column": 1, + "source_line": "static void nsvg__deleteParser(NSVGparser* p)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 715, + "column": 1, + "source_line": "static void nsvg__deleteParser(NSVGparser* p)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 725, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__resetPath": { + "name": "nsvg__resetPath", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 727, + "column": 1, + "source_line": "static void nsvg__resetPath(NSVGparser* p)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 727, + "column": 1, + "source_line": "static void nsvg__resetPath(NSVGparser* p)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 730, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__addPoint": { + "name": "nsvg__addPoint", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 732, + "column": 1, + "source_line": "static void nsvg__addPoint(NSVGparser* p, float x, float y)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 732, + "column": 1, + "source_line": "static void nsvg__addPoint(NSVGparser* p, float x, float y)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 742, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__moveTo": { + "name": "nsvg__moveTo", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 744, + "column": 1, + "source_line": "static void nsvg__moveTo(NSVGparser* p, float x, float y)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 744, + "column": 1, + "source_line": "static void nsvg__moveTo(NSVGparser* p, float x, float y)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 752, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__lineTo": { + "name": "nsvg__lineTo", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 754, + "column": 1, + "source_line": "static void nsvg__lineTo(NSVGparser* p, float x, float y)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 754, + "column": 1, + "source_line": "static void nsvg__lineTo(NSVGparser* p, float x, float y)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 766, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__cubicBezTo": { + "name": "nsvg__cubicBezTo", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cpx1", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float cpx1" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float cpx1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cpy1", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float cpy1" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float cpy1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cpx2", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float cpx2" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float cpx2" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cpy2", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float cpy2" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float cpy2" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 768, + "column": 1, + "source_line": "static void nsvg__cubicBezTo(NSVGparser* p, float cpx1, float cpy1, float cpx2, float cpy2, float x, float y)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 768, + "column": 1, + "source_line": "static void nsvg__cubicBezTo(NSVGparser* p, float cpx1, float cpy1, float cpx2, float cpy2, float x, float y)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 775, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__getAttr": { + "name": "nsvg__getAttr", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGattrib", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGattrib" + } + ] + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 777, + "column": 1, + "source_line": "static NSVGattrib* nsvg__getAttr(NSVGparser* p)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 777, + "column": 1, + "source_line": "static NSVGattrib* nsvg__getAttr(NSVGparser* p)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 780, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__pushAttr": { + "name": "nsvg__pushAttr", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 782, + "column": 1, + "source_line": "static void nsvg__pushAttr(NSVGparser* p)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 782, + "column": 1, + "source_line": "static void nsvg__pushAttr(NSVGparser* p)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 788, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__popAttr": { + "name": "nsvg__popAttr", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 790, + "column": 1, + "source_line": "static void nsvg__popAttr(NSVGparser* p)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 790, + "column": 1, + "source_line": "static void nsvg__popAttr(NSVGparser* p)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 794, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__actualOrigX": { + "name": "nsvg__actualOrigX", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 796, + "column": 1, + "source_line": "static float nsvg__actualOrigX(NSVGparser* p)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 796, + "column": 1, + "source_line": "static float nsvg__actualOrigX(NSVGparser* p)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 799, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__actualOrigY": { + "name": "nsvg__actualOrigY", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 801, + "column": 1, + "source_line": "static float nsvg__actualOrigY(NSVGparser* p)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 801, + "column": 1, + "source_line": "static float nsvg__actualOrigY(NSVGparser* p)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 804, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__actualWidth": { + "name": "nsvg__actualWidth", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 806, + "column": 1, + "source_line": "static float nsvg__actualWidth(NSVGparser* p)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 806, + "column": 1, + "source_line": "static float nsvg__actualWidth(NSVGparser* p)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 809, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__actualHeight": { + "name": "nsvg__actualHeight", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 811, + "column": 1, + "source_line": "static float nsvg__actualHeight(NSVGparser* p)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 811, + "column": 1, + "source_line": "static float nsvg__actualHeight(NSVGparser* p)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 814, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__actualLength": { + "name": "nsvg__actualLength", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 816, + "column": 1, + "source_line": "static float nsvg__actualLength(NSVGparser* p)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 816, + "column": 1, + "source_line": "static float nsvg__actualLength(NSVGparser* p)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 820, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__convertToPixels": { + "name": "nsvg__convertToPixels", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c", + "type": { + "reference": "NSVGcoordinate" + }, + "declared_type": { + "reference": "NSVGcoordinate" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "orig", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float orig" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float orig" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "length", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float length" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float length" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 822, + "column": 1, + "source_line": "static float nsvg__convertToPixels(NSVGparser* p, NSVGcoordinate c, float orig, float length)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 822, + "column": 1, + "source_line": "static float nsvg__convertToPixels(NSVGparser* p, NSVGcoordinate c, float orig, float length)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 839, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__findGradientData": { + "name": "nsvg__findGradientData", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGgradientData", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGgradientData" + } + ] + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "id", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * id", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * id", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 841, + "column": 1, + "source_line": "static NSVGgradientData* nsvg__findGradientData(NSVGparser* p, const char* id)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 841, + "column": 1, + "source_line": "static NSVGgradientData* nsvg__findGradientData(NSVGparser* p, const char* id)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 852, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__createGradient": { + "name": "nsvg__createGradient", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGgradient", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGgradient" + } + ] + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "id", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * id", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * id", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "localBounds", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const float * localBounds", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [ + "const" + ], + "source_text": "const float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const float * localBounds", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [ + "const" + ], + "source_text": "const float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "xform", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *xform", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *xform", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "paintType", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "signed char * paintType", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CSignedChar", + "qualifiers": [], + "source_text": "signed char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "signed char * paintType", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CSignedChar", + "qualifiers": [], + "source_text": "signed char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 854, + "column": 1, + "source_line": "static NSVGgradient* nsvg__createGradient(NSVGparser* p, const char* id, const float* localBounds, float *xform, signed char* paintType)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 854, + "column": 1, + "source_line": "static NSVGgradient* nsvg__createGradient(NSVGparser* p, const char* id, const float* localBounds, float *xform, signed char* paintType)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 939, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__getAverageScale": { + "name": "nsvg__getAverageScale", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "t", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * t", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * t", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 941, + "column": 1, + "source_line": "static float nsvg__getAverageScale(float* t)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 941, + "column": 1, + "source_line": "static float nsvg__getAverageScale(float* t)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 946, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__getLocalBounds": { + "name": "nsvg__getLocalBounds", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "bounds", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * bounds", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * bounds", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "shape", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGshape *shape", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGshape" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGshape *shape", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGshape" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "xform", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * xform", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * xform", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 948, + "column": 1, + "source_line": "static void nsvg__getLocalBounds(float* bounds, NSVGshape *shape, float* xform)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 948, + "column": 1, + "source_line": "static void nsvg__getLocalBounds(float* bounds, NSVGshape *shape, float* xform)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 976, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__addShape": { + "name": "nsvg__addShape", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 978, + "column": 1, + "source_line": "static void nsvg__addShape(NSVGparser* p)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 978, + "column": 1, + "source_line": "static void nsvg__addShape(NSVGparser* p)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1061, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__addPath": { + "name": "nsvg__addPath", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "closed", + "type": { + "model": "CChar", + "qualifiers": [], + "source_text": "char closed" + }, + "declared_type": { + "model": "CChar", + "qualifiers": [], + "source_text": "char closed" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1063, + "column": 1, + "source_line": "static void nsvg__addPath(NSVGparser* p, char closed)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1063, + "column": 1, + "source_line": "static void nsvg__addPath(NSVGparser* p, char closed)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1121, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__atof": { + "name": "nsvg__atof", + "result_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1124, + "column": 1, + "source_line": "static double nsvg__atof(const char* s)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1124, + "column": 1, + "source_line": "static double nsvg__atof(const char* s)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1180, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__parseNumber": { + "name": "nsvg__parseNumber", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "it", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char * it", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char * it", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "size", + "type": { + "model": "CInt", + "qualifiers": [ + "const" + ], + "source_text": "const int size" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [ + "const" + ], + "source_text": "const int size" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1183, + "column": 1, + "source_line": "static const char* nsvg__parseNumber(const char* s, char* it, const int size)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1183, + "column": 1, + "source_line": "static const char* nsvg__parseNumber(const char* s, char* it, const int size)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1224, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__getNextPathItemWhenArcFlag": { + "name": "nsvg__getNextPathItemWhenArcFlag", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "it", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char * it", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char * it", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1226, + "column": 1, + "source_line": "static const char* nsvg__getNextPathItemWhenArcFlag(const char* s, char* it)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1226, + "column": 1, + "source_line": "static const char* nsvg__getNextPathItemWhenArcFlag(const char* s, char* it)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1237, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__getNextPathItem": { + "name": "nsvg__getNextPathItem", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "it", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char * it", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char * it", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1239, + "column": 1, + "source_line": "static const char* nsvg__getNextPathItem(const char* s, char* it)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1239, + "column": 1, + "source_line": "static const char* nsvg__getNextPathItem(const char* s, char* it)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1255, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__parseColorHex": { + "name": "nsvg__parseColorHex", + "result_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int" + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1257, + "column": 1, + "source_line": "static unsigned int nsvg__parseColorHex(const char* str)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1257, + "column": 1, + "source_line": "static unsigned int nsvg__parseColorHex(const char* str)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1265, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__parseColorRGB": { + "name": "nsvg__parseColorRGB", + "result_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int" + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1271, + "column": 1, + "source_line": "static unsigned int nsvg__parseColorRGB(const char* str)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1271, + "column": 1, + "source_line": "static unsigned int nsvg__parseColorRGB(const char* str)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1319, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__parseColorName": { + "name": "nsvg__parseColorName", + "result_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int" + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1480, + "column": 1, + "source_line": "static unsigned int nsvg__parseColorName(const char* str)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1480, + "column": 1, + "source_line": "static unsigned int nsvg__parseColorName(const char* str)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1491, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__parseColor": { + "name": "nsvg__parseColor", + "result_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int" + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1493, + "column": 1, + "source_line": "static unsigned int nsvg__parseColor(const char* str)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1493, + "column": 1, + "source_line": "static unsigned int nsvg__parseColor(const char* str)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1503, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__parseOpacity": { + "name": "nsvg__parseOpacity", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1505, + "column": 1, + "source_line": "static float nsvg__parseOpacity(const char* str)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1505, + "column": 1, + "source_line": "static float nsvg__parseOpacity(const char* str)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1511, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__parseMiterLimit": { + "name": "nsvg__parseMiterLimit", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1513, + "column": 1, + "source_line": "static float nsvg__parseMiterLimit(const char* str)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1513, + "column": 1, + "source_line": "static float nsvg__parseMiterLimit(const char* str)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1518, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__parseUnits": { + "name": "nsvg__parseUnits", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "units", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * units", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * units", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1520, + "column": 1, + "source_line": "static int nsvg__parseUnits(const char* units)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1520, + "column": 1, + "source_line": "static int nsvg__parseUnits(const char* units)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1541, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__isCoordinate": { + "name": "nsvg__isCoordinate", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1543, + "column": 1, + "source_line": "static int nsvg__isCoordinate(const char* s)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1543, + "column": 1, + "source_line": "static int nsvg__isCoordinate(const char* s)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1550, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__parseCoordinateRaw": { + "name": "nsvg__parseCoordinateRaw", + "result_type": { + "reference": "NSVGcoordinate" + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1552, + "column": 1, + "source_line": "static NSVGcoordinate nsvg__parseCoordinateRaw(const char* str)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1552, + "column": 1, + "source_line": "static NSVGcoordinate nsvg__parseCoordinateRaw(const char* str)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1559, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__coord": { + "name": "nsvg__coord", + "result_type": { + "reference": "NSVGcoordinate" + }, + "parameters": [ + { + "name": "v", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float v" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float v" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "units", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int units" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int units" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1561, + "column": 1, + "source_line": "static NSVGcoordinate nsvg__coord(float v, int units)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1561, + "column": 1, + "source_line": "static NSVGcoordinate nsvg__coord(float v, int units)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1565, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__parseCoordinate": { + "name": "nsvg__parseCoordinate", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "orig", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float orig" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float orig" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "length", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float length" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float length" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1567, + "column": 1, + "source_line": "static float nsvg__parseCoordinate(NSVGparser* p, const char* str, float orig, float length)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1567, + "column": 1, + "source_line": "static float nsvg__parseCoordinate(NSVGparser* p, const char* str, float orig, float length)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1571, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__parseTransformArgs": { + "name": "nsvg__parseTransformArgs", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "args", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * args", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * args", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "maxNa", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int maxNa" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int maxNa" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "na", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int * na", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int * na", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1573, + "column": 1, + "source_line": "static int nsvg__parseTransformArgs(const char* str, float* args, int maxNa, int* na)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1573, + "column": 1, + "source_line": "static int nsvg__parseTransformArgs(const char* str, float* args, int maxNa, int* na)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1599, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__parseMatrix": { + "name": "nsvg__parseMatrix", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "xform", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * xform", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * xform", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1602, + "column": 1, + "source_line": "static int nsvg__parseMatrix(float* xform, const char* str)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1602, + "column": 1, + "source_line": "static int nsvg__parseMatrix(float* xform, const char* str)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1610, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__parseTranslate": { + "name": "nsvg__parseTranslate", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "xform", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * xform", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * xform", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1612, + "column": 1, + "source_line": "static int nsvg__parseTranslate(float* xform, const char* str)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1612, + "column": 1, + "source_line": "static int nsvg__parseTranslate(float* xform, const char* str)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1623, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__parseScale": { + "name": "nsvg__parseScale", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "xform", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * xform", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * xform", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1625, + "column": 1, + "source_line": "static int nsvg__parseScale(float* xform, const char* str)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1625, + "column": 1, + "source_line": "static int nsvg__parseScale(float* xform, const char* str)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1635, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__parseSkewX": { + "name": "nsvg__parseSkewX", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "xform", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * xform", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * xform", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1637, + "column": 1, + "source_line": "static int nsvg__parseSkewX(float* xform, const char* str)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1637, + "column": 1, + "source_line": "static int nsvg__parseSkewX(float* xform, const char* str)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1646, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__parseSkewY": { + "name": "nsvg__parseSkewY", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "xform", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * xform", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * xform", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1648, + "column": 1, + "source_line": "static int nsvg__parseSkewY(float* xform, const char* str)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1648, + "column": 1, + "source_line": "static int nsvg__parseSkewY(float* xform, const char* str)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1657, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__parseRotate": { + "name": "nsvg__parseRotate", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "xform", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * xform", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * xform", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1659, + "column": 1, + "source_line": "static int nsvg__parseRotate(float* xform, const char* str)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1659, + "column": 1, + "source_line": "static int nsvg__parseRotate(float* xform, const char* str)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1686, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__parseTransform": { + "name": "nsvg__parseTransform", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "xform", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * xform", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * xform", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1688, + "column": 1, + "source_line": "static void nsvg__parseTransform(float* xform, const char* str)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1688, + "column": 1, + "source_line": "static void nsvg__parseTransform(float* xform, const char* str)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1720, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__parseUrl": { + "name": "nsvg__parseUrl", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "id", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char * id", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char * id", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1722, + "column": 1, + "source_line": "static void nsvg__parseUrl(char* id, const char* str)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1722, + "column": 1, + "source_line": "static void nsvg__parseUrl(char* id, const char* str)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1733, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__parseLineCap": { + "name": "nsvg__parseLineCap", + "result_type": { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1735, + "column": 1, + "source_line": "static char nsvg__parseLineCap(const char* str)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1735, + "column": 1, + "source_line": "static char nsvg__parseLineCap(const char* str)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1745, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__parseLineJoin": { + "name": "nsvg__parseLineJoin", + "result_type": { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1747, + "column": 1, + "source_line": "static char nsvg__parseLineJoin(const char* str)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1747, + "column": 1, + "source_line": "static char nsvg__parseLineJoin(const char* str)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1757, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__parseFillRule": { + "name": "nsvg__parseFillRule", + "result_type": { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1759, + "column": 1, + "source_line": "static char nsvg__parseFillRule(const char* str)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1759, + "column": 1, + "source_line": "static char nsvg__parseFillRule(const char* str)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1767, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__parsePaintOrder": { + "name": "nsvg__parsePaintOrder", + "result_type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1769, + "column": 1, + "source_line": "static unsigned char nsvg__parsePaintOrder(const char* str)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1769, + "column": 1, + "source_line": "static unsigned char nsvg__parsePaintOrder(const char* str)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1785, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__getNextDashItem": { + "name": "nsvg__getNextDashItem", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "it", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char * it", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char * it", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1787, + "column": 1, + "source_line": "static const char* nsvg__getNextDashItem(const char* s, char* it)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1787, + "column": 1, + "source_line": "static const char* nsvg__getNextDashItem(const char* s, char* it)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1801, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__parseStrokeDashArray": { + "name": "nsvg__parseStrokeDashArray", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "strokeDashArray", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * strokeDashArray", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * strokeDashArray", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1803, + "column": 1, + "source_line": "static int nsvg__parseStrokeDashArray(NSVGparser* p, const char* str, float* strokeDashArray)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1803, + "column": 1, + "source_line": "static int nsvg__parseStrokeDashArray(NSVGparser* p, const char* str, float* strokeDashArray)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1827, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__parseStyle": { + "name": "nsvg__parseStyle", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1969, + "column": 1, + "source_line": "static void nsvg__parseStyle(NSVGparser* p, const char* str)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1969, + "column": 1, + "source_line": "static void nsvg__parseStyle(NSVGparser* p, const char* str)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1988, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "nanosvg/nanosvg.h", + "line": 1829, + "column": 1, + "source_line": "static void nsvg__parseStyle(NSVGparser* p, const char* str);" + } + ] + }, + "nsvg__applyClassStyles": { + "name": "nsvg__applyClassStyles", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "value", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * value", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * value", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1833, + "column": 1, + "source_line": "static void nsvg__applyClassStyles(NSVGparser* p, const char* value)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1833, + "column": 1, + "source_line": "static void nsvg__applyClassStyles(NSVGparser* p, const char* value)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1857, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__parseAttr": { + "name": "nsvg__parseAttr", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "name", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * name", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * name", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "value", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * value", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * value", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1859, + "column": 1, + "source_line": "static int nsvg__parseAttr(NSVGparser* p, const char* name, const char* value)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1859, + "column": 1, + "source_line": "static int nsvg__parseAttr(NSVGparser* p, const char* name, const char* value)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1935, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__parseNameValue": { + "name": "nsvg__parseNameValue", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "start", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * start", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * start", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "end", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * end", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * end", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1937, + "column": 1, + "source_line": "static int nsvg__parseNameValue(NSVGparser* p, const char* start, const char* end)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1937, + "column": 1, + "source_line": "static int nsvg__parseNameValue(NSVGparser* p, const char* start, const char* end)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 1967, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__parseAttribs": { + "name": "nsvg__parseAttribs", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "attr", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char ** attr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char ** attr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 1990, + "column": 1, + "source_line": "static void nsvg__parseAttribs(NSVGparser* p, const char** attr)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 1990, + "column": 1, + "source_line": "static void nsvg__parseAttribs(NSVGparser* p, const char** attr)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 2000, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__getArgsPerElement": { + "name": "nsvg__getArgsPerElement", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "cmd", + "type": { + "model": "CChar", + "qualifiers": [], + "source_text": "char cmd" + }, + "declared_type": { + "model": "CChar", + "qualifiers": [], + "source_text": "char cmd" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 2002, + "column": 1, + "source_line": "static int nsvg__getArgsPerElement(char cmd)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 2002, + "column": 1, + "source_line": "static int nsvg__getArgsPerElement(char cmd)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 2033, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__pathMoveTo": { + "name": "nsvg__pathMoveTo", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cpx", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpx", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpx", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cpy", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpy", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpy", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "args", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * args", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * args", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "rel", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int rel" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int rel" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 2035, + "column": 1, + "source_line": "static void nsvg__pathMoveTo(NSVGparser* p, float* cpx, float* cpy, float* args, int rel)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 2035, + "column": 1, + "source_line": "static void nsvg__pathMoveTo(NSVGparser* p, float* cpx, float* cpy, float* args, int rel)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 2045, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__pathLineTo": { + "name": "nsvg__pathLineTo", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cpx", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpx", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpx", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cpy", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpy", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpy", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "args", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * args", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * args", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "rel", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int rel" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int rel" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 2047, + "column": 1, + "source_line": "static void nsvg__pathLineTo(NSVGparser* p, float* cpx, float* cpy, float* args, int rel)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 2047, + "column": 1, + "source_line": "static void nsvg__pathLineTo(NSVGparser* p, float* cpx, float* cpy, float* args, int rel)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 2057, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__pathHLineTo": { + "name": "nsvg__pathHLineTo", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cpx", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpx", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpx", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cpy", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpy", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpy", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "args", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * args", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * args", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "rel", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int rel" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int rel" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 2059, + "column": 1, + "source_line": "static void nsvg__pathHLineTo(NSVGparser* p, float* cpx, float* cpy, float* args, int rel)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 2059, + "column": 1, + "source_line": "static void nsvg__pathHLineTo(NSVGparser* p, float* cpx, float* cpy, float* args, int rel)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 2066, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__pathVLineTo": { + "name": "nsvg__pathVLineTo", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cpx", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpx", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpx", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cpy", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpy", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpy", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "args", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * args", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * args", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "rel", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int rel" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int rel" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 2068, + "column": 1, + "source_line": "static void nsvg__pathVLineTo(NSVGparser* p, float* cpx, float* cpy, float* args, int rel)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 2068, + "column": 1, + "source_line": "static void nsvg__pathVLineTo(NSVGparser* p, float* cpx, float* cpy, float* args, int rel)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 2075, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__pathCubicBezTo": { + "name": "nsvg__pathCubicBezTo", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cpx", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpx", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpx", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cpy", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpy", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpy", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cpx2", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpx2", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpx2", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cpy2", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpy2", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpy2", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "args", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * args", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * args", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "rel", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int rel" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int rel" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 2077, + "column": 1, + "source_line": "static void nsvg__pathCubicBezTo(NSVGparser* p, float* cpx, float* cpy," + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 2077, + "column": 1, + "source_line": "static void nsvg__pathCubicBezTo(NSVGparser* p, float* cpx, float* cpy," + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 2104, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__pathCubicBezShortTo": { + "name": "nsvg__pathCubicBezShortTo", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cpx", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpx", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpx", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cpy", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpy", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpy", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cpx2", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpx2", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpx2", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cpy2", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpy2", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpy2", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "args", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * args", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * args", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "rel", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int rel" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int rel" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 2106, + "column": 1, + "source_line": "static void nsvg__pathCubicBezShortTo(NSVGparser* p, float* cpx, float* cpy," + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 2106, + "column": 1, + "source_line": "static void nsvg__pathCubicBezShortTo(NSVGparser* p, float* cpx, float* cpy," + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 2134, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__pathQuadBezTo": { + "name": "nsvg__pathQuadBezTo", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cpx", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpx", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpx", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cpy", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpy", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpy", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cpx2", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpx2", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpx2", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cpy2", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpy2", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpy2", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "args", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * args", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * args", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "rel", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int rel" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int rel" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 2136, + "column": 1, + "source_line": "static void nsvg__pathQuadBezTo(NSVGparser* p, float* cpx, float* cpy," + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 2136, + "column": 1, + "source_line": "static void nsvg__pathQuadBezTo(NSVGparser* p, float* cpx, float* cpy," + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 2168, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__pathQuadBezShortTo": { + "name": "nsvg__pathQuadBezShortTo", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cpx", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpx", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpx", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cpy", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpy", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpy", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cpx2", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpx2", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpx2", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cpy2", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpy2", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpy2", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "args", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * args", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * args", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "rel", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int rel" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int rel" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 2170, + "column": 1, + "source_line": "static void nsvg__pathQuadBezShortTo(NSVGparser* p, float* cpx, float* cpy," + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 2170, + "column": 1, + "source_line": "static void nsvg__pathQuadBezShortTo(NSVGparser* p, float* cpx, float* cpy," + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 2201, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__sqr": { + "name": "nsvg__sqr", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 2203, + "column": 1, + "source_line": "static float nsvg__sqr(float x) { return x*x; }" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 2203, + "column": 1, + "source_line": "static float nsvg__sqr(float x) { return x*x; }" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 2203, + "column": 47, + "source_line": "static float nsvg__sqr(float x) { return x*x; }" + }, + "declaration_locations": [] + }, + "nsvg__vmag": { + "name": "nsvg__vmag", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 2204, + "column": 1, + "source_line": "static float nsvg__vmag(float x, float y) { return sqrtf(x*x + y*y); }" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 2204, + "column": 1, + "source_line": "static float nsvg__vmag(float x, float y) { return sqrtf(x*x + y*y); }" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 2204, + "column": 70, + "source_line": "static float nsvg__vmag(float x, float y) { return sqrtf(x*x + y*y); }" + }, + "declaration_locations": [] + }, + "nsvg__vecrat": { + "name": "nsvg__vecrat", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "ux", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float ux" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float ux" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "uy", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float uy" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float uy" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "vx", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float vx" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float vx" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "vy", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float vy" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float vy" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 2206, + "column": 1, + "source_line": "static float nsvg__vecrat(float ux, float uy, float vx, float vy)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 2206, + "column": 1, + "source_line": "static float nsvg__vecrat(float ux, float uy, float vx, float vy)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 2209, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__vecang": { + "name": "nsvg__vecang", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "ux", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float ux" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float ux" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "uy", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float uy" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float uy" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "vx", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float vx" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float vx" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "vy", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float vy" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float vy" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 2211, + "column": 1, + "source_line": "static float nsvg__vecang(float ux, float uy, float vx, float vy)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 2211, + "column": 1, + "source_line": "static float nsvg__vecang(float ux, float uy, float vx, float vy)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 2217, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__pathArcTo": { + "name": "nsvg__pathArcTo", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cpx", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpx", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpx", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cpy", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpy", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * cpy", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "args", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * args", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * args", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "rel", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int rel" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int rel" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 2219, + "column": 1, + "source_line": "static void nsvg__pathArcTo(NSVGparser* p, float* cpx, float* cpy, float* args, int rel)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 2219, + "column": 1, + "source_line": "static void nsvg__pathArcTo(NSVGparser* p, float* cpx, float* cpy, float* args, int rel)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 2338, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__parsePath": { + "name": "nsvg__parsePath", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "attr", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char ** attr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char ** attr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 2340, + "column": 1, + "source_line": "static void nsvg__parsePath(NSVGparser* p, const char** attr)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 2340, + "column": 1, + "source_line": "static void nsvg__parsePath(NSVGparser* p, const char** attr)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 2486, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__parseRect": { + "name": "nsvg__parseRect", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "attr", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char ** attr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char ** attr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 2488, + "column": 1, + "source_line": "static void nsvg__parseRect(NSVGparser* p, const char** attr)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 2488, + "column": 1, + "source_line": "static void nsvg__parseRect(NSVGparser* p, const char** attr)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 2541, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__parseCircle": { + "name": "nsvg__parseCircle", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "attr", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char ** attr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char ** attr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 2543, + "column": 1, + "source_line": "static void nsvg__parseCircle(NSVGparser* p, const char** attr)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 2543, + "column": 1, + "source_line": "static void nsvg__parseCircle(NSVGparser* p, const char** attr)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 2571, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__parseEllipse": { + "name": "nsvg__parseEllipse", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "attr", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char ** attr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char ** attr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 2573, + "column": 1, + "source_line": "static void nsvg__parseEllipse(NSVGparser* p, const char** attr)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 2573, + "column": 1, + "source_line": "static void nsvg__parseEllipse(NSVGparser* p, const char** attr)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 2604, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__parseLine": { + "name": "nsvg__parseLine", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "attr", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char ** attr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char ** attr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 2606, + "column": 1, + "source_line": "static void nsvg__parseLine(NSVGparser* p, const char** attr)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 2606, + "column": 1, + "source_line": "static void nsvg__parseLine(NSVGparser* p, const char** attr)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 2631, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__parsePoly": { + "name": "nsvg__parsePoly", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "attr", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char ** attr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char ** attr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "closeFlag", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int closeFlag" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int closeFlag" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 2633, + "column": 1, + "source_line": "static void nsvg__parsePoly(NSVGparser* p, const char** attr, int closeFlag)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 2633, + "column": 1, + "source_line": "static void nsvg__parsePoly(NSVGparser* p, const char** attr, int closeFlag)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 2667, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__parseSVG": { + "name": "nsvg__parseSVG", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "attr", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char ** attr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char ** attr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 2669, + "column": 1, + "source_line": "static void nsvg__parseSVG(NSVGparser* p, const char** attr)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 2669, + "column": 1, + "source_line": "static void nsvg__parseSVG(NSVGparser* p, const char** attr)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 2722, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__parseGradient": { + "name": "nsvg__parseGradient", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "attr", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char ** attr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char ** attr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "type", + "type": { + "model": "CSignedChar", + "qualifiers": [], + "source_text": "signed char type" + }, + "declared_type": { + "model": "CSignedChar", + "qualifiers": [], + "source_text": "signed char type" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 2724, + "column": 1, + "source_line": "static void nsvg__parseGradient(NSVGparser* p, const char** attr, signed char type)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 2724, + "column": 1, + "source_line": "static void nsvg__parseGradient(NSVGparser* p, const char** attr, signed char type)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 2792, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__parseGradientStop": { + "name": "nsvg__parseGradientStop", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "attr", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char ** attr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char ** attr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 2794, + "column": 1, + "source_line": "static void nsvg__parseGradientStop(NSVGparser* p, const char** attr)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 2794, + "column": 1, + "source_line": "static void nsvg__parseGradientStop(NSVGparser* p, const char** attr)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 2834, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__startElement": { + "name": "nsvg__startElement", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "ud", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * ud", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * ud", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "el", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * el", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * el", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "attr", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char ** attr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char ** attr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 2836, + "column": 1, + "source_line": "static void nsvg__startElement(void* ud, const char* el, const char** attr)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 2836, + "column": 1, + "source_line": "static void nsvg__startElement(void* ud, const char* el, const char** attr)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 2900, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__endElement": { + "name": "nsvg__endElement", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "ud", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * ud", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * ud", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "el", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * el", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * el", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 2902, + "column": 1, + "source_line": "static void nsvg__endElement(void* ud, const char* el)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 2902, + "column": 1, + "source_line": "static void nsvg__endElement(void* ud, const char* el)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 2915, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__strndup": { + "name": "nsvg__strndup", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "reference": "size_t" + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 2917, + "column": 1, + "source_line": "static char *nsvg__strndup(const char *s, size_t n)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 2917, + "column": 1, + "source_line": "static char *nsvg__strndup(const char *s, size_t n)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 2926, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__content": { + "name": "nsvg__content", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "ud", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * ud", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * ud", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 2928, + "column": 1, + "source_line": "static void nsvg__content(void* ud, const char* s)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 2928, + "column": 1, + "source_line": "static void nsvg__content(void* ud, const char* s)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 3010, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__imageBounds": { + "name": "nsvg__imageBounds", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "bounds", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * bounds", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * bounds", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 3012, + "column": 1, + "source_line": "static void nsvg__imageBounds(NSVGparser* p, float* bounds)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 3012, + "column": 1, + "source_line": "static void nsvg__imageBounds(NSVGparser* p, float* bounds)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 3030, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__viewAlign": { + "name": "nsvg__viewAlign", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "content", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float content" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float content" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "container", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float container" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float container" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "type", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int type" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int type" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 3032, + "column": 1, + "source_line": "static float nsvg__viewAlign(float content, float container, int type)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 3032, + "column": 1, + "source_line": "static float nsvg__viewAlign(float content, float container, int type)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 3040, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__scaleGradient": { + "name": "nsvg__scaleGradient", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "grad", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGgradient * grad", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGgradient" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGgradient * grad", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGgradient" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "tx", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float tx" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float tx" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ty", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float ty" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float ty" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "sx", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float sx" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float sx" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "sy", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float sy" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float sy" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 3042, + "column": 1, + "source_line": "static void nsvg__scaleGradient(NSVGgradient* grad, float tx, float ty, float sx, float sy)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 3042, + "column": 1, + "source_line": "static void nsvg__scaleGradient(NSVGgradient* grad, float tx, float ty, float sx, float sy)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 3050, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__scaleToViewbox": { + "name": "nsvg__scaleToViewbox", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "units", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * units", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * units", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 3052, + "column": 1, + "source_line": "static void nsvg__scaleToViewbox(NSVGparser* p, const char* units)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 3052, + "column": 1, + "source_line": "static void nsvg__scaleToViewbox(NSVGparser* p, const char* units)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 3141, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__createGradients": { + "name": "nsvg__createGradients", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGparser * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGparser" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 3143, + "column": 1, + "source_line": "static void nsvg__createGradients(NSVGparser* p)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 3143, + "column": 1, + "source_line": "static void nsvg__createGradients(NSVGparser* p)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 3171, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvgParse": { + "name": "nsvgParse", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGimage", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGimage" + } + ] + }, + "parameters": [ + { + "name": "input", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char * input", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char * input", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "units", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * units", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * units", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dpi", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dpi" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dpi" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 3173, + "column": 1, + "source_line": "NSVGimage* nsvgParse(char* input, const char* units, float dpi)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 3173, + "column": 1, + "source_line": "NSVGimage* nsvgParse(char* input, const char* units, float dpi)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 3198, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvgParseFromFile": { + "name": "nsvgParseFromFile", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGimage", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGimage" + } + ] + }, + "parameters": [ + { + "name": "filename", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * filename", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * filename", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "units", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * units", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * units", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dpi", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dpi" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dpi" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 3200, + "column": 1, + "source_line": "NSVGimage* nsvgParseFromFile(const char* filename, const char* units, float dpi)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 3200, + "column": 1, + "source_line": "NSVGimage* nsvgParseFromFile(const char* filename, const char* units, float dpi)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 3227, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvgDuplicatePath": { + "name": "nsvgDuplicatePath", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpath", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpath" + } + ] + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpath * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpath" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpath * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpath" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 3229, + "column": 1, + "source_line": "NSVGpath* nsvgDuplicatePath(NSVGpath* p)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 3229, + "column": 1, + "source_line": "NSVGpath* nsvgDuplicatePath(NSVGpath* p)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 3257, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvgDelete": { + "name": "nsvgDelete", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "image", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGimage * image", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGimage" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGimage * image", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGimage" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 3259, + "column": 1, + "source_line": "void nsvgDelete(NSVGimage* image)" + }, + "start": { + "filename": "nanosvg/nanosvg.h", + "line": 3259, + "column": 1, + "source_line": "void nsvgDelete(NSVGimage* image)" + }, + "end": { + "filename": "nanosvg/nanosvg.h", + "line": 3273, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvgCreateRasterizer": { + "name": "nsvgCreateRasterizer", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "parameters": [], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 153, + "column": 1, + "source_line": "NSVGrasterizer* nsvgCreateRasterizer(void)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 153, + "column": 1, + "source_line": "NSVGrasterizer* nsvgCreateRasterizer(void)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 167, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvgDeleteRasterizer": { + "name": "nsvgDeleteRasterizer", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "r", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 169, + "column": 1, + "source_line": "void nsvgDeleteRasterizer(NSVGrasterizer* r)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 169, + "column": 1, + "source_line": "void nsvgDeleteRasterizer(NSVGrasterizer* r)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 188, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__nextPage": { + "name": "nsvg__nextPage", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGmemPage", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGmemPage" + } + ] + }, + "parameters": [ + { + "name": "r", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cur", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGmemPage * cur", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGmemPage" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGmemPage * cur", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGmemPage" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 190, + "column": 1, + "source_line": "static NSVGmemPage* nsvg__nextPage(NSVGrasterizer* r, NSVGmemPage* cur)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 190, + "column": 1, + "source_line": "static NSVGmemPage* nsvg__nextPage(NSVGrasterizer* r, NSVGmemPage* cur)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 211, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__resetPool": { + "name": "nsvg__resetPool", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "r", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 213, + "column": 1, + "source_line": "static void nsvg__resetPool(NSVGrasterizer* r)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 213, + "column": 1, + "source_line": "static void nsvg__resetPool(NSVGrasterizer* r)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 221, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__alloc": { + "name": "nsvg__alloc", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "parameters": [ + { + "name": "r", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "size", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int size" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int size" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 223, + "column": 1, + "source_line": "static unsigned char* nsvg__alloc(NSVGrasterizer* r, int size)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 223, + "column": 1, + "source_line": "static unsigned char* nsvg__alloc(NSVGrasterizer* r, int size)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 233, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__ptEquals": { + "name": "nsvg__ptEquals", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "x1", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x1" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y1", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y1" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x2", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x2" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x2" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y2", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y2" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y2" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "tol", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float tol" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float tol" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 235, + "column": 1, + "source_line": "static int nsvg__ptEquals(float x1, float y1, float x2, float y2, float tol)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 235, + "column": 1, + "source_line": "static int nsvg__ptEquals(float x1, float y1, float x2, float y2, float tol)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 240, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__addPathPoint": { + "name": "nsvg__addPathPoint", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "r", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "flags", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int flags" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int flags" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 242, + "column": 1, + "source_line": "static void nsvg__addPathPoint(NSVGrasterizer* r, float x, float y, int flags)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 242, + "column": 1, + "source_line": "static void nsvg__addPathPoint(NSVGrasterizer* r, float x, float y, int flags)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 265, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__appendPathPoint": { + "name": "nsvg__appendPathPoint", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "r", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "pt", + "type": { + "reference": "NSVGpoint" + }, + "declared_type": { + "reference": "NSVGpoint" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 267, + "column": 1, + "source_line": "static void nsvg__appendPathPoint(NSVGrasterizer* r, NSVGpoint pt)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 267, + "column": 1, + "source_line": "static void nsvg__appendPathPoint(NSVGrasterizer* r, NSVGpoint pt)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 276, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__duplicatePoints": { + "name": "nsvg__duplicatePoints", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "r", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 278, + "column": 1, + "source_line": "static void nsvg__duplicatePoints(NSVGrasterizer* r)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 278, + "column": 1, + "source_line": "static void nsvg__duplicatePoints(NSVGrasterizer* r)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 288, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__addEdge": { + "name": "nsvg__addEdge", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "r", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x0", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x0" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y0", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y0" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x1", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x1" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y1", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y1" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y1" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 290, + "column": 1, + "source_line": "static void nsvg__addEdge(NSVGrasterizer* r, float x0, float y0, float x1, float y1)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 290, + "column": 1, + "source_line": "static void nsvg__addEdge(NSVGrasterizer* r, float x0, float y0, float x1, float y1)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 320, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__normalize": { + "name": "nsvg__normalize", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 322, + "column": 1, + "source_line": "static float nsvg__normalize(float *x, float* y)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 322, + "column": 1, + "source_line": "static float nsvg__normalize(float *x, float* y)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 331, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__absf": { + "name": "nsvg__absf", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 333, + "column": 1, + "source_line": "static float nsvg__absf(float x) { return x < 0 ? -x : x; }" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 333, + "column": 1, + "source_line": "static float nsvg__absf(float x) { return x < 0 ? -x : x; }" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 333, + "column": 59, + "source_line": "static float nsvg__absf(float x) { return x < 0 ? -x : x; }" + }, + "declaration_locations": [] + }, + "nsvg__roundf": { + "name": "nsvg__roundf", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 334, + "column": 1, + "source_line": "static float nsvg__roundf(float x) { return (x >= 0) ? floorf(x + 0.5) : ceilf(x - 0.5); }" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 334, + "column": 1, + "source_line": "static float nsvg__roundf(float x) { return (x >= 0) ? floorf(x + 0.5) : ceilf(x - 0.5); }" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 334, + "column": 90, + "source_line": "static float nsvg__roundf(float x) { return (x >= 0) ? floorf(x + 0.5) : ceilf(x - 0.5); }" + }, + "declaration_locations": [] + }, + "nsvg__flattenCubicBez": { + "name": "nsvg__flattenCubicBez", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "r", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x1", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x1" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y1", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y1" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x2", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x2" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x2" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y2", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y2" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y2" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x3", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x3" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x3" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y3", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y3" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y3" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x4", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x4" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x4" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y4", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y4" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y4" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "level", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int level" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int level" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "type", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int type" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int type" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 336, + "column": 1, + "source_line": "static void nsvg__flattenCubicBez(NSVGrasterizer* r," + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 336, + "column": 1, + "source_line": "static void nsvg__flattenCubicBez(NSVGrasterizer* r," + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 372, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__flattenShape": { + "name": "nsvg__flattenShape", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "r", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "shape", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGshape * shape", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGshape" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGshape * shape", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGshape" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "scale", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float scale" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float scale" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 374, + "column": 1, + "source_line": "static void nsvg__flattenShape(NSVGrasterizer* r, NSVGshape* shape, float scale)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 374, + "column": 1, + "source_line": "static void nsvg__flattenShape(NSVGrasterizer* r, NSVGshape* shape, float scale)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 393, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__initClosed": { + "name": "nsvg__initClosed", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "left", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * left", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * left", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "right", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * right", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * right", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p0", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * p0", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * p0", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p1", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * p1", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * p1", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "lineWidth", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float lineWidth" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float lineWidth" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 402, + "column": 1, + "source_line": "static void nsvg__initClosed(NSVGpoint* left, NSVGpoint* right, NSVGpoint* p0, NSVGpoint* p1, float lineWidth)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 402, + "column": 1, + "source_line": "static void nsvg__initClosed(NSVGpoint* left, NSVGpoint* right, NSVGpoint* p0, NSVGpoint* p1, float lineWidth)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 414, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__buttCap": { + "name": "nsvg__buttCap", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "r", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "left", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * left", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * left", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "right", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * right", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * right", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dx", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dx" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dx" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dy", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dy" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dy" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "lineWidth", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float lineWidth" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float lineWidth" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "connect", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int connect" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int connect" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 416, + "column": 1, + "source_line": "static void nsvg__buttCap(NSVGrasterizer* r, NSVGpoint* left, NSVGpoint* right, NSVGpoint* p, float dx, float dy, float lineWidth, int connect)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 416, + "column": 1, + "source_line": "static void nsvg__buttCap(NSVGrasterizer* r, NSVGpoint* left, NSVGpoint* right, NSVGpoint* p, float dx, float dy, float lineWidth, int connect)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 432, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__squareCap": { + "name": "nsvg__squareCap", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "r", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "left", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * left", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * left", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "right", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * right", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * right", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dx", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dx" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dx" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dy", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dy" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dy" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "lineWidth", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float lineWidth" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float lineWidth" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "connect", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int connect" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int connect" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 434, + "column": 1, + "source_line": "static void nsvg__squareCap(NSVGrasterizer* r, NSVGpoint* left, NSVGpoint* right, NSVGpoint* p, float dx, float dy, float lineWidth, int connect)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 434, + "column": 1, + "source_line": "static void nsvg__squareCap(NSVGrasterizer* r, NSVGpoint* left, NSVGpoint* right, NSVGpoint* p, float dx, float dy, float lineWidth, int connect)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 450, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__roundCap": { + "name": "nsvg__roundCap", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "r", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "left", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * left", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * left", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "right", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * right", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * right", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dx", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dx" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dx" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dy", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dy" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dy" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "lineWidth", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float lineWidth" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float lineWidth" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ncap", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ncap" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ncap" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "connect", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int connect" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int connect" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 456, + "column": 1, + "source_line": "static void nsvg__roundCap(NSVGrasterizer* r, NSVGpoint* left, NSVGpoint* right, NSVGpoint* p, float dx, float dy, float lineWidth, int ncap, int connect)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 456, + "column": 1, + "source_line": "static void nsvg__roundCap(NSVGrasterizer* r, NSVGpoint* left, NSVGpoint* right, NSVGpoint* p, float dx, float dy, float lineWidth, int ncap, int connect)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 490, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__bevelJoin": { + "name": "nsvg__bevelJoin", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "r", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "left", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * left", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * left", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "right", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * right", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * right", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p0", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * p0", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * p0", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p1", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * p1", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * p1", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "lineWidth", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float lineWidth" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float lineWidth" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 492, + "column": 1, + "source_line": "static void nsvg__bevelJoin(NSVGrasterizer* r, NSVGpoint* left, NSVGpoint* right, NSVGpoint* p0, NSVGpoint* p1, float lineWidth)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 492, + "column": 1, + "source_line": "static void nsvg__bevelJoin(NSVGrasterizer* r, NSVGpoint* left, NSVGpoint* right, NSVGpoint* p0, NSVGpoint* p1, float lineWidth)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 510, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__miterJoin": { + "name": "nsvg__miterJoin", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "r", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "left", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * left", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * left", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "right", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * right", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * right", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p0", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * p0", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * p0", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p1", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * p1", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * p1", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "lineWidth", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float lineWidth" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float lineWidth" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 512, + "column": 1, + "source_line": "static void nsvg__miterJoin(NSVGrasterizer* r, NSVGpoint* left, NSVGpoint* right, NSVGpoint* p0, NSVGpoint* p1, float lineWidth)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 512, + "column": 1, + "source_line": "static void nsvg__miterJoin(NSVGrasterizer* r, NSVGpoint* left, NSVGpoint* right, NSVGpoint* p0, NSVGpoint* p1, float lineWidth)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 546, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__roundJoin": { + "name": "nsvg__roundJoin", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "r", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "left", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * left", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * left", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "right", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * right", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * right", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p0", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * p0", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * p0", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p1", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * p1", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * p1", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "lineWidth", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float lineWidth" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float lineWidth" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ncap", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ncap" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ncap" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 548, + "column": 1, + "source_line": "static void nsvg__roundJoin(NSVGrasterizer* r, NSVGpoint* left, NSVGpoint* right, NSVGpoint* p0, NSVGpoint* p1, float lineWidth, int ncap)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 548, + "column": 1, + "source_line": "static void nsvg__roundJoin(NSVGrasterizer* r, NSVGpoint* left, NSVGpoint* right, NSVGpoint* p0, NSVGpoint* p1, float lineWidth, int ncap)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 587, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__straightJoin": { + "name": "nsvg__straightJoin", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "r", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "left", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * left", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * left", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "right", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * right", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * right", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p1", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * p1", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * p1", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "lineWidth", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float lineWidth" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float lineWidth" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 589, + "column": 1, + "source_line": "static void nsvg__straightJoin(NSVGrasterizer* r, NSVGpoint* left, NSVGpoint* right, NSVGpoint* p1, float lineWidth)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 589, + "column": 1, + "source_line": "static void nsvg__straightJoin(NSVGrasterizer* r, NSVGpoint* left, NSVGpoint* right, NSVGpoint* p1, float lineWidth)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 600, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__curveDivs": { + "name": "nsvg__curveDivs", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "r", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float r" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float r" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "arc", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float arc" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float arc" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "tol", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float tol" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float tol" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 602, + "column": 1, + "source_line": "static int nsvg__curveDivs(float r, float arc, float tol)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 602, + "column": 1, + "source_line": "static int nsvg__curveDivs(float r, float arc, float tol)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 608, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__expandStroke": { + "name": "nsvg__expandStroke", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "r", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "points", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * points", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpoint * points", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpoint" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "npoints", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int npoints" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int npoints" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "closed", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int closed" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int closed" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "lineJoin", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int lineJoin" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int lineJoin" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "lineCap", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int lineCap" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int lineCap" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "lineWidth", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float lineWidth" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float lineWidth" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 610, + "column": 1, + "source_line": "static void nsvg__expandStroke(NSVGrasterizer* r, NSVGpoint* points, int npoints, int closed, int lineJoin, int lineCap, float lineWidth)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 610, + "column": 1, + "source_line": "static void nsvg__expandStroke(NSVGrasterizer* r, NSVGpoint* points, int npoints, int closed, int lineJoin, int lineCap, float lineWidth)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 679, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__prepareStroke": { + "name": "nsvg__prepareStroke", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "r", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "miterLimit", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float miterLimit" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float miterLimit" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "lineJoin", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int lineJoin" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int lineJoin" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 681, + "column": 1, + "source_line": "static void nsvg__prepareStroke(NSVGrasterizer* r, float miterLimit, int lineJoin)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 681, + "column": 1, + "source_line": "static void nsvg__prepareStroke(NSVGrasterizer* r, float miterLimit, int lineJoin)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 736, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__flattenShapeStroke": { + "name": "nsvg__flattenShapeStroke", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "r", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "shape", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGshape * shape", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGshape" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGshape * shape", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGshape" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "scale", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float scale" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float scale" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 738, + "column": 1, + "source_line": "static void nsvg__flattenShapeStroke(NSVGrasterizer* r, NSVGshape* shape, float scale)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 738, + "column": 1, + "source_line": "static void nsvg__flattenShapeStroke(NSVGrasterizer* r, NSVGshape* shape, float scale)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 847, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__cmpEdge": { + "name": "nsvg__cmpEdge", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const void *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [ + "const" + ], + "source_text": "const void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const void *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [ + "const" + ], + "source_text": "const void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "q", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const void *q", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [ + "const" + ], + "source_text": "const void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const void *q", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [ + "const" + ], + "source_text": "const void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 849, + "column": 1, + "source_line": "static int nsvg__cmpEdge(const void *p, const void *q)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 849, + "column": 1, + "source_line": "static int nsvg__cmpEdge(const void *p, const void *q)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 857, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__addActive": { + "name": "nsvg__addActive", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGactiveEdge", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGactiveEdge" + } + ] + }, + "parameters": [ + { + "name": "r", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "e", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGedge * e", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGedge" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGedge * e", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGedge" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "startPoint", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float startPoint" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float startPoint" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 860, + "column": 1, + "source_line": "static NSVGactiveEdge* nsvg__addActive(NSVGrasterizer* r, NSVGedge* e, float startPoint)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 860, + "column": 1, + "source_line": "static NSVGactiveEdge* nsvg__addActive(NSVGrasterizer* r, NSVGedge* e, float startPoint)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 888, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__freeActive": { + "name": "nsvg__freeActive", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "r", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "z", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGactiveEdge * z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGactiveEdge" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGactiveEdge * z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGactiveEdge" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 890, + "column": 1, + "source_line": "static void nsvg__freeActive(NSVGrasterizer* r, NSVGactiveEdge* z)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 890, + "column": 1, + "source_line": "static void nsvg__freeActive(NSVGrasterizer* r, NSVGactiveEdge* z)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 894, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__fillScanline": { + "name": "nsvg__fillScanline", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "scanline", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char * scanline", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char * scanline", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "maxWeight", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int maxWeight" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int maxWeight" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "xmin", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int * xmin", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int * xmin", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "xmax", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int * xmax", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int * xmax", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 896, + "column": 1, + "source_line": "static void nsvg__fillScanline(unsigned char* scanline, int len, int x0, int x1, int maxWeight, int* xmin, int* xmax)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 896, + "column": 1, + "source_line": "static void nsvg__fillScanline(unsigned char* scanline, int len, int x0, int x1, int maxWeight, int* xmin, int* xmax)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 921, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__fillActiveEdges": { + "name": "nsvg__fillActiveEdges", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "scanline", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char * scanline", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char * scanline", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "e", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGactiveEdge * e", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGactiveEdge" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGactiveEdge * e", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGactiveEdge" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "maxWeight", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int maxWeight" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int maxWeight" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "xmin", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int * xmin", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int * xmin", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "xmax", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int * xmax", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int * xmax", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "fillRule", + "type": { + "model": "CChar", + "qualifiers": [], + "source_text": "char fillRule" + }, + "declared_type": { + "model": "CChar", + "qualifiers": [], + "source_text": "char fillRule" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 926, + "column": 1, + "source_line": "static void nsvg__fillActiveEdges(unsigned char* scanline, int len, NSVGactiveEdge* e, int maxWeight, int* xmin, int* xmax, char fillRule)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 926, + "column": 1, + "source_line": "static void nsvg__fillActiveEdges(unsigned char* scanline, int len, NSVGactiveEdge* e, int maxWeight, int* xmin, int* xmax, char fillRule)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 958, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__clampf": { + "name": "nsvg__clampf", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float a" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float a" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mn", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float mn" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float mn" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mx", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float mx" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float mx" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 960, + "column": 1, + "source_line": "static float nsvg__clampf(float a, float mn, float mx) {" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 960, + "column": 1, + "source_line": "static float nsvg__clampf(float a, float mn, float mx) {" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 964, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__RGBA": { + "name": "nsvg__RGBA", + "result_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int" + }, + "parameters": [ + { + "name": "r", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char r" + }, + "declared_type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char r" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "g", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char g" + }, + "declared_type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char g" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char b" + }, + "declared_type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char b" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "a", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char a" + }, + "declared_type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char a" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 966, + "column": 1, + "source_line": "static unsigned int nsvg__RGBA(unsigned char r, unsigned char g, unsigned char b, unsigned char a)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 966, + "column": 1, + "source_line": "static unsigned int nsvg__RGBA(unsigned char r, unsigned char g, unsigned char b, unsigned char a)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 969, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__lerpRGBA": { + "name": "nsvg__lerpRGBA", + "result_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int" + }, + "parameters": [ + { + "name": "c0", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int c0" + }, + "declared_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int c0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c1", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int c1" + }, + "declared_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int c1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "u", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float u" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float u" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 971, + "column": 1, + "source_line": "static unsigned int nsvg__lerpRGBA(unsigned int c0, unsigned int c1, float u)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 971, + "column": 1, + "source_line": "static unsigned int nsvg__lerpRGBA(unsigned int c0, unsigned int c1, float u)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 979, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__applyOpacity": { + "name": "nsvg__applyOpacity", + "result_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int" + }, + "parameters": [ + { + "name": "c", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int c" + }, + "declared_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int c" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "u", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float u" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float u" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 981, + "column": 1, + "source_line": "static unsigned int nsvg__applyOpacity(unsigned int c, float u)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 981, + "column": 1, + "source_line": "static unsigned int nsvg__applyOpacity(unsigned int c, float u)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 989, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__div255": { + "name": "nsvg__div255", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [ + "inline" + ], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 991, + "column": 1, + "source_line": "static inline int nsvg__div255(int x)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 991, + "column": 1, + "source_line": "static inline int nsvg__div255(int x)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 994, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__scanlineSolid": { + "name": "nsvg__scanlineSolid", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "dst", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char * dst", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char * dst", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "count", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int count" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int count" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cover", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char * cover", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char * cover", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "tx", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float tx" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float tx" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ty", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float ty" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float ty" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "scale", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float scale" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float scale" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cache", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGcachedPaint * cache", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGcachedPaint" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGcachedPaint * cache", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGcachedPaint" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 996, + "column": 1, + "source_line": "static void nsvg__scanlineSolid(unsigned char* dst, int count, unsigned char* cover, int x, int y," + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 996, + "column": 1, + "source_line": "static void nsvg__scanlineSolid(unsigned char* dst, int count, unsigned char* cover, int x, int y," + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 1122, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__rasterizeSortedEdges": { + "name": "nsvg__rasterizeSortedEdges", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "r", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer *r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer *r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "tx", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float tx" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float tx" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ty", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float ty" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float ty" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "scale", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float scale" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float scale" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cache", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGcachedPaint * cache", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGcachedPaint" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGcachedPaint * cache", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGcachedPaint" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "fillRule", + "type": { + "model": "CChar", + "qualifiers": [], + "source_text": "char fillRule" + }, + "declared_type": { + "model": "CChar", + "qualifiers": [], + "source_text": "char fillRule" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 1124, + "column": 1, + "source_line": "static void nsvg__rasterizeSortedEdges(NSVGrasterizer *r, float tx, float ty, float scale, NSVGcachedPaint* cache, char fillRule)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 1124, + "column": 1, + "source_line": "static void nsvg__rasterizeSortedEdges(NSVGrasterizer *r, float tx, float ty, float scale, NSVGcachedPaint* cache, char fillRule)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 1210, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__unpremultiplyAlpha": { + "name": "nsvg__unpremultiplyAlpha", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "image", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char * image", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char * image", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "w", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "h", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "stride", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int stride" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int stride" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 1212, + "column": 1, + "source_line": "static void nsvg__unpremultiplyAlpha(unsigned char* image, int w, int h, int stride)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 1212, + "column": 1, + "source_line": "static void nsvg__unpremultiplyAlpha(unsigned char* image, int w, int h, int stride)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 1269, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvg__initPaint": { + "name": "nsvg__initPaint", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "cache", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGcachedPaint * cache", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGcachedPaint" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGcachedPaint * cache", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGcachedPaint" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "paint", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpaint * paint", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpaint" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGpaint * paint", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGpaint" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "opacity", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float opacity" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float opacity" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 1272, + "column": 1, + "source_line": "static void nsvg__initPaint(NSVGcachedPaint* cache, NSVGpaint* paint, float opacity)" + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 1272, + "column": 1, + "source_line": "static void nsvg__initPaint(NSVGcachedPaint* cache, NSVGpaint* paint, float opacity)" + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 1331, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "nsvgRasterize": { + "name": "nsvgRasterize", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "r", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGrasterizer * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGrasterizer" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "image", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGimage * image", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGimage" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "NSVGimage * image", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "NSVGimage" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "tx", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float tx" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float tx" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ty", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float ty" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float ty" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "scale", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float scale" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float scale" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dst", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char * dst", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char * dst", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "w", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "h", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "stride", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int stride" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int stride" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 1375, + "column": 1, + "source_line": "void nsvgRasterize(NSVGrasterizer* r," + }, + "start": { + "filename": "nanosvg/nanosvgrast.h", + "line": 1375, + "column": 1, + "source_line": "void nsvgRasterize(NSVGrasterizer* r," + }, + "end": { + "filename": "nanosvg/nanosvgrast.h", + "line": 1468, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + } + }, + "structs": { + "NSVGcoordinate": { + "reference": "struct NSVGcoordinate" + }, + "NSVGlinearData": { + "reference": "struct NSVGlinearData" + }, + "NSVGradialData": { + "reference": "struct NSVGradialData" + }, + "NSVGgradientData": { + "reference": "struct NSVGgradientData" + }, + "NSVGattrib": { + "reference": "struct NSVGattrib" + }, + "NSVGstyleDeclaration": { + "reference": "struct NSVGstyleDeclaration" + }, + "NSVGparser": { + "reference": "struct NSVGparser" + }, + "NSVGNamedColor": { + "reference": "struct NSVGNamedColor" + }, + "NSVGedge": { + "reference": "struct NSVGedge" + }, + "NSVGpoint": { + "reference": "struct NSVGpoint" + }, + "NSVGactiveEdge": { + "reference": "struct NSVGactiveEdge" + }, + "NSVGmemPage": { + "reference": "struct NSVGmemPage" + }, + "NSVGcachedPaint": { + "reference": "struct NSVGcachedPaint" + }, + "NSVGrasterizer": { + "reference": "struct NSVGrasterizer" + } + }, + "unions": {}, + "enums": { + "NSVGgradientUnits": { + "reference": "enum NSVGgradientUnits" + }, + "NSVGunits": { + "reference": "enum NSVGunits" + }, + "NSVGpointFlags": { + "reference": "enum NSVGpointFlags" + } + }, + "typedefs": { + "NSVGcoordinate": { + "reference": "NSVGcoordinate" + }, + "NSVGlinearData": { + "reference": "NSVGlinearData" + }, + "NSVGradialData": { + "reference": "NSVGradialData" + }, + "NSVGgradientData": { + "reference": "NSVGgradientData" + }, + "NSVGattrib": { + "reference": "NSVGattrib" + }, + "NSVGstyleDeclaration": { + "reference": "NSVGstyleDeclaration" + }, + "NSVGparser": { + "reference": "NSVGparser" + }, + "NSVGNamedColor": { + "reference": "NSVGNamedColor" + }, + "NSVGedge": { + "reference": "NSVGedge" + }, + "NSVGpoint": { + "reference": "NSVGpoint" + }, + "NSVGactiveEdge": { + "reference": "NSVGactiveEdge" + }, + "NSVGmemPage": { + "reference": "NSVGmemPage" + }, + "NSVGcachedPaint": { + "reference": "NSVGcachedPaint" + } + }, + "variables": {}, + "macros": { + "NANOSVG_H": { + "name": "NANOSVG_H", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 30, + "column": 1, + "source_line": "#define NANOSVG_H" + } + }, + "NSVG_PI": { + "name": "NSVG_PI", + "value": "(3.14159265358979323846264338327f)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 453, + "column": 1, + "source_line": "#define NSVG_PI (3.14159265358979323846264338327f)" + } + }, + "NSVG_KAPPA90": { + "name": "NSVG_KAPPA90", + "value": "(0.5522847493f)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 203, + "column": 1, + "source_line": "#define NSVG_KAPPA90 (0.5522847493f)\t// Length proportional to radius of a cubic bezier handle for 90deg arcs." + } + }, + "NSVG_ALIGN_MIN": { + "name": "NSVG_ALIGN_MIN", + "value": "0", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 205, + "column": 1, + "source_line": "#define NSVG_ALIGN_MIN 0" + } + }, + "NSVG_ALIGN_MID": { + "name": "NSVG_ALIGN_MID", + "value": "1", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 206, + "column": 1, + "source_line": "#define NSVG_ALIGN_MID 1" + } + }, + "NSVG_ALIGN_MAX": { + "name": "NSVG_ALIGN_MAX", + "value": "2", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 207, + "column": 1, + "source_line": "#define NSVG_ALIGN_MAX 2" + } + }, + "NSVG_ALIGN_NONE": { + "name": "NSVG_ALIGN_NONE", + "value": "0", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 208, + "column": 1, + "source_line": "#define NSVG_ALIGN_NONE 0" + } + }, + "NSVG_ALIGN_MEET": { + "name": "NSVG_ALIGN_MEET", + "value": "1", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 209, + "column": 1, + "source_line": "#define NSVG_ALIGN_MEET 1" + } + }, + "NSVG_ALIGN_SLICE": { + "name": "NSVG_ALIGN_SLICE", + "value": "2", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 210, + "column": 1, + "source_line": "#define NSVG_ALIGN_SLICE 2" + } + }, + "NSVG_NOTUSED": { + "name": "NSVG_NOTUSED", + "value": "do { (void)(1 ? (void)0 : ( (void)(v) ) ); } while(0)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 212, + "column": 1, + "source_line": "#define NSVG_NOTUSED(v) do { (void)(1 ? (void)0 : ( (void)(v) ) ); } while(0)" + } + }, + "NSVG_RGB": { + "name": "NSVG_RGB", + "value": "(((unsigned int)r) | ((unsigned int)g << 8) | ((unsigned int)b << 16))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 213, + "column": 1, + "source_line": "#define NSVG_RGB(r, g, b) (((unsigned int)r) | ((unsigned int)g << 8) | ((unsigned int)b << 16))" + } + }, + "NSVG_INLINE": { + "name": "NSVG_INLINE", + "value": "inline", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 224, + "column": 2, + "source_line": "\t#define NSVG_INLINE inline" + } + }, + "NSVG_XML_TAG": { + "name": "NSVG_XML_TAG", + "value": "1", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 244, + "column": 1, + "source_line": "#define NSVG_XML_TAG 1" + } + }, + "NSVG_XML_CONTENT": { + "name": "NSVG_XML_CONTENT", + "value": "2", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 245, + "column": 1, + "source_line": "#define NSVG_XML_CONTENT 2" + } + }, + "NSVG_XML_MAX_ATTRIBS": { + "name": "NSVG_XML_MAX_ATTRIBS", + "value": "256", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 246, + "column": 1, + "source_line": "#define NSVG_XML_MAX_ATTRIBS 256" + } + }, + "NSVG_MAX_ATTR": { + "name": "NSVG_MAX_ATTR", + "value": "128", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 369, + "column": 1, + "source_line": "#define NSVG_MAX_ATTR 128" + } + }, + "NSVG_MAX_DASHES": { + "name": "NSVG_MAX_DASHES", + "value": "8", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 376, + "column": 1, + "source_line": "#define NSVG_MAX_DASHES 8" + } + }, + "NSVG_MAX_CLASSES": { + "name": "NSVG_MAX_CLASSES", + "value": "32", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 377, + "column": 1, + "source_line": "#define NSVG_MAX_CLASSES 32" + } + }, + "NSVG_EPSILON": { + "name": "NSVG_EPSILON", + "value": "(1e-12)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 570, + "column": 1, + "source_line": "#define NSVG_EPSILON (1e-12)" + } + }, + "NANOSVGRAST_H": { + "name": "NANOSVGRAST_H", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 26, + "column": 1, + "source_line": "#define NANOSVGRAST_H" + } + }, + "NSVG__SUBSAMPLES": { + "name": "NSVG__SUBSAMPLES", + "value": "5", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 83, + "column": 1, + "source_line": "#define NSVG__SUBSAMPLES\t5" + } + }, + "NSVG__FIXSHIFT": { + "name": "NSVG__FIXSHIFT", + "value": "10", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 84, + "column": 1, + "source_line": "#define NSVG__FIXSHIFT\t\t10" + } + }, + "NSVG__FIX": { + "name": "NSVG__FIX", + "value": "(1 << NSVG__FIXSHIFT)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 85, + "column": 1, + "source_line": "#define NSVG__FIX\t\t\t(1 << NSVG__FIXSHIFT)" + } + }, + "NSVG__FIXMASK": { + "name": "NSVG__FIXMASK", + "value": "(NSVG__FIX-1)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 86, + "column": 1, + "source_line": "#define NSVG__FIXMASK\t\t(NSVG__FIX-1)" + } + }, + "NSVG__MEMPAGE_SIZE": { + "name": "NSVG__MEMPAGE_SIZE", + "value": "1024", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 87, + "column": 1, + "source_line": "#define NSVG__MEMPAGE_SIZE\t1024" + } + } + }, + "includes": { + "nanosvg/nanosvg.h:string.h": { + "target": "string.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 197, + "column": 1, + "source_line": "#include " + } + }, + "nanosvg/nanosvg.h:stdlib.h": { + "target": "stdlib.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 198, + "column": 1, + "source_line": "#include " + } + }, + "nanosvg/nanosvg.h:stdio.h": { + "target": "stdio.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 199, + "column": 1, + "source_line": "#include " + } + }, + "nanosvg/nanosvg.h:math.h": { + "target": "math.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 200, + "column": 1, + "source_line": "#include " + } + }, + "nanosvg/nanosvgrast.h:nanosvg.h": { + "target": "nanosvg.h", + "kind": "local", + "resolved_path": "nanosvg/nanosvg.h", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 28, + "column": 1, + "source_line": "#include \"nanosvg.h\"" + } + }, + "nanosvg/nanosvgrast.h:math.h": { + "target": "math.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 79, + "column": 1, + "source_line": "#include " + } + }, + "nanosvg/nanosvgrast.h:stdlib.h": { + "target": "stdlib.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 80, + "column": 1, + "source_line": "#include " + } + }, + "nanosvg/nanosvgrast.h:string.h": { + "target": "string.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 81, + "column": 1, + "source_line": "#include " + } + } + }, + "functions_by_file": { + "nanosvg/nanosvg.h": [ + "nsvg__isspace", + "nsvg__isdigit", + "nsvg__parseContent", + "nsvg__parseElement", + "nsvg__parseXML", + "nsvg__xformIdentity", + "nsvg__xformSetTranslation", + "nsvg__xformSetScale", + "nsvg__xformSetSkewX", + "nsvg__xformSetSkewY", + "nsvg__xformSetRotation", + "nsvg__xformMultiply", + "nsvg__xformInverse", + "nsvg__xformPremultiply", + "nsvg__xformPoint", + "nsvg__xformVec", + "nsvg__ptInBounds", + "nsvg__evalBezier", + "nsvg__curveBounds", + "nsvg__encodePaintOrder", + "nsvg__createParser", + "nsvg__deleteStyles", + "nsvg__deletePaths", + "nsvg__deletePaint", + "nsvg__deleteGradientData", + "nsvg__deleteParser", + "nsvg__resetPath", + "nsvg__addPoint", + "nsvg__moveTo", + "nsvg__lineTo", + "nsvg__cubicBezTo", + "nsvg__getAttr", + "nsvg__pushAttr", + "nsvg__popAttr", + "nsvg__actualOrigX", + "nsvg__actualOrigY", + "nsvg__actualWidth", + "nsvg__actualHeight", + "nsvg__actualLength", + "nsvg__convertToPixels", + "nsvg__findGradientData", + "nsvg__createGradient", + "nsvg__getAverageScale", + "nsvg__getLocalBounds", + "nsvg__addShape", + "nsvg__addPath", + "nsvg__atof", + "nsvg__parseNumber", + "nsvg__getNextPathItemWhenArcFlag", + "nsvg__getNextPathItem", + "nsvg__parseColorHex", + "nsvg__parseColorRGB", + "nsvg__parseColorName", + "nsvg__parseColor", + "nsvg__parseOpacity", + "nsvg__parseMiterLimit", + "nsvg__parseUnits", + "nsvg__isCoordinate", + "nsvg__parseCoordinateRaw", + "nsvg__coord", + "nsvg__parseCoordinate", + "nsvg__parseTransformArgs", + "nsvg__parseMatrix", + "nsvg__parseTranslate", + "nsvg__parseScale", + "nsvg__parseSkewX", + "nsvg__parseSkewY", + "nsvg__parseRotate", + "nsvg__parseTransform", + "nsvg__parseUrl", + "nsvg__parseLineCap", + "nsvg__parseLineJoin", + "nsvg__parseFillRule", + "nsvg__parsePaintOrder", + "nsvg__getNextDashItem", + "nsvg__parseStrokeDashArray", + "nsvg__parseStyle", + "nsvg__applyClassStyles", + "nsvg__parseAttr", + "nsvg__parseNameValue", + "nsvg__parseAttribs", + "nsvg__getArgsPerElement", + "nsvg__pathMoveTo", + "nsvg__pathLineTo", + "nsvg__pathHLineTo", + "nsvg__pathVLineTo", + "nsvg__pathCubicBezTo", + "nsvg__pathCubicBezShortTo", + "nsvg__pathQuadBezTo", + "nsvg__pathQuadBezShortTo", + "nsvg__sqr", + "nsvg__vmag", + "nsvg__vecrat", + "nsvg__vecang", + "nsvg__pathArcTo", + "nsvg__parsePath", + "nsvg__parseRect", + "nsvg__parseCircle", + "nsvg__parseEllipse", + "nsvg__parseLine", + "nsvg__parsePoly", + "nsvg__parseSVG", + "nsvg__parseGradient", + "nsvg__parseGradientStop", + "nsvg__startElement", + "nsvg__endElement", + "nsvg__strndup", + "nsvg__content", + "nsvg__imageBounds", + "nsvg__viewAlign", + "nsvg__scaleGradient", + "nsvg__scaleToViewbox", + "nsvg__createGradients", + "nsvgParse", + "nsvgParseFromFile", + "nsvgDuplicatePath", + "nsvgDelete" + ], + "nanosvg/nanosvgrast.h": [ + "nsvgCreateRasterizer", + "nsvgDeleteRasterizer", + "nsvg__nextPage", + "nsvg__resetPool", + "nsvg__alloc", + "nsvg__ptEquals", + "nsvg__addPathPoint", + "nsvg__appendPathPoint", + "nsvg__duplicatePoints", + "nsvg__addEdge", + "nsvg__normalize", + "nsvg__absf", + "nsvg__roundf", + "nsvg__flattenCubicBez", + "nsvg__flattenShape", + "nsvg__initClosed", + "nsvg__buttCap", + "nsvg__squareCap", + "nsvg__roundCap", + "nsvg__bevelJoin", + "nsvg__miterJoin", + "nsvg__roundJoin", + "nsvg__straightJoin", + "nsvg__curveDivs", + "nsvg__expandStroke", + "nsvg__prepareStroke", + "nsvg__flattenShapeStroke", + "nsvg__cmpEdge", + "nsvg__addActive", + "nsvg__freeActive", + "nsvg__fillScanline", + "nsvg__fillActiveEdges", + "nsvg__clampf", + "nsvg__RGBA", + "nsvg__lerpRGBA", + "nsvg__applyOpacity", + "nsvg__div255", + "nsvg__scanlineSolid", + "nsvg__rasterizeSortedEdges", + "nsvg__unpremultiplyAlpha", + "nsvg__initPaint", + "nsvgRasterize" + ] + }, + "enum_constants": { + "NSVG_USER_SPACE": { + "name": "NSVG_USER_SPACE", + "value": "0", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 371, + "column": 1, + "source_line": "enum NSVGgradientUnits {" + } + }, + "NSVG_OBJECT_SPACE": { + "name": "NSVG_OBJECT_SPACE", + "value": "1", + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 371, + "column": 1, + "source_line": "enum NSVGgradientUnits {" + } + }, + "NSVG_UNITS_USER": { + "name": "NSVG_UNITS_USER", + "value": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 379, + "column": 1, + "source_line": "enum NSVGunits {" + } + }, + "NSVG_UNITS_PX": { + "name": "NSVG_UNITS_PX", + "value": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 379, + "column": 1, + "source_line": "enum NSVGunits {" + } + }, + "NSVG_UNITS_PT": { + "name": "NSVG_UNITS_PT", + "value": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 379, + "column": 1, + "source_line": "enum NSVGunits {" + } + }, + "NSVG_UNITS_PC": { + "name": "NSVG_UNITS_PC", + "value": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 379, + "column": 1, + "source_line": "enum NSVGunits {" + } + }, + "NSVG_UNITS_MM": { + "name": "NSVG_UNITS_MM", + "value": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 379, + "column": 1, + "source_line": "enum NSVGunits {" + } + }, + "NSVG_UNITS_CM": { + "name": "NSVG_UNITS_CM", + "value": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 379, + "column": 1, + "source_line": "enum NSVGunits {" + } + }, + "NSVG_UNITS_IN": { + "name": "NSVG_UNITS_IN", + "value": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 379, + "column": 1, + "source_line": "enum NSVGunits {" + } + }, + "NSVG_UNITS_PERCENT": { + "name": "NSVG_UNITS_PERCENT", + "value": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 379, + "column": 1, + "source_line": "enum NSVGunits {" + } + }, + "NSVG_UNITS_EM": { + "name": "NSVG_UNITS_EM", + "value": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 379, + "column": 1, + "source_line": "enum NSVGunits {" + } + }, + "NSVG_UNITS_EX": { + "name": "NSVG_UNITS_EX", + "value": null, + "source_location": { + "filename": "nanosvg/nanosvg.h", + "line": 379, + "column": 1, + "source_line": "enum NSVGunits {" + } + }, + "NSVG_PT_CORNER": { + "name": "NSVG_PT_CORNER", + "value": "0x01", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 395, + "column": 1, + "source_line": "enum NSVGpointFlags" + } + }, + "NSVG_PT_BEVEL": { + "name": "NSVG_PT_BEVEL", + "value": "0x02", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 395, + "column": 1, + "source_line": "enum NSVGpointFlags" + } + }, + "NSVG_PT_LEFT": { + "name": "NSVG_PT_LEFT", + "value": "0x04", + "source_location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 395, + "column": 1, + "source_line": "enum NSVGpointFlags" + } + } + }, + "include_graph": { + "nanosvg/nanosvg.h": [], + "nanosvg/nanosvgrast.h": [ + "nanosvg/nanosvg.h" + ] + }, + "system_includes": { + "nanosvg/nanosvg.h": [ + "math.h", + "stdio.h", + "stdlib.h", + "string.h" + ], + "nanosvg/nanosvgrast.h": [ + "math.h", + "stdlib.h", + "string.h" + ] + }, + "unresolved_includes": { + "nanosvg/nanosvg.h": [], + "nanosvg/nanosvgrast.h": [] + }, + "header_source_pairs": { + "nanosvg/nanosvg.h": [], + "nanosvg/nanosvgrast.h": [] + }, + "diagnostics": [ + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'NSVG_NOTUSED' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "nanosvg/nanosvg.h", + "line": 212, + "column": 1, + "source_line": "#define NSVG_NOTUSED(v) do { (void)(1 ? (void)0 : ( (void)(v) ) ); } while(0)" + }, + "unit_kind": "macro", + "unit_name": "NSVG_NOTUSED" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'NSVG_RGB' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "nanosvg/nanosvg.h", + "line": 213, + "column": 1, + "source_line": "#define NSVG_RGB(r, g, b) (((unsigned int)r) | ((unsigned int)g << 8) | ((unsigned int)b << 16))" + }, + "unit_kind": "macro", + "unit_name": "NSVG_RGB" + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '\"C\"'.", + "severity": "warning", + "location": { + "filename": "nanosvg/nanosvg.h", + "line": 34, + "column": 1, + "source_line": "extern \"C\" {" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'NSVG_INLINE'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "nanosvg/nanosvg.h", + "line": 238, + "column": 1, + "source_line": "static NSVG_INLINE float nsvg__minf(float a, float b) { return a < b ? a : b; }" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "NSVG_INLINE" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'NSVG_INLINE'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "nanosvg/nanosvg.h", + "line": 239, + "column": 1, + "source_line": "static NSVG_INLINE float nsvg__maxf(float a, float b) { return a > b ? a : b; }" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "NSVG_INLINE" + }, + { + "code": "C_UNSUPPORTED_FIELD_DECLARATION", + "message": "Nested aggregate field definitions are not supported yet.", + "severity": "warning", + "location": { + "filename": "nanosvg/nanosvg.h", + "line": 410, + "column": 2, + "source_line": "\tunion {" + }, + "unit_kind": "struct_field", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "nanosvg/nanosvg.h", + "line": 1326, + "column": 1, + "source_line": "NSVGNamedColor nsvg__colors[] = {" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '\"C\"'.", + "severity": "warning", + "location": { + "filename": "nanosvg/nanosvgrast.h", + "line": 32, + "column": 1, + "source_line": "extern \"C\" {" + }, + "unit_kind": "declarator", + "unit_name": null + } + ] +} diff --git a/tests/parser/c/fixtures/stb/stb_c_lexer.json b/tests/parser/c/fixtures/stb/stb_c_lexer.json new file mode 100644 index 000000000..2d7fdc6aa --- /dev/null +++ b/tests/parser/c/fixtures/stb/stb_c_lexer.json @@ -0,0 +1,6786 @@ +{ + "files": { + "stb/stb_c_lexer.h": { + "filename": "stb/stb_c_lexer.h", + "language": "c", + "parser_status": "partial", + "preprocessing": "raw", + "functions": [ + { + "name": "stb_c_lexer_init", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "lexer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_lexer *lexer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stb_lexer", + "name": "stb_lexer", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "input_stream", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *input_stream", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 116, + "column": 4, + "source_line": " char *input_stream;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "eof", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *eof", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 117, + "column": 4, + "source_line": " char *eof;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "parse_point", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *parse_point", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 118, + "column": 4, + "source_line": " char *parse_point;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "string_storage", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *string_storage", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 119, + "column": 4, + "source_line": " char *string_storage;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "string_storage_len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int string_storage_len" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 120, + "column": 4, + "source_line": " int string_storage_len;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "where_firstchar", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *where_firstchar", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 123, + "column": 4, + "source_line": " char *where_firstchar;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "where_lastchar", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *where_lastchar", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 124, + "column": 4, + "source_line": " char *where_lastchar;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "token", + "type": { + "model": "CLong", + "qualifiers": [], + "source_text": "long token" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 127, + "column": 4, + "source_line": " long token;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "real_number", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double real_number" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 128, + "column": 4, + "source_line": " double real_number;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "int_number", + "type": { + "model": "CLong", + "qualifiers": [], + "source_text": "long int_number" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 129, + "column": 4, + "source_line": " long int_number;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "string", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *string", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 130, + "column": 4, + "source_line": " char *string;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "string_len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int string_len" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 131, + "column": 4, + "source_line": " int string_len;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_c_lexer.h:113:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 113, + "column": 1, + "source_line": "typedef struct" + } + }, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 113, + "column": 1, + "source_line": "typedef struct" + }, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_lexer *lexer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_lexer" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "input_stream", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *input_stream", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *input_stream", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "input_stream_end", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *input_stream_end", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *input_stream_end", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "string_store", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *string_store", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *string_store", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "store_length", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int store_length" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int store_length" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 273, + "column": 1, + "source_line": "void stb_c_lexer_init(stb_lexer *lexer, const char *input_stream, const char *input_stream_end, char *string_store, int store_length)" + }, + "start": { + "filename": "stb/stb_c_lexer.h", + "line": 273, + "column": 1, + "source_line": "void stb_c_lexer_init(stb_lexer *lexer, const char *input_stream, const char *input_stream_end, char *string_store, int store_length)" + }, + "end": { + "filename": "stb/stb_c_lexer.h", + "line": 280, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_c_lexer_get_location", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "lexer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stb_lexer *lexer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_lexer" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stb_lexer *lexer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_lexer" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "where", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *where", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *where", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "loc", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_lex_location *loc", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stb_lex_location", + "name": "stb_lex_location", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "line_number", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int line_number" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 136, + "column": 4, + "source_line": " int line_number;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "line_offset", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int line_offset" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 137, + "column": 4, + "source_line": " int line_offset;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_c_lexer.h:134:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 134, + "column": 1, + "source_line": "typedef struct" + } + }, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 134, + "column": 1, + "source_line": "typedef struct" + }, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_lex_location *loc", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_lex_location" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 283, + "column": 1, + "source_line": "void stb_c_lexer_get_location(const stb_lexer *lexer, const char *where, stb_lex_location *loc)" + }, + "start": { + "filename": "stb/stb_c_lexer.h", + "line": 283, + "column": 1, + "source_line": "void stb_c_lexer_get_location(const stb_lexer *lexer, const char *where, stb_lex_location *loc)" + }, + "end": { + "filename": "stb/stb_c_lexer.h", + "line": 300, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb__clex_token", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "lexer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_lexer *lexer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_lexer" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_lexer *lexer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_lexer" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "token", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int token" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int token" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "start", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *start", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *start", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "end", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *end", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *end", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 303, + "column": 1, + "source_line": "static int stb__clex_token(stb_lexer *lexer, int token, char *start, char *end)" + }, + "start": { + "filename": "stb/stb_c_lexer.h", + "line": 303, + "column": 1, + "source_line": "static int stb__clex_token(stb_lexer *lexer, int token, char *start, char *end)" + }, + "end": { + "filename": "stb/stb_c_lexer.h", + "line": 310, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb__clex_eof", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "lexer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_lexer *lexer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_lexer" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_lexer *lexer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_lexer" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 313, + "column": 1, + "source_line": "static int stb__clex_eof(stb_lexer *lexer)" + }, + "start": { + "filename": "stb/stb_c_lexer.h", + "line": 313, + "column": 1, + "source_line": "static int stb__clex_eof(stb_lexer *lexer)" + }, + "end": { + "filename": "stb/stb_c_lexer.h", + "line": 317, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb__clex_iswhite", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 319, + "column": 1, + "source_line": "static int stb__clex_iswhite(int x)" + }, + "start": { + "filename": "stb/stb_c_lexer.h", + "line": 319, + "column": 1, + "source_line": "static int stb__clex_iswhite(int x)" + }, + "end": { + "filename": "stb/stb_c_lexer.h", + "line": 322, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb__strchr", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ch", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ch" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ch" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 324, + "column": 1, + "source_line": "static const char *stb__strchr(const char *str, int ch)" + }, + "start": { + "filename": "stb/stb_c_lexer.h", + "line": 324, + "column": 1, + "source_line": "static const char *stb__strchr(const char *str, int ch)" + }, + "end": { + "filename": "stb/stb_c_lexer.h", + "line": 330, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb__clex_parse_suffixes", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "lexer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_lexer *lexer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_lexer" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_lexer *lexer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_lexer" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "tokenid", + "type": { + "model": "CLong", + "qualifiers": [], + "source_text": "long tokenid" + }, + "declared_type": { + "model": "CLong", + "qualifiers": [], + "source_text": "long tokenid" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "start", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *start", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *start", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cur", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *cur", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *cur", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "suffixes", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *suffixes", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *suffixes", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 333, + "column": 1, + "source_line": "static int stb__clex_parse_suffixes(stb_lexer *lexer, long tokenid, char *start, char *cur, const char *suffixes)" + }, + "start": { + "filename": "stb/stb_c_lexer.h", + "line": 333, + "column": 1, + "source_line": "static int stb__clex_parse_suffixes(stb_lexer *lexer, long tokenid, char *start, char *cur, const char *suffixes)" + }, + "end": { + "filename": "stb/stb_c_lexer.h", + "line": 350, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb__clex_pow", + "result_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + }, + "parameters": [ + { + "name": "base", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double base" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double base" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "exponent", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int exponent" + }, + "declared_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int exponent" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 353, + "column": 1, + "source_line": "static double stb__clex_pow(double base, unsigned int exponent)" + }, + "start": { + "filename": "stb/stb_c_lexer.h", + "line": 353, + "column": 1, + "source_line": "static double stb__clex_pow(double base, unsigned int exponent)" + }, + "end": { + "filename": "stb/stb_c_lexer.h", + "line": 362, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb__clex_parse_float", + "result_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "q", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char **q", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char **q", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 364, + "column": 1, + "source_line": "static double stb__clex_parse_float(char *p, char **q)" + }, + "start": { + "filename": "stb/stb_c_lexer.h", + "line": 364, + "column": 1, + "source_line": "static double stb__clex_parse_float(char *p, char **q)" + }, + "end": { + "filename": "stb/stb_c_lexer.h", + "line": 445, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb__clex_parse_char", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "q", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char **q", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char **q", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 448, + "column": 1, + "source_line": "static int stb__clex_parse_char(char *p, char **q)" + }, + "start": { + "filename": "stb/stb_c_lexer.h", + "line": 448, + "column": 1, + "source_line": "static int stb__clex_parse_char(char *p, char **q)" + }, + "end": { + "filename": "stb/stb_c_lexer.h", + "line": 467, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb__clex_parse_string", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "lexer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_lexer *lexer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_lexer" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_lexer *lexer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_lexer" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "type", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int type" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int type" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 469, + "column": 1, + "source_line": "static int stb__clex_parse_string(stb_lexer *lexer, char *p, int type)" + }, + "start": { + "filename": "stb/stb_c_lexer.h", + "line": 469, + "column": 1, + "source_line": "static int stb__clex_parse_string(stb_lexer *lexer, char *p, int type)" + }, + "end": { + "filename": "stb/stb_c_lexer.h", + "line": 496, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_c_lexer_get_token", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "lexer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_lexer *lexer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_lexer" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_lexer *lexer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_lexer" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 498, + "column": 1, + "source_line": "int stb_c_lexer_get_token(stb_lexer *lexer)" + }, + "start": { + "filename": "stb/stb_c_lexer.h", + "line": 498, + "column": 1, + "source_line": "int stb_c_lexer_get_token(stb_lexer *lexer)" + }, + "end": { + "filename": "stb/stb_c_lexer.h", + "line": 800, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "print_token", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "lexer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_lexer *lexer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_lexer" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_lexer *lexer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_lexer" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 808, + "column": 1, + "source_line": "static void print_token(stb_lexer *lexer)" + }, + "start": { + "filename": "stb/stb_c_lexer.h", + "line": 808, + "column": 1, + "source_line": "static void print_token(stb_lexer *lexer)" + }, + "end": { + "filename": "stb/stb_c_lexer.h", + "line": 851, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "dummy", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [], + "storage": [ + "extern" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 858, + "column": 6, + "source_line": "/**/ extern /**/" + }, + "start": { + "filename": "stb/stb_c_lexer.h", + "line": 858, + "column": 6, + "source_line": "/**/ extern /**/" + }, + "end": { + "filename": "stb/stb_c_lexer.h", + "line": 873, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "main", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "argc", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int argc" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int argc" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "argv", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char **argv", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char **argv", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 875, + "column": 1, + "source_line": "int main(int argc, char **argv)" + }, + "start": { + "filename": "stb/stb_c_lexer.h", + "line": 875, + "column": 1, + "source_line": "int main(int argc, char **argv)" + }, + "end": { + "filename": "stb/stb_c_lexer.h", + "line": 899, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + } + ], + "structs": [ + { + "reference": "struct@stb/stb_c_lexer.h:113:1" + }, + { + "reference": "struct@stb/stb_c_lexer.h:134:1" + } + ], + "unions": [], + "enums": [ + { + "model": "CEnum", + "qualifiers": [], + "source_text": "", + "name": null, + "constants": [ + { + "name": "CLEX_eof", + "value": "256", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 177, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "CLEX_parse_error", + "value": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 177, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "CLEX_intlit", + "value": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 177, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "CLEX_floatlit", + "value": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 177, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "CLEX_id", + "value": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 177, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "CLEX_dqstring", + "value": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 177, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "CLEX_sqstring", + "value": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 177, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "CLEX_charlit", + "value": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 177, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "CLEX_eq", + "value": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 177, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "CLEX_noteq", + "value": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 177, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "CLEX_lesseq", + "value": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 177, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "CLEX_greatereq", + "value": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 177, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "CLEX_andand", + "value": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 177, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "CLEX_oror", + "value": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 177, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "CLEX_shl", + "value": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 177, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "CLEX_shr", + "value": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 177, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "CLEX_plusplus", + "value": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 177, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "CLEX_minusminus", + "value": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 177, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "CLEX_pluseq", + "value": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 177, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "CLEX_minuseq", + "value": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 177, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "CLEX_muleq", + "value": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 177, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "CLEX_diveq", + "value": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 177, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "CLEX_modeq", + "value": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 177, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "CLEX_andeq", + "value": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 177, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "CLEX_oreq", + "value": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 177, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "CLEX_xoreq", + "value": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 177, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "CLEX_arrow", + "value": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 177, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "CLEX_eqarrow", + "value": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 177, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "CLEX_shleq", + "value": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 177, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "CLEX_shreq", + "value": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 177, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "CLEX_first_unused_token", + "value": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 177, + "column": 1, + "source_line": "enum" + } + } + ], + "anonymous_id": "enum@stb/stb_c_lexer.h:177:1", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 177, + "column": 1, + "source_line": "enum" + } + } + ], + "typedefs": [ + { + "reference": "stb_lexer" + }, + { + "reference": "stb_lex_location" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stb__clex_int", + "name": "stb__clex_int", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "typedef double stb__clex_int" + }, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 221, + "column": 1, + "source_line": "typedef double stb__clex_int;" + }, + "declaration_locations": [] + } + ], + "variables": [], + "macros": [ + { + "name": "STB_C_LEX_C_DECIMAL_INTS", + "value": "Y", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 60, + "column": 1, + "source_line": "#define STB_C_LEX_C_DECIMAL_INTS Y // \"0|[1-9][0-9]*\" CLEX_intlit" + } + }, + { + "name": "STB_C_LEX_C_HEX_INTS", + "value": "Y", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 61, + "column": 1, + "source_line": "#define STB_C_LEX_C_HEX_INTS Y // \"0x[0-9a-fA-F]+\" CLEX_intlit" + } + }, + { + "name": "STB_C_LEX_C_OCTAL_INTS", + "value": "Y", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 62, + "column": 1, + "source_line": "#define STB_C_LEX_C_OCTAL_INTS Y // \"[0-7]+\" CLEX_intlit" + } + }, + { + "name": "STB_C_LEX_C_DECIMAL_FLOATS", + "value": "Y", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 63, + "column": 1, + "source_line": "#define STB_C_LEX_C_DECIMAL_FLOATS Y // \"[0-9]*(.[0-9]*([eE][-+]?[0-9]+)?) CLEX_floatlit" + } + }, + { + "name": "STB_C_LEX_C99_HEX_FLOATS", + "value": "N", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 64, + "column": 1, + "source_line": "#define STB_C_LEX_C99_HEX_FLOATS N // \"0x{hex}+(.{hex}*)?[pP][-+]?{hex}+ CLEX_floatlit" + } + }, + { + "name": "STB_C_LEX_C_IDENTIFIERS", + "value": "Y", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 65, + "column": 1, + "source_line": "#define STB_C_LEX_C_IDENTIFIERS Y // \"[_a-zA-Z][_a-zA-Z0-9]*\" CLEX_id" + } + }, + { + "name": "STB_C_LEX_C_DQ_STRINGS", + "value": "Y", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 66, + "column": 1, + "source_line": "#define STB_C_LEX_C_DQ_STRINGS Y // double-quote-delimited strings with escapes CLEX_dqstring" + } + }, + { + "name": "STB_C_LEX_C_SQ_STRINGS", + "value": "N", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 67, + "column": 1, + "source_line": "#define STB_C_LEX_C_SQ_STRINGS N // single-quote-delimited strings with escapes CLEX_ssstring" + } + }, + { + "name": "STB_C_LEX_C_CHARS", + "value": "Y", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 68, + "column": 1, + "source_line": "#define STB_C_LEX_C_CHARS Y // single-quote-delimited character with escape CLEX_charlits" + } + }, + { + "name": "STB_C_LEX_C_COMMENTS", + "value": "Y", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 69, + "column": 1, + "source_line": "#define STB_C_LEX_C_COMMENTS Y // \"/* comment */\"" + } + }, + { + "name": "STB_C_LEX_CPP_COMMENTS", + "value": "Y", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 70, + "column": 1, + "source_line": "#define STB_C_LEX_CPP_COMMENTS Y // \"// comment to end of line\\n\"" + } + }, + { + "name": "STB_C_LEX_C_COMPARISONS", + "value": "Y", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 71, + "column": 1, + "source_line": "#define STB_C_LEX_C_COMPARISONS Y // \"==\" CLEX_eq \"!=\" CLEX_noteq \"<=\" CLEX_lesseq \">=\" CLEX_greatereq" + } + }, + { + "name": "STB_C_LEX_C_LOGICAL", + "value": "Y", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 72, + "column": 1, + "source_line": "#define STB_C_LEX_C_LOGICAL Y // \"&&\" CLEX_andand \"||\" CLEX_oror" + } + }, + { + "name": "STB_C_LEX_C_SHIFTS", + "value": "Y", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 73, + "column": 1, + "source_line": "#define STB_C_LEX_C_SHIFTS Y // \"<<\" CLEX_shl \">>\" CLEX_shr" + } + }, + { + "name": "STB_C_LEX_C_INCREMENTS", + "value": "Y", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 74, + "column": 1, + "source_line": "#define STB_C_LEX_C_INCREMENTS Y // \"++\" CLEX_plusplus \"--\" CLEX_minusminus" + } + }, + { + "name": "STB_C_LEX_C_ARROW", + "value": "Y", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 75, + "column": 1, + "source_line": "#define STB_C_LEX_C_ARROW Y // \"->\" CLEX_arrow" + } + }, + { + "name": "STB_C_LEX_EQUAL_ARROW", + "value": "N", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 76, + "column": 1, + "source_line": "#define STB_C_LEX_EQUAL_ARROW N // \"=>\" CLEX_eqarrow" + } + }, + { + "name": "STB_C_LEX_C_BITWISEEQ", + "value": "Y", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 77, + "column": 1, + "source_line": "#define STB_C_LEX_C_BITWISEEQ Y // \"&=\" CLEX_andeq \"|=\" CLEX_oreq \"^=\" CLEX_xoreq" + } + }, + { + "name": "STB_C_LEX_C_ARITHEQ", + "value": "Y", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 78, + "column": 1, + "source_line": "#define STB_C_LEX_C_ARITHEQ Y // \"+=\" CLEX_pluseq \"-=\" CLEX_minuseq" + } + }, + { + "name": "STB_C_LEX_PARSE_SUFFIXES", + "value": "N", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 83, + "column": 1, + "source_line": "#define STB_C_LEX_PARSE_SUFFIXES N // letters after numbers are parsed as part of those numbers, and must be in suffix list below" + } + }, + { + "name": "STB_C_LEX_DECIMAL_SUFFIXES", + "value": "\"\"", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 84, + "column": 1, + "source_line": "#define STB_C_LEX_DECIMAL_SUFFIXES \"\" // decimal integer suffixes e.g. \"uUlL\" -- these are returned as-is in string storage" + } + }, + { + "name": "STB_C_LEX_HEX_SUFFIXES", + "value": "\"\"", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 85, + "column": 1, + "source_line": "#define STB_C_LEX_HEX_SUFFIXES \"\" // e.g. \"uUlL\"" + } + }, + { + "name": "STB_C_LEX_OCTAL_SUFFIXES", + "value": "\"\"", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 86, + "column": 1, + "source_line": "#define STB_C_LEX_OCTAL_SUFFIXES \"\" // e.g. \"uUlL\"" + } + }, + { + "name": "STB_C_LEX_FLOAT_SUFFIXES", + "value": "\"\"", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 87, + "column": 1, + "source_line": "#define STB_C_LEX_FLOAT_SUFFIXES \"\" //" + } + }, + { + "name": "STB_C_LEX_0_IS_EOF", + "value": "N", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 89, + "column": 1, + "source_line": "#define STB_C_LEX_0_IS_EOF N // if Y, ends parsing at '\\0'; if N, returns '\\0' as token" + } + }, + { + "name": "STB_C_LEX_INTEGERS_AS_DOUBLES", + "value": "N", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 90, + "column": 1, + "source_line": "#define STB_C_LEX_INTEGERS_AS_DOUBLES N // parses integers as doubles so they can be larger than 'int', but only if STB_C_LEX_STDLIB==N" + } + }, + { + "name": "STB_C_LEX_MULTILINE_DSTRINGS", + "value": "N", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 91, + "column": 1, + "source_line": "#define STB_C_LEX_MULTILINE_DSTRINGS N // allow newlines in double-quoted strings" + } + }, + { + "name": "STB_C_LEX_MULTILINE_SSTRINGS", + "value": "N", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 92, + "column": 1, + "source_line": "#define STB_C_LEX_MULTILINE_SSTRINGS N // allow newlines in single-quoted strings" + } + }, + { + "name": "STB_C_LEX_USE_STDLIB", + "value": "Y", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 93, + "column": 1, + "source_line": "#define STB_C_LEX_USE_STDLIB Y // use strtod,strtol for parsing #s; otherwise inaccurate hack" + } + }, + { + "name": "STB_C_LEX_DOLLAR_IDENTIFIER", + "value": "Y", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 94, + "column": 1, + "source_line": "#define STB_C_LEX_DOLLAR_IDENTIFIER Y // allow $ as an identifier character" + } + }, + { + "name": "STB_C_LEX_FLOAT_NO_DECIMAL", + "value": "Y", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 95, + "column": 1, + "source_line": "#define STB_C_LEX_FLOAT_NO_DECIMAL Y // allow floats that have no decimal point if they have an exponent" + } + }, + { + "name": "STB_C_LEX_DEFINE_ALL_TOKEN_NAMES", + "value": "N", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 97, + "column": 1, + "source_line": "#define STB_C_LEX_DEFINE_ALL_TOKEN_NAMES N // if Y, all CLEX_ token names are defined, even if never returned" + } + }, + { + "name": "STB_C_LEX_DISCARD_PREPROCESSOR", + "value": "Y", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 100, + "column": 1, + "source_line": "#define STB_C_LEX_DISCARD_PREPROCESSOR Y // discard C-preprocessor directives (e.g. after prepocess" + } + }, + { + "name": "STB_C_LEXER_DEFINITIONS", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 105, + "column": 1, + "source_line": "#define STB_C_LEXER_DEFINITIONS // This line prevents the header file from replacing your definitions" + } + }, + { + "name": "INCLUDE_STB_C_LEXER_H", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 111, + "column": 1, + "source_line": "#define INCLUDE_STB_C_LEXER_H" + } + }, + { + "name": "Y", + "value": "1", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 217, + "column": 1, + "source_line": "#define Y(x) 1" + } + }, + { + "name": "N", + "value": "0", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 218, + "column": 1, + "source_line": "#define N(x) 0" + } + }, + { + "name": "intfield", + "value": "real_number", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 222, + "column": 1, + "source_line": "#define intfield real_number" + } + }, + { + "name": "STB__clex_int_as_double", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 223, + "column": 1, + "source_line": "#define STB__clex_int_as_double" + } + }, + { + "name": "intfield", + "value": "int_number", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 226, + "column": 1, + "source_line": "#define intfield int_number" + } + }, + { + "name": "STB__clex_parse_suffixes", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 233, + "column": 1, + "source_line": "#define STB__clex_parse_suffixes" + } + }, + { + "name": "STB__clex_hex_floats", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 237, + "column": 1, + "source_line": "#define STB__clex_hex_floats" + } + }, + { + "name": "STB__clex_hex_ints", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 241, + "column": 1, + "source_line": "#define STB__clex_hex_ints" + } + }, + { + "name": "STB__clex_decimal_ints", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 245, + "column": 1, + "source_line": "#define STB__clex_decimal_ints" + } + }, + { + "name": "STB__clex_octal_ints", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 249, + "column": 1, + "source_line": "#define STB__clex_octal_ints" + } + }, + { + "name": "STB__clex_decimal_floats", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 253, + "column": 1, + "source_line": "#define STB__clex_decimal_floats" + } + }, + { + "name": "STB__clex_discard_preprocessor", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 257, + "column": 1, + "source_line": "#define STB__clex_discard_preprocessor" + } + }, + { + "name": "STB__CLEX_use_stdlib", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 261, + "column": 1, + "source_line": "#define STB__CLEX_use_stdlib" + } + }, + { + "name": "Y", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 267, + "column": 1, + "source_line": "#undef Y" + } + }, + { + "name": "Y", + "value": "a", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 268, + "column": 1, + "source_line": "#define Y(a) a" + } + }, + { + "name": "N", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 269, + "column": 1, + "source_line": "#undef N" + } + }, + { + "name": "N", + "value": null, + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 270, + "column": 1, + "source_line": "#define N(a)" + } + }, + { + "name": "_CRT_SECURE_NO_WARNINGS", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 804, + "column": 1, + "source_line": "#define _CRT_SECURE_NO_WARNINGS" + } + } + ], + "includes": [ + { + "target": "stdlib.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 262, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "stdio.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 805, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "stdlib.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 806, + "column": 1, + "source_line": "#include " + } + } + ], + "raw_directives": [ + { + "directive": "ifdef", + "argument": "STB_C_LEXER_IMPLEMENTATION", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 47, + "column": 1, + "source_line": "#ifdef STB_C_LEXER_IMPLEMENTATION" + } + }, + { + "directive": "ifndef", + "argument": "STB_C_LEXER_DEFINITIONS", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 48, + "column": 1, + "source_line": "#ifndef STB_C_LEXER_DEFINITIONS" + } + }, + { + "directive": "if", + "argument": "defined(Y) || defined(N)", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 56, + "column": 1, + "source_line": "#if defined(Y) || defined(N)" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 58, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 107, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 108, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "INCLUDE_STB_C_LEXER_H", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 110, + "column": 1, + "source_line": "#ifndef INCLUDE_STB_C_LEXER_H" + } + }, + { + "directive": "ifdef", + "argument": "__cplusplus", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 140, + "column": 1, + "source_line": "#ifdef __cplusplus" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 142, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "__cplusplus", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 173, + "column": 1, + "source_line": "#ifdef __cplusplus" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 175, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 212, + "column": 1, + "source_line": "#endif // INCLUDE_STB_C_LEXER_H" + } + }, + { + "directive": "ifdef", + "argument": "STB_C_LEXER_IMPLEMENTATION", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 214, + "column": 1, + "source_line": "#ifdef STB_C_LEXER_IMPLEMENTATION" + } + }, + { + "directive": "if", + "argument": "STB_C_LEX_INTEGERS_AS_DOUBLES(x)", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 220, + "column": 1, + "source_line": "#if STB_C_LEX_INTEGERS_AS_DOUBLES(x)" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 224, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 227, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "STB_C_LEX_PARSE_SUFFIXES(x)", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 232, + "column": 1, + "source_line": "#if STB_C_LEX_PARSE_SUFFIXES(x)" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 234, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "STB_C_LEX_C99_HEX_FLOATS(x)", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 236, + "column": 1, + "source_line": "#if STB_C_LEX_C99_HEX_FLOATS(x)" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 238, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "STB_C_LEX_C_HEX_INTS(x)", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 240, + "column": 1, + "source_line": "#if STB_C_LEX_C_HEX_INTS(x)" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 242, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "STB_C_LEX_C_DECIMAL_INTS(x)", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 244, + "column": 1, + "source_line": "#if STB_C_LEX_C_DECIMAL_INTS(x)" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 246, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "STB_C_LEX_C_OCTAL_INTS(x)", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 248, + "column": 1, + "source_line": "#if STB_C_LEX_C_OCTAL_INTS(x)" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 250, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "STB_C_LEX_C_DECIMAL_FLOATS(x)", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 252, + "column": 1, + "source_line": "#if STB_C_LEX_C_DECIMAL_FLOATS(x)" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 254, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "STB_C_LEX_DISCARD_PREPROCESSOR(x)", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 256, + "column": 1, + "source_line": "#if STB_C_LEX_DISCARD_PREPROCESSOR(x)" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 258, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "STB_C_LEX_USE_STDLIB(x) && (!defined(STB__clex_hex_floats) || __STDC_VERSION__ >= 199901L)", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 260, + "column": 1, + "source_line": "#if STB_C_LEX_USE_STDLIB(x) && (!defined(STB__clex_hex_floats) || __STDC_VERSION__ >= 199901L)" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 263, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STB__clex_parse_suffixes", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 335, + "column": 4, + "source_line": " #ifdef STB__clex_parse_suffixes" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 346, + "column": 4, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 348, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STB__CLEX_use_stdlib", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 352, + "column": 1, + "source_line": "#ifndef STB__CLEX_use_stdlib" + } + }, + { + "directive": "ifdef", + "argument": "STB__clex_hex_floats", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 371, + "column": 1, + "source_line": "#ifdef STB__clex_hex_floats" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 378, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STB__clex_hex_floats", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 383, + "column": 1, + "source_line": "#ifdef STB__clex_hex_floats" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 388, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STB__clex_hex_floats", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 399, + "column": 1, + "source_line": "#ifdef STB__clex_hex_floats" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 404, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STB__clex_hex_floats", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 410, + "column": 1, + "source_line": "#ifdef STB__clex_hex_floats" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 419, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STB__clex_hex_floats", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 432, + "column": 1, + "source_line": "#ifdef STB__clex_hex_floats" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 436, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 446, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STB_C_LEX_ISWHITE", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 504, + "column": 7, + "source_line": " #ifdef STB_C_LEX_ISWHITE" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 513, + "column": 7, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 516, + "column": 7, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "STB__clex_discard_preprocessor", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 539, + "column": 7, + "source_line": " #ifdef STB__clex_discard_preprocessor" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 549, + "column": 7, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "defined(STB__clex_hex_ints) || defined(STB__clex_hex_floats)", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 680, + "column": 10, + "source_line": " #if defined(STB__clex_hex_ints) || defined(STB__clex_hex_floats)" + } + }, + { + "directive": "ifdef", + "argument": "STB__clex_hex_floats", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 685, + "column": 19, + "source_line": " #ifdef STB__clex_hex_floats" + } + }, + { + "directive": "ifdef", + "argument": "STB__CLEX_use_stdlib", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 691, + "column": 25, + "source_line": " #ifdef STB__CLEX_use_stdlib" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 693, + "column": 25, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 695, + "column": 25, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 703, + "column": 19, + "source_line": " #endif // STB__CLEX_hex_floats" + } + }, + { + "directive": "ifdef", + "argument": "STB__clex_hex_ints", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 705, + "column": 19, + "source_line": " #ifdef STB__clex_hex_ints" + } + }, + { + "directive": "ifdef", + "argument": "STB__CLEX_use_stdlib", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 706, + "column": 19, + "source_line": " #ifdef STB__CLEX_use_stdlib" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 708, + "column": 19, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 723, + "column": 19, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 727, + "column": 19, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 730, + "column": 10, + "source_line": " #endif // defined(STB__clex_hex_ints) || defined(STB__clex_hex_floats)" + } + }, + { + "directive": "ifdef", + "argument": "STB__clex_decimal_floats", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 737, + "column": 10, + "source_line": " #ifdef STB__clex_decimal_floats" + } + }, + { + "directive": "ifdef", + "argument": "STB__CLEX_use_stdlib", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 744, + "column": 19, + "source_line": " #ifdef STB__CLEX_use_stdlib" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 746, + "column": 19, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 748, + "column": 19, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 755, + "column": 10, + "source_line": " #endif // STB__clex_decimal_floats" + } + }, + { + "directive": "ifdef", + "argument": "STB__clex_octal_ints", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 757, + "column": 10, + "source_line": " #ifdef STB__clex_octal_ints" + } + }, + { + "directive": "ifdef", + "argument": "STB__CLEX_use_stdlib", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 760, + "column": 13, + "source_line": " #ifdef STB__CLEX_use_stdlib" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 762, + "column": 13, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 774, + "column": 13, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 777, + "column": 10, + "source_line": " #endif // STB__clex_octal_ints" + } + }, + { + "directive": "ifdef", + "argument": "STB__clex_decimal_ints", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 779, + "column": 10, + "source_line": " #ifdef STB__clex_decimal_ints" + } + }, + { + "directive": "ifdef", + "argument": "STB__CLEX_use_stdlib", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 782, + "column": 13, + "source_line": " #ifdef STB__CLEX_use_stdlib" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 784, + "column": 13, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 794, + "column": 13, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 797, + "column": 10, + "source_line": " #endif // STB__clex_decimal_ints" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 801, + "column": 1, + "source_line": "#endif // STB_C_LEXER_IMPLEMENTATION" + } + }, + { + "directive": "ifdef", + "argument": "STB_C_LEXER_SELF_TEST", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 803, + "column": 1, + "source_line": "#ifdef STB_C_LEXER_SELF_TEST" + } + }, + { + "directive": "if", + "argument": "defined(STB__clex_int_as_double) && !defined(STB__CLEX_use_stdlib)", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 837, + "column": 7, + "source_line": " #if defined(STB__clex_int_as_double) && !defined(STB__CLEX_use_stdlib)" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 839, + "column": 7, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 841, + "column": 7, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "0", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 864, + "column": 1, + "source_line": "#if 0 // not supported in C++ or C-pre-99, so don't try to compile it, but let our parser test it" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 866, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 900, + "column": 1, + "source_line": "#endif" + } + } + ], + "macro_dependencies": [], + "diagnostics": [ + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'Y' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_c_lexer.h", + "line": 217, + "column": 1, + "source_line": "#define Y(x) 1" + }, + "unit_kind": "macro", + "unit_name": "Y" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'N' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_c_lexer.h", + "line": 218, + "column": 1, + "source_line": "#define N(x) 0" + }, + "unit_kind": "macro", + "unit_name": "N" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'Y' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_c_lexer.h", + "line": 268, + "column": 1, + "source_line": "#define Y(a) a" + }, + "unit_kind": "macro", + "unit_name": "Y" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'N' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_c_lexer.h", + "line": 270, + "column": 1, + "source_line": "#define N(a)" + }, + "unit_kind": "macro", + "unit_name": "N" + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '\"C\"'.", + "severity": "warning", + "location": { + "filename": "stb/stb_c_lexer.h", + "line": 141, + "column": 1, + "source_line": "extern \"C\" {" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_CONFLICTING_TYPEDEF", + "message": "Conflicting typedef declarations for 'stb__clex_int'.", + "severity": "error", + "location": { + "filename": "stb/stb_c_lexer.h", + "line": 225, + "column": 1, + "source_line": "typedef long stb__clex_int;" + }, + "unit_kind": "typedef", + "unit_name": "stb__clex_int" + } + ] + } + }, + "functions": { + "stb_c_lexer_init": { + "name": "stb_c_lexer_init", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "lexer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_lexer *lexer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_lexer" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_lexer *lexer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_lexer" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "input_stream", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *input_stream", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *input_stream", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "input_stream_end", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *input_stream_end", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *input_stream_end", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "string_store", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *string_store", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *string_store", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "store_length", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int store_length" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int store_length" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 273, + "column": 1, + "source_line": "void stb_c_lexer_init(stb_lexer *lexer, const char *input_stream, const char *input_stream_end, char *string_store, int store_length)" + }, + "start": { + "filename": "stb/stb_c_lexer.h", + "line": 273, + "column": 1, + "source_line": "void stb_c_lexer_init(stb_lexer *lexer, const char *input_stream, const char *input_stream_end, char *string_store, int store_length)" + }, + "end": { + "filename": "stb/stb_c_lexer.h", + "line": 280, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_c_lexer_get_location": { + "name": "stb_c_lexer_get_location", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "lexer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stb_lexer *lexer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_lexer" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stb_lexer *lexer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_lexer" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "where", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *where", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *where", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "loc", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_lex_location *loc", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_lex_location" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_lex_location *loc", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_lex_location" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 283, + "column": 1, + "source_line": "void stb_c_lexer_get_location(const stb_lexer *lexer, const char *where, stb_lex_location *loc)" + }, + "start": { + "filename": "stb/stb_c_lexer.h", + "line": 283, + "column": 1, + "source_line": "void stb_c_lexer_get_location(const stb_lexer *lexer, const char *where, stb_lex_location *loc)" + }, + "end": { + "filename": "stb/stb_c_lexer.h", + "line": 300, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb__clex_token": { + "name": "stb__clex_token", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "lexer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_lexer *lexer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_lexer" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_lexer *lexer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_lexer" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "token", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int token" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int token" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "start", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *start", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *start", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "end", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *end", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *end", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 303, + "column": 1, + "source_line": "static int stb__clex_token(stb_lexer *lexer, int token, char *start, char *end)" + }, + "start": { + "filename": "stb/stb_c_lexer.h", + "line": 303, + "column": 1, + "source_line": "static int stb__clex_token(stb_lexer *lexer, int token, char *start, char *end)" + }, + "end": { + "filename": "stb/stb_c_lexer.h", + "line": 310, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb__clex_eof": { + "name": "stb__clex_eof", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "lexer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_lexer *lexer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_lexer" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_lexer *lexer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_lexer" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 313, + "column": 1, + "source_line": "static int stb__clex_eof(stb_lexer *lexer)" + }, + "start": { + "filename": "stb/stb_c_lexer.h", + "line": 313, + "column": 1, + "source_line": "static int stb__clex_eof(stb_lexer *lexer)" + }, + "end": { + "filename": "stb/stb_c_lexer.h", + "line": 317, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb__clex_iswhite": { + "name": "stb__clex_iswhite", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 319, + "column": 1, + "source_line": "static int stb__clex_iswhite(int x)" + }, + "start": { + "filename": "stb/stb_c_lexer.h", + "line": 319, + "column": 1, + "source_line": "static int stb__clex_iswhite(int x)" + }, + "end": { + "filename": "stb/stb_c_lexer.h", + "line": 322, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb__strchr": { + "name": "stb__strchr", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ch", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ch" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ch" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 324, + "column": 1, + "source_line": "static const char *stb__strchr(const char *str, int ch)" + }, + "start": { + "filename": "stb/stb_c_lexer.h", + "line": 324, + "column": 1, + "source_line": "static const char *stb__strchr(const char *str, int ch)" + }, + "end": { + "filename": "stb/stb_c_lexer.h", + "line": 330, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb__clex_parse_suffixes": { + "name": "stb__clex_parse_suffixes", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "lexer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_lexer *lexer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_lexer" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_lexer *lexer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_lexer" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "tokenid", + "type": { + "model": "CLong", + "qualifiers": [], + "source_text": "long tokenid" + }, + "declared_type": { + "model": "CLong", + "qualifiers": [], + "source_text": "long tokenid" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "start", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *start", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *start", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cur", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *cur", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *cur", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "suffixes", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *suffixes", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *suffixes", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 333, + "column": 1, + "source_line": "static int stb__clex_parse_suffixes(stb_lexer *lexer, long tokenid, char *start, char *cur, const char *suffixes)" + }, + "start": { + "filename": "stb/stb_c_lexer.h", + "line": 333, + "column": 1, + "source_line": "static int stb__clex_parse_suffixes(stb_lexer *lexer, long tokenid, char *start, char *cur, const char *suffixes)" + }, + "end": { + "filename": "stb/stb_c_lexer.h", + "line": 350, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb__clex_pow": { + "name": "stb__clex_pow", + "result_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + }, + "parameters": [ + { + "name": "base", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double base" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double base" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "exponent", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int exponent" + }, + "declared_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int exponent" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 353, + "column": 1, + "source_line": "static double stb__clex_pow(double base, unsigned int exponent)" + }, + "start": { + "filename": "stb/stb_c_lexer.h", + "line": 353, + "column": 1, + "source_line": "static double stb__clex_pow(double base, unsigned int exponent)" + }, + "end": { + "filename": "stb/stb_c_lexer.h", + "line": 362, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb__clex_parse_float": { + "name": "stb__clex_parse_float", + "result_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "q", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char **q", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char **q", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 364, + "column": 1, + "source_line": "static double stb__clex_parse_float(char *p, char **q)" + }, + "start": { + "filename": "stb/stb_c_lexer.h", + "line": 364, + "column": 1, + "source_line": "static double stb__clex_parse_float(char *p, char **q)" + }, + "end": { + "filename": "stb/stb_c_lexer.h", + "line": 445, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb__clex_parse_char": { + "name": "stb__clex_parse_char", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "q", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char **q", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char **q", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 448, + "column": 1, + "source_line": "static int stb__clex_parse_char(char *p, char **q)" + }, + "start": { + "filename": "stb/stb_c_lexer.h", + "line": 448, + "column": 1, + "source_line": "static int stb__clex_parse_char(char *p, char **q)" + }, + "end": { + "filename": "stb/stb_c_lexer.h", + "line": 467, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb__clex_parse_string": { + "name": "stb__clex_parse_string", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "lexer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_lexer *lexer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_lexer" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_lexer *lexer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_lexer" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "type", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int type" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int type" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 469, + "column": 1, + "source_line": "static int stb__clex_parse_string(stb_lexer *lexer, char *p, int type)" + }, + "start": { + "filename": "stb/stb_c_lexer.h", + "line": 469, + "column": 1, + "source_line": "static int stb__clex_parse_string(stb_lexer *lexer, char *p, int type)" + }, + "end": { + "filename": "stb/stb_c_lexer.h", + "line": 496, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_c_lexer_get_token": { + "name": "stb_c_lexer_get_token", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "lexer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_lexer *lexer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_lexer" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_lexer *lexer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_lexer" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 498, + "column": 1, + "source_line": "int stb_c_lexer_get_token(stb_lexer *lexer)" + }, + "start": { + "filename": "stb/stb_c_lexer.h", + "line": 498, + "column": 1, + "source_line": "int stb_c_lexer_get_token(stb_lexer *lexer)" + }, + "end": { + "filename": "stb/stb_c_lexer.h", + "line": 800, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "print_token": { + "name": "print_token", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "lexer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_lexer *lexer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_lexer" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_lexer *lexer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_lexer" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 808, + "column": 1, + "source_line": "static void print_token(stb_lexer *lexer)" + }, + "start": { + "filename": "stb/stb_c_lexer.h", + "line": 808, + "column": 1, + "source_line": "static void print_token(stb_lexer *lexer)" + }, + "end": { + "filename": "stb/stb_c_lexer.h", + "line": 851, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "dummy": { + "name": "dummy", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [], + "storage": [ + "extern" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 858, + "column": 6, + "source_line": "/**/ extern /**/" + }, + "start": { + "filename": "stb/stb_c_lexer.h", + "line": 858, + "column": 6, + "source_line": "/**/ extern /**/" + }, + "end": { + "filename": "stb/stb_c_lexer.h", + "line": 873, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "main": { + "name": "main", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "argc", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int argc" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int argc" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "argv", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char **argv", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char **argv", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 875, + "column": 1, + "source_line": "int main(int argc, char **argv)" + }, + "start": { + "filename": "stb/stb_c_lexer.h", + "line": 875, + "column": 1, + "source_line": "int main(int argc, char **argv)" + }, + "end": { + "filename": "stb/stb_c_lexer.h", + "line": 899, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + } + }, + "structs": {}, + "unions": {}, + "enums": {}, + "typedefs": { + "stb_lexer": { + "reference": "stb_lexer" + }, + "stb_lex_location": { + "reference": "stb_lex_location" + }, + "stb__clex_int": { + "reference": "stb__clex_int" + } + }, + "variables": {}, + "macros": { + "STB_C_LEX_C_DECIMAL_INTS": { + "name": "STB_C_LEX_C_DECIMAL_INTS", + "value": "Y", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 60, + "column": 1, + "source_line": "#define STB_C_LEX_C_DECIMAL_INTS Y // \"0|[1-9][0-9]*\" CLEX_intlit" + } + }, + "STB_C_LEX_C_HEX_INTS": { + "name": "STB_C_LEX_C_HEX_INTS", + "value": "Y", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 61, + "column": 1, + "source_line": "#define STB_C_LEX_C_HEX_INTS Y // \"0x[0-9a-fA-F]+\" CLEX_intlit" + } + }, + "STB_C_LEX_C_OCTAL_INTS": { + "name": "STB_C_LEX_C_OCTAL_INTS", + "value": "Y", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 62, + "column": 1, + "source_line": "#define STB_C_LEX_C_OCTAL_INTS Y // \"[0-7]+\" CLEX_intlit" + } + }, + "STB_C_LEX_C_DECIMAL_FLOATS": { + "name": "STB_C_LEX_C_DECIMAL_FLOATS", + "value": "Y", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 63, + "column": 1, + "source_line": "#define STB_C_LEX_C_DECIMAL_FLOATS Y // \"[0-9]*(.[0-9]*([eE][-+]?[0-9]+)?) CLEX_floatlit" + } + }, + "STB_C_LEX_C99_HEX_FLOATS": { + "name": "STB_C_LEX_C99_HEX_FLOATS", + "value": "N", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 64, + "column": 1, + "source_line": "#define STB_C_LEX_C99_HEX_FLOATS N // \"0x{hex}+(.{hex}*)?[pP][-+]?{hex}+ CLEX_floatlit" + } + }, + "STB_C_LEX_C_IDENTIFIERS": { + "name": "STB_C_LEX_C_IDENTIFIERS", + "value": "Y", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 65, + "column": 1, + "source_line": "#define STB_C_LEX_C_IDENTIFIERS Y // \"[_a-zA-Z][_a-zA-Z0-9]*\" CLEX_id" + } + }, + "STB_C_LEX_C_DQ_STRINGS": { + "name": "STB_C_LEX_C_DQ_STRINGS", + "value": "Y", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 66, + "column": 1, + "source_line": "#define STB_C_LEX_C_DQ_STRINGS Y // double-quote-delimited strings with escapes CLEX_dqstring" + } + }, + "STB_C_LEX_C_SQ_STRINGS": { + "name": "STB_C_LEX_C_SQ_STRINGS", + "value": "N", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 67, + "column": 1, + "source_line": "#define STB_C_LEX_C_SQ_STRINGS N // single-quote-delimited strings with escapes CLEX_ssstring" + } + }, + "STB_C_LEX_C_CHARS": { + "name": "STB_C_LEX_C_CHARS", + "value": "Y", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 68, + "column": 1, + "source_line": "#define STB_C_LEX_C_CHARS Y // single-quote-delimited character with escape CLEX_charlits" + } + }, + "STB_C_LEX_C_COMMENTS": { + "name": "STB_C_LEX_C_COMMENTS", + "value": "Y", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 69, + "column": 1, + "source_line": "#define STB_C_LEX_C_COMMENTS Y // \"/* comment */\"" + } + }, + "STB_C_LEX_CPP_COMMENTS": { + "name": "STB_C_LEX_CPP_COMMENTS", + "value": "Y", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 70, + "column": 1, + "source_line": "#define STB_C_LEX_CPP_COMMENTS Y // \"// comment to end of line\\n\"" + } + }, + "STB_C_LEX_C_COMPARISONS": { + "name": "STB_C_LEX_C_COMPARISONS", + "value": "Y", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 71, + "column": 1, + "source_line": "#define STB_C_LEX_C_COMPARISONS Y // \"==\" CLEX_eq \"!=\" CLEX_noteq \"<=\" CLEX_lesseq \">=\" CLEX_greatereq" + } + }, + "STB_C_LEX_C_LOGICAL": { + "name": "STB_C_LEX_C_LOGICAL", + "value": "Y", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 72, + "column": 1, + "source_line": "#define STB_C_LEX_C_LOGICAL Y // \"&&\" CLEX_andand \"||\" CLEX_oror" + } + }, + "STB_C_LEX_C_SHIFTS": { + "name": "STB_C_LEX_C_SHIFTS", + "value": "Y", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 73, + "column": 1, + "source_line": "#define STB_C_LEX_C_SHIFTS Y // \"<<\" CLEX_shl \">>\" CLEX_shr" + } + }, + "STB_C_LEX_C_INCREMENTS": { + "name": "STB_C_LEX_C_INCREMENTS", + "value": "Y", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 74, + "column": 1, + "source_line": "#define STB_C_LEX_C_INCREMENTS Y // \"++\" CLEX_plusplus \"--\" CLEX_minusminus" + } + }, + "STB_C_LEX_C_ARROW": { + "name": "STB_C_LEX_C_ARROW", + "value": "Y", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 75, + "column": 1, + "source_line": "#define STB_C_LEX_C_ARROW Y // \"->\" CLEX_arrow" + } + }, + "STB_C_LEX_EQUAL_ARROW": { + "name": "STB_C_LEX_EQUAL_ARROW", + "value": "N", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 76, + "column": 1, + "source_line": "#define STB_C_LEX_EQUAL_ARROW N // \"=>\" CLEX_eqarrow" + } + }, + "STB_C_LEX_C_BITWISEEQ": { + "name": "STB_C_LEX_C_BITWISEEQ", + "value": "Y", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 77, + "column": 1, + "source_line": "#define STB_C_LEX_C_BITWISEEQ Y // \"&=\" CLEX_andeq \"|=\" CLEX_oreq \"^=\" CLEX_xoreq" + } + }, + "STB_C_LEX_C_ARITHEQ": { + "name": "STB_C_LEX_C_ARITHEQ", + "value": "Y", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 78, + "column": 1, + "source_line": "#define STB_C_LEX_C_ARITHEQ Y // \"+=\" CLEX_pluseq \"-=\" CLEX_minuseq" + } + }, + "STB_C_LEX_PARSE_SUFFIXES": { + "name": "STB_C_LEX_PARSE_SUFFIXES", + "value": "N", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 83, + "column": 1, + "source_line": "#define STB_C_LEX_PARSE_SUFFIXES N // letters after numbers are parsed as part of those numbers, and must be in suffix list below" + } + }, + "STB_C_LEX_DECIMAL_SUFFIXES": { + "name": "STB_C_LEX_DECIMAL_SUFFIXES", + "value": "\"\"", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 84, + "column": 1, + "source_line": "#define STB_C_LEX_DECIMAL_SUFFIXES \"\" // decimal integer suffixes e.g. \"uUlL\" -- these are returned as-is in string storage" + } + }, + "STB_C_LEX_HEX_SUFFIXES": { + "name": "STB_C_LEX_HEX_SUFFIXES", + "value": "\"\"", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 85, + "column": 1, + "source_line": "#define STB_C_LEX_HEX_SUFFIXES \"\" // e.g. \"uUlL\"" + } + }, + "STB_C_LEX_OCTAL_SUFFIXES": { + "name": "STB_C_LEX_OCTAL_SUFFIXES", + "value": "\"\"", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 86, + "column": 1, + "source_line": "#define STB_C_LEX_OCTAL_SUFFIXES \"\" // e.g. \"uUlL\"" + } + }, + "STB_C_LEX_FLOAT_SUFFIXES": { + "name": "STB_C_LEX_FLOAT_SUFFIXES", + "value": "\"\"", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 87, + "column": 1, + "source_line": "#define STB_C_LEX_FLOAT_SUFFIXES \"\" //" + } + }, + "STB_C_LEX_0_IS_EOF": { + "name": "STB_C_LEX_0_IS_EOF", + "value": "N", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 89, + "column": 1, + "source_line": "#define STB_C_LEX_0_IS_EOF N // if Y, ends parsing at '\\0'; if N, returns '\\0' as token" + } + }, + "STB_C_LEX_INTEGERS_AS_DOUBLES": { + "name": "STB_C_LEX_INTEGERS_AS_DOUBLES", + "value": "N", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 90, + "column": 1, + "source_line": "#define STB_C_LEX_INTEGERS_AS_DOUBLES N // parses integers as doubles so they can be larger than 'int', but only if STB_C_LEX_STDLIB==N" + } + }, + "STB_C_LEX_MULTILINE_DSTRINGS": { + "name": "STB_C_LEX_MULTILINE_DSTRINGS", + "value": "N", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 91, + "column": 1, + "source_line": "#define STB_C_LEX_MULTILINE_DSTRINGS N // allow newlines in double-quoted strings" + } + }, + "STB_C_LEX_MULTILINE_SSTRINGS": { + "name": "STB_C_LEX_MULTILINE_SSTRINGS", + "value": "N", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 92, + "column": 1, + "source_line": "#define STB_C_LEX_MULTILINE_SSTRINGS N // allow newlines in single-quoted strings" + } + }, + "STB_C_LEX_USE_STDLIB": { + "name": "STB_C_LEX_USE_STDLIB", + "value": "Y", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 93, + "column": 1, + "source_line": "#define STB_C_LEX_USE_STDLIB Y // use strtod,strtol for parsing #s; otherwise inaccurate hack" + } + }, + "STB_C_LEX_DOLLAR_IDENTIFIER": { + "name": "STB_C_LEX_DOLLAR_IDENTIFIER", + "value": "Y", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 94, + "column": 1, + "source_line": "#define STB_C_LEX_DOLLAR_IDENTIFIER Y // allow $ as an identifier character" + } + }, + "STB_C_LEX_FLOAT_NO_DECIMAL": { + "name": "STB_C_LEX_FLOAT_NO_DECIMAL", + "value": "Y", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 95, + "column": 1, + "source_line": "#define STB_C_LEX_FLOAT_NO_DECIMAL Y // allow floats that have no decimal point if they have an exponent" + } + }, + "STB_C_LEX_DEFINE_ALL_TOKEN_NAMES": { + "name": "STB_C_LEX_DEFINE_ALL_TOKEN_NAMES", + "value": "N", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 97, + "column": 1, + "source_line": "#define STB_C_LEX_DEFINE_ALL_TOKEN_NAMES N // if Y, all CLEX_ token names are defined, even if never returned" + } + }, + "STB_C_LEX_DISCARD_PREPROCESSOR": { + "name": "STB_C_LEX_DISCARD_PREPROCESSOR", + "value": "Y", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 100, + "column": 1, + "source_line": "#define STB_C_LEX_DISCARD_PREPROCESSOR Y // discard C-preprocessor directives (e.g. after prepocess" + } + }, + "STB_C_LEXER_DEFINITIONS": { + "name": "STB_C_LEXER_DEFINITIONS", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 105, + "column": 1, + "source_line": "#define STB_C_LEXER_DEFINITIONS // This line prevents the header file from replacing your definitions" + } + }, + "INCLUDE_STB_C_LEXER_H": { + "name": "INCLUDE_STB_C_LEXER_H", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 111, + "column": 1, + "source_line": "#define INCLUDE_STB_C_LEXER_H" + } + }, + "Y": { + "name": "Y", + "value": "a", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 268, + "column": 1, + "source_line": "#define Y(a) a" + } + }, + "N": { + "name": "N", + "value": null, + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 270, + "column": 1, + "source_line": "#define N(a)" + } + }, + "intfield": { + "name": "intfield", + "value": "int_number", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 226, + "column": 1, + "source_line": "#define intfield int_number" + } + }, + "STB__clex_int_as_double": { + "name": "STB__clex_int_as_double", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 223, + "column": 1, + "source_line": "#define STB__clex_int_as_double" + } + }, + "STB__clex_parse_suffixes": { + "name": "STB__clex_parse_suffixes", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 233, + "column": 1, + "source_line": "#define STB__clex_parse_suffixes" + } + }, + "STB__clex_hex_floats": { + "name": "STB__clex_hex_floats", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 237, + "column": 1, + "source_line": "#define STB__clex_hex_floats" + } + }, + "STB__clex_hex_ints": { + "name": "STB__clex_hex_ints", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 241, + "column": 1, + "source_line": "#define STB__clex_hex_ints" + } + }, + "STB__clex_decimal_ints": { + "name": "STB__clex_decimal_ints", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 245, + "column": 1, + "source_line": "#define STB__clex_decimal_ints" + } + }, + "STB__clex_octal_ints": { + "name": "STB__clex_octal_ints", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 249, + "column": 1, + "source_line": "#define STB__clex_octal_ints" + } + }, + "STB__clex_decimal_floats": { + "name": "STB__clex_decimal_floats", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 253, + "column": 1, + "source_line": "#define STB__clex_decimal_floats" + } + }, + "STB__clex_discard_preprocessor": { + "name": "STB__clex_discard_preprocessor", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 257, + "column": 1, + "source_line": "#define STB__clex_discard_preprocessor" + } + }, + "STB__CLEX_use_stdlib": { + "name": "STB__CLEX_use_stdlib", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 261, + "column": 1, + "source_line": "#define STB__CLEX_use_stdlib" + } + }, + "_CRT_SECURE_NO_WARNINGS": { + "name": "_CRT_SECURE_NO_WARNINGS", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 804, + "column": 1, + "source_line": "#define _CRT_SECURE_NO_WARNINGS" + } + } + }, + "includes": { + "stb/stb_c_lexer.h:stdlib.h": { + "target": "stdlib.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 806, + "column": 1, + "source_line": "#include " + } + }, + "stb/stb_c_lexer.h:stdio.h": { + "target": "stdio.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 805, + "column": 1, + "source_line": "#include " + } + } + }, + "functions_by_file": { + "stb/stb_c_lexer.h": [ + "stb_c_lexer_init", + "stb_c_lexer_get_location", + "stb__clex_token", + "stb__clex_eof", + "stb__clex_iswhite", + "stb__strchr", + "stb__clex_parse_suffixes", + "stb__clex_pow", + "stb__clex_parse_float", + "stb__clex_parse_char", + "stb__clex_parse_string", + "stb_c_lexer_get_token", + "print_token", + "dummy", + "main" + ] + }, + "enum_constants": { + "CLEX_eof": { + "name": "CLEX_eof", + "value": "256", + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 177, + "column": 1, + "source_line": "enum" + } + }, + "CLEX_parse_error": { + "name": "CLEX_parse_error", + "value": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 177, + "column": 1, + "source_line": "enum" + } + }, + "CLEX_intlit": { + "name": "CLEX_intlit", + "value": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 177, + "column": 1, + "source_line": "enum" + } + }, + "CLEX_floatlit": { + "name": "CLEX_floatlit", + "value": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 177, + "column": 1, + "source_line": "enum" + } + }, + "CLEX_id": { + "name": "CLEX_id", + "value": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 177, + "column": 1, + "source_line": "enum" + } + }, + "CLEX_dqstring": { + "name": "CLEX_dqstring", + "value": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 177, + "column": 1, + "source_line": "enum" + } + }, + "CLEX_sqstring": { + "name": "CLEX_sqstring", + "value": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 177, + "column": 1, + "source_line": "enum" + } + }, + "CLEX_charlit": { + "name": "CLEX_charlit", + "value": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 177, + "column": 1, + "source_line": "enum" + } + }, + "CLEX_eq": { + "name": "CLEX_eq", + "value": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 177, + "column": 1, + "source_line": "enum" + } + }, + "CLEX_noteq": { + "name": "CLEX_noteq", + "value": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 177, + "column": 1, + "source_line": "enum" + } + }, + "CLEX_lesseq": { + "name": "CLEX_lesseq", + "value": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 177, + "column": 1, + "source_line": "enum" + } + }, + "CLEX_greatereq": { + "name": "CLEX_greatereq", + "value": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 177, + "column": 1, + "source_line": "enum" + } + }, + "CLEX_andand": { + "name": "CLEX_andand", + "value": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 177, + "column": 1, + "source_line": "enum" + } + }, + "CLEX_oror": { + "name": "CLEX_oror", + "value": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 177, + "column": 1, + "source_line": "enum" + } + }, + "CLEX_shl": { + "name": "CLEX_shl", + "value": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 177, + "column": 1, + "source_line": "enum" + } + }, + "CLEX_shr": { + "name": "CLEX_shr", + "value": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 177, + "column": 1, + "source_line": "enum" + } + }, + "CLEX_plusplus": { + "name": "CLEX_plusplus", + "value": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 177, + "column": 1, + "source_line": "enum" + } + }, + "CLEX_minusminus": { + "name": "CLEX_minusminus", + "value": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 177, + "column": 1, + "source_line": "enum" + } + }, + "CLEX_pluseq": { + "name": "CLEX_pluseq", + "value": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 177, + "column": 1, + "source_line": "enum" + } + }, + "CLEX_minuseq": { + "name": "CLEX_minuseq", + "value": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 177, + "column": 1, + "source_line": "enum" + } + }, + "CLEX_muleq": { + "name": "CLEX_muleq", + "value": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 177, + "column": 1, + "source_line": "enum" + } + }, + "CLEX_diveq": { + "name": "CLEX_diveq", + "value": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 177, + "column": 1, + "source_line": "enum" + } + }, + "CLEX_modeq": { + "name": "CLEX_modeq", + "value": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 177, + "column": 1, + "source_line": "enum" + } + }, + "CLEX_andeq": { + "name": "CLEX_andeq", + "value": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 177, + "column": 1, + "source_line": "enum" + } + }, + "CLEX_oreq": { + "name": "CLEX_oreq", + "value": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 177, + "column": 1, + "source_line": "enum" + } + }, + "CLEX_xoreq": { + "name": "CLEX_xoreq", + "value": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 177, + "column": 1, + "source_line": "enum" + } + }, + "CLEX_arrow": { + "name": "CLEX_arrow", + "value": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 177, + "column": 1, + "source_line": "enum" + } + }, + "CLEX_eqarrow": { + "name": "CLEX_eqarrow", + "value": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 177, + "column": 1, + "source_line": "enum" + } + }, + "CLEX_shleq": { + "name": "CLEX_shleq", + "value": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 177, + "column": 1, + "source_line": "enum" + } + }, + "CLEX_shreq": { + "name": "CLEX_shreq", + "value": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 177, + "column": 1, + "source_line": "enum" + } + }, + "CLEX_first_unused_token": { + "name": "CLEX_first_unused_token", + "value": null, + "source_location": { + "filename": "stb/stb_c_lexer.h", + "line": 177, + "column": 1, + "source_line": "enum" + } + } + }, + "include_graph": { + "stb/stb_c_lexer.h": [] + }, + "system_includes": { + "stb/stb_c_lexer.h": [ + "stdio.h", + "stdlib.h" + ] + }, + "unresolved_includes": { + "stb/stb_c_lexer.h": [] + }, + "header_source_pairs": { + "stb/stb_c_lexer.h": [] + }, + "diagnostics": [ + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'Y' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_c_lexer.h", + "line": 217, + "column": 1, + "source_line": "#define Y(x) 1" + }, + "unit_kind": "macro", + "unit_name": "Y" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'N' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_c_lexer.h", + "line": 218, + "column": 1, + "source_line": "#define N(x) 0" + }, + "unit_kind": "macro", + "unit_name": "N" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'Y' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_c_lexer.h", + "line": 268, + "column": 1, + "source_line": "#define Y(a) a" + }, + "unit_kind": "macro", + "unit_name": "Y" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'N' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_c_lexer.h", + "line": 270, + "column": 1, + "source_line": "#define N(a)" + }, + "unit_kind": "macro", + "unit_name": "N" + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '\"C\"'.", + "severity": "warning", + "location": { + "filename": "stb/stb_c_lexer.h", + "line": 141, + "column": 1, + "source_line": "extern \"C\" {" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_CONFLICTING_TYPEDEF", + "message": "Conflicting typedef declarations for 'stb__clex_int'.", + "severity": "error", + "location": { + "filename": "stb/stb_c_lexer.h", + "line": 225, + "column": 1, + "source_line": "typedef long stb__clex_int;" + }, + "unit_kind": "typedef", + "unit_name": "stb__clex_int" + } + ] +} diff --git a/tests/parser/c/fixtures/stb/stb_connected_components.json b/tests/parser/c/fixtures/stb/stb_connected_components.json new file mode 100644 index 000000000..6804bf073 --- /dev/null +++ b/tests/parser/c/fixtures/stb/stb_connected_components.json @@ -0,0 +1,6816 @@ +{ + "files": { + "stb/stb_connected_components.h": { + "filename": "stb/stb_connected_components.h", + "language": "c", + "parser_status": "partial", + "preprocessing": "raw", + "functions": [ + { + "name": "stbcc_query_grid_node_connection", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "g", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc_grid *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbcc_grid", + "name": "stbcc_grid", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": "st_stbcc_grid", + "members": [ + { + "name": "w", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 264, + "column": 4, + "source_line": " int w,h,cw,ch;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "h", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 264, + "column": 4, + "source_line": " int w,h,cw,ch;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "cw", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int cw" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 264, + "column": 4, + "source_line": " int w,h,cw,ch;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "ch", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ch" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 264, + "column": 4, + "source_line": " int w,h,cw,ch;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "in_batched_update", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int in_batched_update" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 265, + "column": 4, + "source_line": " int in_batched_update;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "map", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char map[STBCC__GRID_COUNT_Y][STBCC__MAP_STRIDE]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STBCC__GRID_COUNT_Y", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STBCC__MAP_STRIDE", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 267, + "column": 4, + "source_line": " unsigned char map[STBCC__GRID_COUNT_Y][STBCC__MAP_STRIDE]; // 1K x 1K => 1K x 128 => 128KB" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "clump_for_node", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc__clumpid clump_for_node[STBCC__GRID_COUNT_Y][STBCC__GRID_COUNT_X]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STBCC__GRID_COUNT_Y", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STBCC__GRID_COUNT_X", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbcc__clumpid", + "name": "stbcc__clumpid", + "type": { + "model": "CUnsignedShort", + "qualifiers": [], + "source_text": "typedef unsigned short stbcc__clumpid" + }, + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 199, + "column": 1, + "source_line": "typedef unsigned short stbcc__clumpid;" + }, + "declaration_locations": [] + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 268, + "column": 4, + "source_line": " stbcc__clumpid clump_for_node[STBCC__GRID_COUNT_Y][STBCC__GRID_COUNT_X]; // 1K x 1K x 2 = 2MB" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "cluster", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc__cluster cluster[STBCC__CLUSTER_COUNT_Y][STBCC__CLUSTER_COUNT_X]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STBCC__CLUSTER_COUNT_Y", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STBCC__CLUSTER_COUNT_X", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbcc__cluster", + "name": "stbcc__cluster", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "num_clumps", + "type": { + "model": "CShort", + "qualifiers": [], + "source_text": "short num_clumps" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 255, + "column": 4, + "source_line": " short num_clumps;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "num_edge_clumps", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char num_edge_clumps" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 256, + "column": 4, + "source_line": " unsigned char num_edge_clumps;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "rebuild_adjacency", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char rebuild_adjacency" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 257, + "column": 4, + "source_line": " unsigned char rebuild_adjacency;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "clump", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc__clump clump[STBCC__MAX_CLUMPS_PER_CLUSTER]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STBCC__MAX_CLUMPS_PER_CLUSTER", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbcc__clump", + "name": "stbcc__clump", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "global_label", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbcc__global_clumpid", + "name": "stbcc__global_clumpid", + "type": { + "model": "CUnion", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "c", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int c" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 236, + "column": 4, + "source_line": " unsigned int c;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "union@stb/stb_connected_components.h:229:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 229, + "column": 1, + "source_line": "typedef union" + } + }, + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 229, + "column": 1, + "source_line": "typedef union" + }, + "declaration_locations": [] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 245, + "column": 4, + "source_line": " stbcc__global_clumpid global_label; // 4" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "num_adjacent", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char num_adjacent" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 246, + "column": 4, + "source_line": " unsigned char num_adjacent; // 1" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "max_adjacent", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char max_adjacent" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 247, + "column": 4, + "source_line": " unsigned char max_adjacent; // 1" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "adjacent_clump_list_index", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char adjacent_clump_list_index" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 248, + "column": 4, + "source_line": " unsigned char adjacent_clump_list_index; // 1" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "reserved", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char reserved" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 249, + "column": 4, + "source_line": " unsigned char reserved;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_connected_components.h:243:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 243, + "column": 1, + "source_line": "typedef struct" + } + }, + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 243, + "column": 1, + "source_line": "typedef struct" + }, + "declaration_locations": [] + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 258, + "column": 4, + "source_line": " stbcc__clump clump[STBCC__MAX_CLUMPS_PER_CLUSTER]; // 8 * 2^9 = 4KB" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "adjacency_storage", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc__relative_clumpid adjacency_storage[STBCC__CLUSTER_ADJACENCY_COUNT]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STBCC__CLUSTER_ADJACENCY_COUNT", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbcc__relative_clumpid", + "name": "stbcc__relative_clumpid", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "clump_index", + "type": { + "model": "CUnsignedShort", + "qualifiers": [], + "source_text": "unsigned short clump_index" + }, + "storage": [], + "initializer": null, + "bit_width": "12", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 224, + "column": 4, + "source_line": " unsigned short clump_index:12;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "cluster_dx", + "type": { + "model": "CShort", + "qualifiers": [], + "source_text": "signed short cluster_dx" + }, + "storage": [], + "initializer": null, + "bit_width": "2", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 225, + "column": 6, + "source_line": " signed short cluster_dx:2;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "cluster_dy", + "type": { + "model": "CShort", + "qualifiers": [], + "source_text": "signed short cluster_dy" + }, + "storage": [], + "initializer": null, + "bit_width": "2", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 226, + "column": 6, + "source_line": " signed short cluster_dy:2;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_connected_components.h:222:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 222, + "column": 1, + "source_line": "typedef struct" + } + }, + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 222, + "column": 1, + "source_line": "typedef struct" + }, + "declaration_locations": [] + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 259, + "column": 4, + "source_line": " stbcc__relative_clumpid adjacency_storage[STBCC__CLUSTER_ADJACENCY_COUNT]; // 256 bytes" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_connected_components.h:253:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 253, + "column": 1, + "source_line": "typedef struct" + } + }, + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 253, + "column": 1, + "source_line": "typedef struct" + }, + "declaration_locations": [] + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 269, + "column": 4, + "source_line": " stbcc__cluster cluster[STBCC__CLUSTER_COUNT_Y][STBCC__CLUSTER_COUNT_X]; // 1K x 4.5KB = 4.5MB" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": null, + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 262, + "column": 1, + "source_line": "struct st_stbcc_grid" + } + }, + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 88, + "column": 1, + "source_line": "typedef struct st_stbcc_grid stbcc_grid;" + }, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc_grid *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc_grid" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x2", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x2" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x2" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y2", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y2" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y2" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 272, + "column": 1, + "source_line": "int stbcc_query_grid_node_connection(stbcc_grid *g, int x1, int y1, int x2, int y2)" + }, + "start": { + "filename": "stb/stb_connected_components.h", + "line": 272, + "column": 1, + "source_line": "int stbcc_query_grid_node_connection(stbcc_grid *g, int x1, int y1, int x2, int y2)" + }, + "end": { + "filename": "stb/stb_connected_components.h", + "line": 289, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbcc_query_grid_open", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "g", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc_grid *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc_grid" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc_grid *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc_grid" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 291, + "column": 1, + "source_line": "int stbcc_query_grid_open(stbcc_grid *g, int x, int y)" + }, + "start": { + "filename": "stb/stb_connected_components.h", + "line": 291, + "column": 1, + "source_line": "int stbcc_query_grid_open(stbcc_grid *g, int x, int y)" + }, + "end": { + "filename": "stb/stb_connected_components.h", + "line": 294, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbcc_get_unique_id", + "result_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int" + }, + "parameters": [ + { + "name": "g", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc_grid *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc_grid" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc_grid *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc_grid" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 296, + "column": 1, + "source_line": "unsigned int stbcc_get_unique_id(stbcc_grid *g, int x, int y)" + }, + "start": { + "filename": "stb/stb_connected_components.h", + "line": 296, + "column": 1, + "source_line": "unsigned int stbcc_get_unique_id(stbcc_grid *g, int x, int y)" + }, + "end": { + "filename": "stb/stb_connected_components.h", + "line": 304, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbcc__build_clumps_for_cluster", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "g", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc_grid *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc_grid" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc_grid *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc_grid" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cx", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int cx" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int cx" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cy", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int cy" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int cy" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 863, + "column": 1, + "source_line": "static void stbcc__build_clumps_for_cluster(stbcc_grid *g, int cx, int cy)" + }, + "start": { + "filename": "stb/stb_connected_components.h", + "line": 863, + "column": 1, + "source_line": "static void stbcc__build_clumps_for_cluster(stbcc_grid *g, int cx, int cy)" + }, + "end": { + "filename": "stb/stb_connected_components.h", + "line": 1006, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_connected_components.h", + "line": 317, + "column": 1, + "source_line": "static void stbcc__build_clumps_for_cluster(stbcc_grid *g, int cx, int cy);" + } + ] + }, + { + "name": "stbcc__remove_connections_to_adjacent_cluster", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "g", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc_grid *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc_grid" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc_grid *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc_grid" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cx", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int cx" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int cx" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cy", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int cy" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int cy" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dx", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int dx" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int dx" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dy", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int dy" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int dy" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 775, + "column": 1, + "source_line": "static void stbcc__remove_connections_to_adjacent_cluster(stbcc_grid *g, int cx, int cy, int dx, int dy)" + }, + "start": { + "filename": "stb/stb_connected_components.h", + "line": 775, + "column": 1, + "source_line": "static void stbcc__remove_connections_to_adjacent_cluster(stbcc_grid *g, int cx, int cy, int dx, int dy)" + }, + "end": { + "filename": "stb/stb_connected_components.h", + "line": 831, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_connected_components.h", + "line": 318, + "column": 1, + "source_line": "static void stbcc__remove_connections_to_adjacent_cluster(stbcc_grid *g, int cx, int cy, int dx, int dy);" + } + ] + }, + { + "name": "stbcc__add_connections_to_adjacent_cluster", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "g", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc_grid *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc_grid" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc_grid *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc_grid" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cx", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int cx" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int cx" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cy", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int cy" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int cy" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dx", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int dx" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int dx" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dy", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int dy" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int dy" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 711, + "column": 1, + "source_line": "static void stbcc__add_connections_to_adjacent_cluster(stbcc_grid *g, int cx, int cy, int dx, int dy)" + }, + "start": { + "filename": "stb/stb_connected_components.h", + "line": 711, + "column": 1, + "source_line": "static void stbcc__add_connections_to_adjacent_cluster(stbcc_grid *g, int cx, int cy, int dx, int dy)" + }, + "end": { + "filename": "stb/stb_connected_components.h", + "line": 773, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_connected_components.h", + "line": 319, + "column": 1, + "source_line": "static void stbcc__add_connections_to_adjacent_cluster(stbcc_grid *g, int cx, int cy, int dx, int dy);" + } + ] + }, + { + "name": "stbcc__clump_find", + "result_type": { + "reference": "stbcc__global_clumpid" + }, + "parameters": [ + { + "name": "g", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc_grid *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc_grid" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc_grid *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc_grid" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "reference": "stbcc__global_clumpid" + }, + "declared_type": { + "reference": "stbcc__global_clumpid" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 321, + "column": 1, + "source_line": "static stbcc__global_clumpid stbcc__clump_find(stbcc_grid *g, stbcc__global_clumpid n)" + }, + "start": { + "filename": "stb/stb_connected_components.h", + "line": 321, + "column": 1, + "source_line": "static stbcc__global_clumpid stbcc__clump_find(stbcc_grid *g, stbcc__global_clumpid n)" + }, + "end": { + "filename": "stb/stb_connected_components.h", + "line": 332, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbcc__clump_union", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "g", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc_grid *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc_grid" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc_grid *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc_grid" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "m", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbcc__unpacked_clumpid", + "name": "stbcc__unpacked_clumpid", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "cluster_x", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int cluster_x" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 336, + "column": 4, + "source_line": " unsigned int cluster_x;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "cluster_y", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int cluster_y" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 337, + "column": 4, + "source_line": " unsigned int cluster_y;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "clump_index", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int clump_index" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 338, + "column": 4, + "source_line": " unsigned int clump_index;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_connected_components.h:334:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 334, + "column": 1, + "source_line": "typedef struct" + } + }, + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 334, + "column": 1, + "source_line": "typedef struct" + }, + "declaration_locations": [] + }, + "declared_type": { + "reference": "stbcc__unpacked_clumpid" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "idx", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int idx" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int idx" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 341, + "column": 1, + "source_line": "static void stbcc__clump_union(stbcc_grid *g, stbcc__unpacked_clumpid m, int x, int y, int idx)" + }, + "start": { + "filename": "stb/stb_connected_components.h", + "line": 341, + "column": 1, + "source_line": "static void stbcc__clump_union(stbcc_grid *g, stbcc__unpacked_clumpid m, int x, int y, int idx)" + }, + "end": { + "filename": "stb/stb_connected_components.h", + "line": 352, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbcc__build_connected_components_for_clumps", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "g", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc_grid *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc_grid" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc_grid *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc_grid" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 354, + "column": 1, + "source_line": "static void stbcc__build_connected_components_for_clumps(stbcc_grid *g)" + }, + "start": { + "filename": "stb/stb_connected_components.h", + "line": 354, + "column": 1, + "source_line": "static void stbcc__build_connected_components_for_clumps(stbcc_grid *g)" + }, + "end": { + "filename": "stb/stb_connected_components.h", + "line": 405, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbcc__build_all_connections_for_cluster", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "g", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc_grid *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc_grid" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc_grid *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc_grid" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cx", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int cx" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int cx" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cy", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int cy" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int cy" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 407, + "column": 1, + "source_line": "static void stbcc__build_all_connections_for_cluster(stbcc_grid *g, int cx, int cy)" + }, + "start": { + "filename": "stb/stb_connected_components.h", + "line": 407, + "column": 1, + "source_line": "static void stbcc__build_all_connections_for_cluster(stbcc_grid *g, int cx, int cy)" + }, + "end": { + "filename": "stb/stb_connected_components.h", + "line": 517, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbcc__add_connections_to_adjacent_cluster_with_rebuild", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "g", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc_grid *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc_grid" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc_grid *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc_grid" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cx", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int cx" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int cx" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cy", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int cy" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int cy" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dx", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int dx" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int dx" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dy", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int dy" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int dy" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 519, + "column": 1, + "source_line": "static void stbcc__add_connections_to_adjacent_cluster_with_rebuild(stbcc_grid *g, int cx, int cy, int dx, int dy)" + }, + "start": { + "filename": "stb/stb_connected_components.h", + "line": 519, + "column": 1, + "source_line": "static void stbcc__add_connections_to_adjacent_cluster_with_rebuild(stbcc_grid *g, int cx, int cy, int dx, int dy)" + }, + "end": { + "filename": "stb/stb_connected_components.h", + "line": 526, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbcc_update_grid", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "g", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc_grid *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc_grid" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc_grid *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc_grid" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "solid", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int solid" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int solid" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 528, + "column": 1, + "source_line": "void stbcc_update_grid(stbcc_grid *g, int x, int y, int solid)" + }, + "start": { + "filename": "stb/stb_connected_components.h", + "line": 528, + "column": 1, + "source_line": "void stbcc_update_grid(stbcc_grid *g, int x, int y, int solid)" + }, + "end": { + "filename": "stb/stb_connected_components.h", + "line": 567, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbcc_update_batch_begin", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "g", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc_grid *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc_grid" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc_grid *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc_grid" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 569, + "column": 1, + "source_line": "void stbcc_update_batch_begin(stbcc_grid *g)" + }, + "start": { + "filename": "stb/stb_connected_components.h", + "line": 569, + "column": 1, + "source_line": "void stbcc_update_batch_begin(stbcc_grid *g)" + }, + "end": { + "filename": "stb/stb_connected_components.h", + "line": 573, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbcc_update_batch_end", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "g", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc_grid *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc_grid" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc_grid *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc_grid" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 575, + "column": 1, + "source_line": "void stbcc_update_batch_end(stbcc_grid *g)" + }, + "start": { + "filename": "stb/stb_connected_components.h", + "line": 575, + "column": 1, + "source_line": "void stbcc_update_batch_end(stbcc_grid *g)" + }, + "end": { + "filename": "stb/stb_connected_components.h", + "line": 580, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbcc_grid_sizeof", + "result_type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "parameters": [], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 582, + "column": 1, + "source_line": "size_t stbcc_grid_sizeof(void)" + }, + "start": { + "filename": "stb/stb_connected_components.h", + "line": 582, + "column": 1, + "source_line": "size_t stbcc_grid_sizeof(void)" + }, + "end": { + "filename": "stb/stb_connected_components.h", + "line": 585, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbcc_init_grid", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "g", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc_grid *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc_grid" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc_grid *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc_grid" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "map", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *map", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *map", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "w", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "h", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 587, + "column": 1, + "source_line": "void stbcc_init_grid(stbcc_grid *g, unsigned char *map, int w, int h)" + }, + "start": { + "filename": "stb/stb_connected_components.h", + "line": 587, + "column": 1, + "source_line": "void stbcc_init_grid(stbcc_grid *g, unsigned char *map, int w, int h)" + }, + "end": { + "filename": "stb/stb_connected_components.h", + "line": 629, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbcc__add_clump_connection", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "g", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc_grid *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc_grid" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc_grid *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc_grid" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x2", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x2" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x2" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y2", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y2" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y2" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 632, + "column": 1, + "source_line": "static void stbcc__add_clump_connection(stbcc_grid *g, int x1, int y1, int x2, int y2)" + }, + "start": { + "filename": "stb/stb_connected_components.h", + "line": 632, + "column": 1, + "source_line": "static void stbcc__add_clump_connection(stbcc_grid *g, int x1, int y1, int x2, int y2)" + }, + "end": { + "filename": "stb/stb_connected_components.h", + "line": 667, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbcc__remove_clump_connection", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "g", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc_grid *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc_grid" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc_grid *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc_grid" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x2", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x2" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x2" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y2", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y2" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y2" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 669, + "column": 1, + "source_line": "static void stbcc__remove_clump_connection(stbcc_grid *g, int x1, int y1, int x2, int y2)" + }, + "start": { + "filename": "stb/stb_connected_components.h", + "line": 669, + "column": 1, + "source_line": "static void stbcc__remove_clump_connection(stbcc_grid *g, int x1, int y1, int x2, int y2)" + }, + "end": { + "filename": "stb/stb_connected_components.h", + "line": 709, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbcc__incluster_find", + "result_type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbcc__tinypoint", + "name": "stbcc__tinypoint", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "x", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char x" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 308, + "column": 4, + "source_line": " unsigned char x,y;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "y", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char y" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 308, + "column": 4, + "source_line": " unsigned char x,y;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_connected_components.h:306:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 306, + "column": 1, + "source_line": "typedef struct" + } + }, + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 306, + "column": 1, + "source_line": "typedef struct" + }, + "declaration_locations": [] + }, + "parameters": [ + { + "name": "cbi", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc__cluster_build_info *cbi", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbcc__cluster_build_info", + "name": "stbcc__cluster_build_info", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "parent", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc__tinypoint parent[STBCC__CLUSTER_SIZE_Y][STBCC__CLUSTER_SIZE_X]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STBCC__CLUSTER_SIZE_Y", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STBCC__CLUSTER_SIZE_X", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "reference": "stbcc__tinypoint" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 313, + "column": 4, + "source_line": " stbcc__tinypoint parent[STBCC__CLUSTER_SIZE_Y][STBCC__CLUSTER_SIZE_X]; // 32x32 => 2KB" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "label", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc__clumpid label[STBCC__CLUSTER_SIZE_Y][STBCC__CLUSTER_SIZE_X]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STBCC__CLUSTER_SIZE_Y", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STBCC__CLUSTER_SIZE_X", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "reference": "stbcc__clumpid" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 314, + "column": 4, + "source_line": " stbcc__clumpid label[STBCC__CLUSTER_SIZE_Y][STBCC__CLUSTER_SIZE_X];" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_connected_components.h:311:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 311, + "column": 1, + "source_line": "typedef struct" + } + }, + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 311, + "column": 1, + "source_line": "typedef struct" + }, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc__cluster_build_info *cbi", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc__cluster_build_info" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 833, + "column": 1, + "source_line": "static stbcc__tinypoint stbcc__incluster_find(stbcc__cluster_build_info *cbi, int x, int y)" + }, + "start": { + "filename": "stb/stb_connected_components.h", + "line": 833, + "column": 1, + "source_line": "static stbcc__tinypoint stbcc__incluster_find(stbcc__cluster_build_info *cbi, int x, int y)" + }, + "end": { + "filename": "stb/stb_connected_components.h", + "line": 842, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbcc__incluster_union", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "cbi", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc__cluster_build_info *cbi", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc__cluster_build_info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc__cluster_build_info *cbi", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc__cluster_build_info" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x2", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x2" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x2" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y2", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y2" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y2" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 844, + "column": 1, + "source_line": "static void stbcc__incluster_union(stbcc__cluster_build_info *cbi, int x1, int y1, int x2, int y2)" + }, + "start": { + "filename": "stb/stb_connected_components.h", + "line": 844, + "column": 1, + "source_line": "static void stbcc__incluster_union(stbcc__cluster_build_info *cbi, int x1, int y1, int x2, int y2)" + }, + "end": { + "filename": "stb/stb_connected_components.h", + "line": 853, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbcc__switch_root", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "cbi", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc__cluster_build_info *cbi", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc__cluster_build_info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc__cluster_build_info *cbi", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc__cluster_build_info" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p", + "type": { + "reference": "stbcc__tinypoint" + }, + "declared_type": { + "reference": "stbcc__tinypoint" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 855, + "column": 1, + "source_line": "static void stbcc__switch_root(stbcc__cluster_build_info *cbi, int x, int y, stbcc__tinypoint p)" + }, + "start": { + "filename": "stb/stb_connected_components.h", + "line": 855, + "column": 1, + "source_line": "static void stbcc__switch_root(stbcc__cluster_build_info *cbi, int x, int y, stbcc__tinypoint p)" + }, + "end": { + "filename": "stb/stb_connected_components.h", + "line": 861, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + } + ], + "structs": [ + { + "reference": "struct@stb/stb_connected_components.h:222:1" + }, + { + "reference": "struct@stb/stb_connected_components.h:243:1" + }, + { + "reference": "struct@stb/stb_connected_components.h:253:1" + }, + { + "reference": "struct st_stbcc_grid" + }, + { + "reference": "struct@stb/stb_connected_components.h:306:1" + }, + { + "reference": "struct@stb/stb_connected_components.h:311:1" + }, + { + "reference": "struct@stb/stb_connected_components.h:334:1" + } + ], + "unions": [ + { + "reference": "union@stb/stb_connected_components.h:229:1" + } + ], + "enums": [], + "typedefs": [ + { + "reference": "stbcc_grid" + }, + { + "reference": "stbcc__clumpid" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbcc__verify_max_clumps", + "name": "stbcc__verify_max_clumps", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "typedef unsigned char stbcc__verify_max_clumps[STBCC__MAX_CLUMPS_PER_CLUSTER < (1 << (8*sizeof(stbcc__clumpid))) ? 1 : -1]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STBCC__MAX_CLUMPS_PER_CLUSTER < (1 << (8*sizeof(stbcc__clumpid))) ? 1 : -1", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 200, + "column": 1, + "source_line": "typedef unsigned char stbcc__verify_max_clumps[STBCC__MAX_CLUMPS_PER_CLUSTER < (1 << (8*sizeof(stbcc__clumpid))) ? 1 : -1];" + }, + "declaration_locations": [] + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbcc__verify_max_exits", + "name": "stbcc__verify_max_exits", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "typedef unsigned char stbcc__verify_max_exits[STBCC__MAX_EXITS_PER_CLUMP <= 256]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STBCC__MAX_EXITS_PER_CLUMP <= 256", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 220, + "column": 1, + "source_line": "typedef unsigned char stbcc__verify_max_exits[STBCC__MAX_EXITS_PER_CLUMP <= 256];" + }, + "declaration_locations": [] + }, + { + "reference": "stbcc__relative_clumpid" + }, + { + "reference": "stbcc__global_clumpid" + }, + { + "reference": "stbcc__clump" + }, + { + "reference": "stbcc__cluster" + }, + { + "reference": "stbcc__tinypoint" + }, + { + "reference": "stbcc__cluster_build_info" + }, + { + "reference": "stbcc__unpacked_clumpid" + } + ], + "variables": [], + "macros": [ + { + "name": "INCLUDE_STB_CONNECTED_COMPONENTS_H", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 84, + "column": 1, + "source_line": "#define INCLUDE_STB_CONNECTED_COMPONENTS_H" + } + }, + { + "name": "STBCC_NULL_UNIQUE_ID", + "value": "0xffffffff", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 135, + "column": 1, + "source_line": "#define STBCC_NULL_UNIQUE_ID 0xffffffff // returned for closed map squares" + } + }, + { + "name": "STBCC__GRID_COUNT_X", + "value": "(1 << STBCC_GRID_COUNT_X_LOG2)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 152, + "column": 1, + "source_line": "#define STBCC__GRID_COUNT_X (1 << STBCC_GRID_COUNT_X_LOG2)" + } + }, + { + "name": "STBCC__GRID_COUNT_Y", + "value": "(1 << STBCC_GRID_COUNT_Y_LOG2)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 153, + "column": 1, + "source_line": "#define STBCC__GRID_COUNT_Y (1 << STBCC_GRID_COUNT_Y_LOG2)" + } + }, + { + "name": "STBCC__MAP_STRIDE", + "value": "(1 << (STBCC_GRID_COUNT_X_LOG2-3))", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 155, + "column": 1, + "source_line": "#define STBCC__MAP_STRIDE (1 << (STBCC_GRID_COUNT_X_LOG2-3))" + } + }, + { + "name": "STBCC_CLUSTER_SIZE_X_LOG2", + "value": "(STBCC_GRID_COUNT_X_LOG2/2)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 158, + "column": 4, + "source_line": " #define STBCC_CLUSTER_SIZE_X_LOG2 (STBCC_GRID_COUNT_X_LOG2/2) // log2(sqrt(2^N)) = 1/2 * log2(2^N)) = 1/2 * N" + } + }, + { + "name": "STBCC_CLUSTER_SIZE_X_LOG2", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 160, + "column": 4, + "source_line": " #undef STBCC_CLUSTER_SIZE_X_LOG2" + } + }, + { + "name": "STBCC_CLUSTER_SIZE_X_LOG2", + "value": "6", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 161, + "column": 4, + "source_line": " #define STBCC_CLUSTER_SIZE_X_LOG2 6" + } + }, + { + "name": "STBCC_CLUSTER_SIZE_Y_LOG2", + "value": "(STBCC_GRID_COUNT_Y_LOG2/2)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 166, + "column": 4, + "source_line": " #define STBCC_CLUSTER_SIZE_Y_LOG2 (STBCC_GRID_COUNT_Y_LOG2/2)" + } + }, + { + "name": "STBCC_CLUSTER_SIZE_Y_LOG2", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 168, + "column": 4, + "source_line": " #undef STBCC_CLUSTER_SIZE_Y_LOG2" + } + }, + { + "name": "STBCC_CLUSTER_SIZE_Y_LOG2", + "value": "6", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 169, + "column": 4, + "source_line": " #define STBCC_CLUSTER_SIZE_Y_LOG2 6" + } + }, + { + "name": "STBCC__CLUSTER_SIZE_X", + "value": "(1 << STBCC_CLUSTER_SIZE_X_LOG2)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 173, + "column": 1, + "source_line": "#define STBCC__CLUSTER_SIZE_X (1 << STBCC_CLUSTER_SIZE_X_LOG2)" + } + }, + { + "name": "STBCC__CLUSTER_SIZE_Y", + "value": "(1 << STBCC_CLUSTER_SIZE_Y_LOG2)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 174, + "column": 1, + "source_line": "#define STBCC__CLUSTER_SIZE_Y (1 << STBCC_CLUSTER_SIZE_Y_LOG2)" + } + }, + { + "name": "STBCC__CLUSTER_COUNT_X_LOG2", + "value": "(STBCC_GRID_COUNT_X_LOG2 - STBCC_CLUSTER_SIZE_X_LOG2)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 176, + "column": 1, + "source_line": "#define STBCC__CLUSTER_COUNT_X_LOG2 (STBCC_GRID_COUNT_X_LOG2 - STBCC_CLUSTER_SIZE_X_LOG2)" + } + }, + { + "name": "STBCC__CLUSTER_COUNT_Y_LOG2", + "value": "(STBCC_GRID_COUNT_Y_LOG2 - STBCC_CLUSTER_SIZE_Y_LOG2)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 177, + "column": 1, + "source_line": "#define STBCC__CLUSTER_COUNT_Y_LOG2 (STBCC_GRID_COUNT_Y_LOG2 - STBCC_CLUSTER_SIZE_Y_LOG2)" + } + }, + { + "name": "STBCC__CLUSTER_COUNT_X", + "value": "(1 << STBCC__CLUSTER_COUNT_X_LOG2)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 179, + "column": 1, + "source_line": "#define STBCC__CLUSTER_COUNT_X (1 << STBCC__CLUSTER_COUNT_X_LOG2)" + } + }, + { + "name": "STBCC__CLUSTER_COUNT_Y", + "value": "(1 << STBCC__CLUSTER_COUNT_Y_LOG2)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 180, + "column": 1, + "source_line": "#define STBCC__CLUSTER_COUNT_Y (1 << STBCC__CLUSTER_COUNT_Y_LOG2)" + } + }, + { + "name": "STBCC__MAX_CLUMPS_PER_CLUSTER_LOG2", + "value": "(STBCC_CLUSTER_SIZE_X_LOG2 + STBCC_CLUSTER_SIZE_Y_LOG2-1)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 187, + "column": 1, + "source_line": "#define STBCC__MAX_CLUMPS_PER_CLUSTER_LOG2 (STBCC_CLUSTER_SIZE_X_LOG2 + STBCC_CLUSTER_SIZE_Y_LOG2-1)" + } + }, + { + "name": "STBCC__MAX_CLUMPS_PER_CLUSTER", + "value": "(1 << STBCC__MAX_CLUMPS_PER_CLUSTER_LOG2)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 188, + "column": 1, + "source_line": "#define STBCC__MAX_CLUMPS_PER_CLUSTER (1 << STBCC__MAX_CLUMPS_PER_CLUSTER_LOG2)" + } + }, + { + "name": "STBCC__MAX_CLUMPS", + "value": "(STBCC__MAX_CLUMPS_PER_CLUSTER * STBCC__CLUSTER_COUNT_X * STBCC__CLUSTER_COUNT_Y)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 189, + "column": 1, + "source_line": "#define STBCC__MAX_CLUMPS (STBCC__MAX_CLUMPS_PER_CLUSTER * STBCC__CLUSTER_COUNT_X * STBCC__CLUSTER_COUNT_Y)" + } + }, + { + "name": "STBCC__NULL_CLUMPID", + "value": "STBCC__MAX_CLUMPS_PER_CLUSTER", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 190, + "column": 1, + "source_line": "#define STBCC__NULL_CLUMPID STBCC__MAX_CLUMPS_PER_CLUSTER" + } + }, + { + "name": "STBCC__CLUSTER_X_FOR_COORD_X", + "value": "((x) >> STBCC_CLUSTER_SIZE_X_LOG2)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 192, + "column": 1, + "source_line": "#define STBCC__CLUSTER_X_FOR_COORD_X(x) ((x) >> STBCC_CLUSTER_SIZE_X_LOG2)" + } + }, + { + "name": "STBCC__CLUSTER_Y_FOR_COORD_Y", + "value": "((y) >> STBCC_CLUSTER_SIZE_Y_LOG2)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 193, + "column": 1, + "source_line": "#define STBCC__CLUSTER_Y_FOR_COORD_Y(y) ((y) >> STBCC_CLUSTER_SIZE_Y_LOG2)" + } + }, + { + "name": "STBCC__MAP_BYTE_MASK", + "value": "(1 << ((x) & 7))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 195, + "column": 1, + "source_line": "#define STBCC__MAP_BYTE_MASK(x,y) (1 << ((x) & 7))" + } + }, + { + "name": "STBCC__MAP_BYTE", + "value": "((g)->map[y][(x) >> 3])", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 196, + "column": 1, + "source_line": "#define STBCC__MAP_BYTE(g,x,y) ((g)->map[y][(x) >> 3])" + } + }, + { + "name": "STBCC__MAP_OPEN", + "value": "(STBCC__MAP_BYTE(g,x,y) & STBCC__MAP_BYTE_MASK(x,y))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 197, + "column": 1, + "source_line": "#define STBCC__MAP_OPEN(g,x,y) (STBCC__MAP_BYTE(g,x,y) & STBCC__MAP_BYTE_MASK(x,y))" + } + }, + { + "name": "STBCC__MAX_EXITS_PER_CLUSTER", + "value": "(STBCC__CLUSTER_SIZE_X + STBCC__CLUSTER_SIZE_Y)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 202, + "column": 1, + "source_line": "#define STBCC__MAX_EXITS_PER_CLUSTER (STBCC__CLUSTER_SIZE_X + STBCC__CLUSTER_SIZE_Y) // 64 for 32x32" + } + }, + { + "name": "STBCC__MAX_EXITS_PER_CLUMP", + "value": "(STBCC__CLUSTER_SIZE_X + STBCC__CLUSTER_SIZE_Y)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 203, + "column": 1, + "source_line": "#define STBCC__MAX_EXITS_PER_CLUMP (STBCC__CLUSTER_SIZE_X + STBCC__CLUSTER_SIZE_Y) // 64 for 32x32" + } + }, + { + "name": "STBCC__MAX_EDGE_CLUMPS_PER_CLUSTER", + "value": "(STBCC__MAX_EXITS_PER_CLUMP)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 204, + "column": 1, + "source_line": "#define STBCC__MAX_EDGE_CLUMPS_PER_CLUSTER (STBCC__MAX_EXITS_PER_CLUMP)" + } + }, + { + "name": "STBCC__CLUSTER_ADJACENCY_COUNT", + "value": "(STBCC__MAX_EXITS_PER_CLUSTER*2)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 252, + "column": 1, + "source_line": "#define STBCC__CLUSTER_ADJACENCY_COUNT (STBCC__MAX_EXITS_PER_CLUSTER*2)" + } + } + ], + "includes": [ + { + "target": "stdlib.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 86, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "assert.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 145, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "string.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 146, + "column": 1, + "source_line": "#include // memset" + } + } + ], + "raw_directives": [ + { + "directive": "ifndef", + "argument": "INCLUDE_STB_CONNECTED_COMPONENTS_H", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 83, + "column": 1, + "source_line": "#ifndef INCLUDE_STB_CONNECTED_COMPONENTS_H" + } + }, + { + "directive": "ifdef", + "argument": "__cplusplus", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 90, + "column": 1, + "source_line": "#ifdef __cplusplus" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 92, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "__cplusplus", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 137, + "column": 1, + "source_line": "#ifdef __cplusplus" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 139, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 141, + "column": 1, + "source_line": "#endif // INCLUDE_STB_CONNECTED_COMPONENTS_H" + } + }, + { + "directive": "ifdef", + "argument": "STB_CONNECTED_COMPONENTS_IMPLEMENTATION", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 143, + "column": 1, + "source_line": "#ifdef STB_CONNECTED_COMPONENTS_IMPLEMENTATION" + } + }, + { + "directive": "if", + "argument": "!defined(STBCC_GRID_COUNT_X_LOG2) || !defined(STBCC_GRID_COUNT_Y_LOG2)", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 148, + "column": 1, + "source_line": "#if !defined(STBCC_GRID_COUNT_X_LOG2) || !defined(STBCC_GRID_COUNT_Y_LOG2)" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 150, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBCC_CLUSTER_SIZE_X_LOG2", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 157, + "column": 1, + "source_line": "#ifndef STBCC_CLUSTER_SIZE_X_LOG2" + } + }, + { + "directive": "if", + "argument": "STBCC_CLUSTER_SIZE_X_LOG2 > 6", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 159, + "column": 4, + "source_line": " #if STBCC_CLUSTER_SIZE_X_LOG2 > 6" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 162, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 163, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBCC_CLUSTER_SIZE_Y_LOG2", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 165, + "column": 1, + "source_line": "#ifndef STBCC_CLUSTER_SIZE_Y_LOG2" + } + }, + { + "directive": "if", + "argument": "STBCC_CLUSTER_SIZE_Y_LOG2 > 6", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 167, + "column": 4, + "source_line": " #if STBCC_CLUSTER_SIZE_Y_LOG2 > 6" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 170, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 171, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "STBCC__CLUSTER_SIZE_X >= STBCC__GRID_COUNT_X || STBCC__CLUSTER_SIZE_Y >= STBCC__GRID_COUNT_Y", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 182, + "column": 1, + "source_line": "#if STBCC__CLUSTER_SIZE_X >= STBCC__GRID_COUNT_X || STBCC__CLUSTER_SIZE_Y >= STBCC__GRID_COUNT_Y" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 184, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "0", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 563, + "column": 4, + "source_line": " #if 0" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 566, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "0", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 600, + "column": 4, + "source_line": " #if 0" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 604, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 1008, + "column": 1, + "source_line": "#endif // STB_CONNECTED_COMPONENTS_IMPLEMENTATION" + } + } + ], + "macro_dependencies": [], + "diagnostics": [ + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBCC__CLUSTER_X_FOR_COORD_X' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_connected_components.h", + "line": 192, + "column": 1, + "source_line": "#define STBCC__CLUSTER_X_FOR_COORD_X(x) ((x) >> STBCC_CLUSTER_SIZE_X_LOG2)" + }, + "unit_kind": "macro", + "unit_name": "STBCC__CLUSTER_X_FOR_COORD_X" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBCC__CLUSTER_Y_FOR_COORD_Y' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_connected_components.h", + "line": 193, + "column": 1, + "source_line": "#define STBCC__CLUSTER_Y_FOR_COORD_Y(y) ((y) >> STBCC_CLUSTER_SIZE_Y_LOG2)" + }, + "unit_kind": "macro", + "unit_name": "STBCC__CLUSTER_Y_FOR_COORD_Y" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBCC__MAP_BYTE_MASK' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_connected_components.h", + "line": 195, + "column": 1, + "source_line": "#define STBCC__MAP_BYTE_MASK(x,y) (1 << ((x) & 7))" + }, + "unit_kind": "macro", + "unit_name": "STBCC__MAP_BYTE_MASK" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBCC__MAP_BYTE' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_connected_components.h", + "line": 196, + "column": 1, + "source_line": "#define STBCC__MAP_BYTE(g,x,y) ((g)->map[y][(x) >> 3])" + }, + "unit_kind": "macro", + "unit_name": "STBCC__MAP_BYTE" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBCC__MAP_OPEN' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_connected_components.h", + "line": 197, + "column": 1, + "source_line": "#define STBCC__MAP_OPEN(g,x,y) (STBCC__MAP_BYTE(g,x,y) & STBCC__MAP_BYTE_MASK(x,y))" + }, + "unit_kind": "macro", + "unit_name": "STBCC__MAP_OPEN" + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '\"C\"'.", + "severity": "warning", + "location": { + "filename": "stb/stb_connected_components.h", + "line": 91, + "column": 1, + "source_line": "extern \"C\" {" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_FIELD_DECLARATION", + "message": "Nested aggregate field definitions are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_connected_components.h", + "line": 231, + "column": 4, + "source_line": " struct {" + }, + "unit_kind": "union_field", + "unit_name": null + } + ] + } + }, + "functions": { + "stbcc_query_grid_node_connection": { + "name": "stbcc_query_grid_node_connection", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "g", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc_grid *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc_grid" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc_grid *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc_grid" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x2", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x2" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x2" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y2", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y2" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y2" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 272, + "column": 1, + "source_line": "int stbcc_query_grid_node_connection(stbcc_grid *g, int x1, int y1, int x2, int y2)" + }, + "start": { + "filename": "stb/stb_connected_components.h", + "line": 272, + "column": 1, + "source_line": "int stbcc_query_grid_node_connection(stbcc_grid *g, int x1, int y1, int x2, int y2)" + }, + "end": { + "filename": "stb/stb_connected_components.h", + "line": 289, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbcc_query_grid_open": { + "name": "stbcc_query_grid_open", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "g", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc_grid *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc_grid" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc_grid *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc_grid" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 291, + "column": 1, + "source_line": "int stbcc_query_grid_open(stbcc_grid *g, int x, int y)" + }, + "start": { + "filename": "stb/stb_connected_components.h", + "line": 291, + "column": 1, + "source_line": "int stbcc_query_grid_open(stbcc_grid *g, int x, int y)" + }, + "end": { + "filename": "stb/stb_connected_components.h", + "line": 294, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbcc_get_unique_id": { + "name": "stbcc_get_unique_id", + "result_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int" + }, + "parameters": [ + { + "name": "g", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc_grid *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc_grid" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc_grid *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc_grid" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 296, + "column": 1, + "source_line": "unsigned int stbcc_get_unique_id(stbcc_grid *g, int x, int y)" + }, + "start": { + "filename": "stb/stb_connected_components.h", + "line": 296, + "column": 1, + "source_line": "unsigned int stbcc_get_unique_id(stbcc_grid *g, int x, int y)" + }, + "end": { + "filename": "stb/stb_connected_components.h", + "line": 304, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbcc__build_clumps_for_cluster": { + "name": "stbcc__build_clumps_for_cluster", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "g", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc_grid *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc_grid" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc_grid *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc_grid" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cx", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int cx" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int cx" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cy", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int cy" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int cy" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 863, + "column": 1, + "source_line": "static void stbcc__build_clumps_for_cluster(stbcc_grid *g, int cx, int cy)" + }, + "start": { + "filename": "stb/stb_connected_components.h", + "line": 863, + "column": 1, + "source_line": "static void stbcc__build_clumps_for_cluster(stbcc_grid *g, int cx, int cy)" + }, + "end": { + "filename": "stb/stb_connected_components.h", + "line": 1006, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_connected_components.h", + "line": 317, + "column": 1, + "source_line": "static void stbcc__build_clumps_for_cluster(stbcc_grid *g, int cx, int cy);" + } + ] + }, + "stbcc__remove_connections_to_adjacent_cluster": { + "name": "stbcc__remove_connections_to_adjacent_cluster", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "g", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc_grid *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc_grid" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc_grid *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc_grid" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cx", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int cx" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int cx" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cy", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int cy" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int cy" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dx", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int dx" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int dx" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dy", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int dy" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int dy" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 775, + "column": 1, + "source_line": "static void stbcc__remove_connections_to_adjacent_cluster(stbcc_grid *g, int cx, int cy, int dx, int dy)" + }, + "start": { + "filename": "stb/stb_connected_components.h", + "line": 775, + "column": 1, + "source_line": "static void stbcc__remove_connections_to_adjacent_cluster(stbcc_grid *g, int cx, int cy, int dx, int dy)" + }, + "end": { + "filename": "stb/stb_connected_components.h", + "line": 831, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_connected_components.h", + "line": 318, + "column": 1, + "source_line": "static void stbcc__remove_connections_to_adjacent_cluster(stbcc_grid *g, int cx, int cy, int dx, int dy);" + } + ] + }, + "stbcc__add_connections_to_adjacent_cluster": { + "name": "stbcc__add_connections_to_adjacent_cluster", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "g", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc_grid *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc_grid" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc_grid *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc_grid" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cx", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int cx" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int cx" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cy", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int cy" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int cy" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dx", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int dx" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int dx" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dy", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int dy" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int dy" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 711, + "column": 1, + "source_line": "static void stbcc__add_connections_to_adjacent_cluster(stbcc_grid *g, int cx, int cy, int dx, int dy)" + }, + "start": { + "filename": "stb/stb_connected_components.h", + "line": 711, + "column": 1, + "source_line": "static void stbcc__add_connections_to_adjacent_cluster(stbcc_grid *g, int cx, int cy, int dx, int dy)" + }, + "end": { + "filename": "stb/stb_connected_components.h", + "line": 773, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_connected_components.h", + "line": 319, + "column": 1, + "source_line": "static void stbcc__add_connections_to_adjacent_cluster(stbcc_grid *g, int cx, int cy, int dx, int dy);" + } + ] + }, + "stbcc__clump_find": { + "name": "stbcc__clump_find", + "result_type": { + "reference": "stbcc__global_clumpid" + }, + "parameters": [ + { + "name": "g", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc_grid *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc_grid" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc_grid *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc_grid" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "reference": "stbcc__global_clumpid" + }, + "declared_type": { + "reference": "stbcc__global_clumpid" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 321, + "column": 1, + "source_line": "static stbcc__global_clumpid stbcc__clump_find(stbcc_grid *g, stbcc__global_clumpid n)" + }, + "start": { + "filename": "stb/stb_connected_components.h", + "line": 321, + "column": 1, + "source_line": "static stbcc__global_clumpid stbcc__clump_find(stbcc_grid *g, stbcc__global_clumpid n)" + }, + "end": { + "filename": "stb/stb_connected_components.h", + "line": 332, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbcc__clump_union": { + "name": "stbcc__clump_union", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "g", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc_grid *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc_grid" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc_grid *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc_grid" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "m", + "type": { + "reference": "stbcc__unpacked_clumpid" + }, + "declared_type": { + "reference": "stbcc__unpacked_clumpid" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "idx", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int idx" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int idx" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 341, + "column": 1, + "source_line": "static void stbcc__clump_union(stbcc_grid *g, stbcc__unpacked_clumpid m, int x, int y, int idx)" + }, + "start": { + "filename": "stb/stb_connected_components.h", + "line": 341, + "column": 1, + "source_line": "static void stbcc__clump_union(stbcc_grid *g, stbcc__unpacked_clumpid m, int x, int y, int idx)" + }, + "end": { + "filename": "stb/stb_connected_components.h", + "line": 352, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbcc__build_connected_components_for_clumps": { + "name": "stbcc__build_connected_components_for_clumps", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "g", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc_grid *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc_grid" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc_grid *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc_grid" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 354, + "column": 1, + "source_line": "static void stbcc__build_connected_components_for_clumps(stbcc_grid *g)" + }, + "start": { + "filename": "stb/stb_connected_components.h", + "line": 354, + "column": 1, + "source_line": "static void stbcc__build_connected_components_for_clumps(stbcc_grid *g)" + }, + "end": { + "filename": "stb/stb_connected_components.h", + "line": 405, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbcc__build_all_connections_for_cluster": { + "name": "stbcc__build_all_connections_for_cluster", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "g", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc_grid *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc_grid" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc_grid *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc_grid" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cx", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int cx" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int cx" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cy", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int cy" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int cy" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 407, + "column": 1, + "source_line": "static void stbcc__build_all_connections_for_cluster(stbcc_grid *g, int cx, int cy)" + }, + "start": { + "filename": "stb/stb_connected_components.h", + "line": 407, + "column": 1, + "source_line": "static void stbcc__build_all_connections_for_cluster(stbcc_grid *g, int cx, int cy)" + }, + "end": { + "filename": "stb/stb_connected_components.h", + "line": 517, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbcc__add_connections_to_adjacent_cluster_with_rebuild": { + "name": "stbcc__add_connections_to_adjacent_cluster_with_rebuild", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "g", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc_grid *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc_grid" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc_grid *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc_grid" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cx", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int cx" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int cx" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cy", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int cy" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int cy" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dx", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int dx" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int dx" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dy", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int dy" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int dy" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 519, + "column": 1, + "source_line": "static void stbcc__add_connections_to_adjacent_cluster_with_rebuild(stbcc_grid *g, int cx, int cy, int dx, int dy)" + }, + "start": { + "filename": "stb/stb_connected_components.h", + "line": 519, + "column": 1, + "source_line": "static void stbcc__add_connections_to_adjacent_cluster_with_rebuild(stbcc_grid *g, int cx, int cy, int dx, int dy)" + }, + "end": { + "filename": "stb/stb_connected_components.h", + "line": 526, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbcc_update_grid": { + "name": "stbcc_update_grid", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "g", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc_grid *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc_grid" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc_grid *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc_grid" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "solid", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int solid" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int solid" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 528, + "column": 1, + "source_line": "void stbcc_update_grid(stbcc_grid *g, int x, int y, int solid)" + }, + "start": { + "filename": "stb/stb_connected_components.h", + "line": 528, + "column": 1, + "source_line": "void stbcc_update_grid(stbcc_grid *g, int x, int y, int solid)" + }, + "end": { + "filename": "stb/stb_connected_components.h", + "line": 567, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbcc_update_batch_begin": { + "name": "stbcc_update_batch_begin", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "g", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc_grid *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc_grid" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc_grid *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc_grid" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 569, + "column": 1, + "source_line": "void stbcc_update_batch_begin(stbcc_grid *g)" + }, + "start": { + "filename": "stb/stb_connected_components.h", + "line": 569, + "column": 1, + "source_line": "void stbcc_update_batch_begin(stbcc_grid *g)" + }, + "end": { + "filename": "stb/stb_connected_components.h", + "line": 573, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbcc_update_batch_end": { + "name": "stbcc_update_batch_end", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "g", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc_grid *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc_grid" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc_grid *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc_grid" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 575, + "column": 1, + "source_line": "void stbcc_update_batch_end(stbcc_grid *g)" + }, + "start": { + "filename": "stb/stb_connected_components.h", + "line": 575, + "column": 1, + "source_line": "void stbcc_update_batch_end(stbcc_grid *g)" + }, + "end": { + "filename": "stb/stb_connected_components.h", + "line": 580, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbcc_grid_sizeof": { + "name": "stbcc_grid_sizeof", + "result_type": { + "reference": "size_t" + }, + "parameters": [], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 582, + "column": 1, + "source_line": "size_t stbcc_grid_sizeof(void)" + }, + "start": { + "filename": "stb/stb_connected_components.h", + "line": 582, + "column": 1, + "source_line": "size_t stbcc_grid_sizeof(void)" + }, + "end": { + "filename": "stb/stb_connected_components.h", + "line": 585, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbcc_init_grid": { + "name": "stbcc_init_grid", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "g", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc_grid *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc_grid" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc_grid *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc_grid" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "map", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *map", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *map", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "w", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "h", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 587, + "column": 1, + "source_line": "void stbcc_init_grid(stbcc_grid *g, unsigned char *map, int w, int h)" + }, + "start": { + "filename": "stb/stb_connected_components.h", + "line": 587, + "column": 1, + "source_line": "void stbcc_init_grid(stbcc_grid *g, unsigned char *map, int w, int h)" + }, + "end": { + "filename": "stb/stb_connected_components.h", + "line": 629, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbcc__add_clump_connection": { + "name": "stbcc__add_clump_connection", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "g", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc_grid *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc_grid" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc_grid *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc_grid" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x2", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x2" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x2" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y2", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y2" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y2" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 632, + "column": 1, + "source_line": "static void stbcc__add_clump_connection(stbcc_grid *g, int x1, int y1, int x2, int y2)" + }, + "start": { + "filename": "stb/stb_connected_components.h", + "line": 632, + "column": 1, + "source_line": "static void stbcc__add_clump_connection(stbcc_grid *g, int x1, int y1, int x2, int y2)" + }, + "end": { + "filename": "stb/stb_connected_components.h", + "line": 667, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbcc__remove_clump_connection": { + "name": "stbcc__remove_clump_connection", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "g", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc_grid *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc_grid" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc_grid *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc_grid" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x2", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x2" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x2" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y2", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y2" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y2" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 669, + "column": 1, + "source_line": "static void stbcc__remove_clump_connection(stbcc_grid *g, int x1, int y1, int x2, int y2)" + }, + "start": { + "filename": "stb/stb_connected_components.h", + "line": 669, + "column": 1, + "source_line": "static void stbcc__remove_clump_connection(stbcc_grid *g, int x1, int y1, int x2, int y2)" + }, + "end": { + "filename": "stb/stb_connected_components.h", + "line": 709, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbcc__incluster_find": { + "name": "stbcc__incluster_find", + "result_type": { + "reference": "stbcc__tinypoint" + }, + "parameters": [ + { + "name": "cbi", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc__cluster_build_info *cbi", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc__cluster_build_info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc__cluster_build_info *cbi", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc__cluster_build_info" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 833, + "column": 1, + "source_line": "static stbcc__tinypoint stbcc__incluster_find(stbcc__cluster_build_info *cbi, int x, int y)" + }, + "start": { + "filename": "stb/stb_connected_components.h", + "line": 833, + "column": 1, + "source_line": "static stbcc__tinypoint stbcc__incluster_find(stbcc__cluster_build_info *cbi, int x, int y)" + }, + "end": { + "filename": "stb/stb_connected_components.h", + "line": 842, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbcc__incluster_union": { + "name": "stbcc__incluster_union", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "cbi", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc__cluster_build_info *cbi", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc__cluster_build_info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc__cluster_build_info *cbi", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc__cluster_build_info" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x2", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x2" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x2" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y2", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y2" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y2" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 844, + "column": 1, + "source_line": "static void stbcc__incluster_union(stbcc__cluster_build_info *cbi, int x1, int y1, int x2, int y2)" + }, + "start": { + "filename": "stb/stb_connected_components.h", + "line": 844, + "column": 1, + "source_line": "static void stbcc__incluster_union(stbcc__cluster_build_info *cbi, int x1, int y1, int x2, int y2)" + }, + "end": { + "filename": "stb/stb_connected_components.h", + "line": 853, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbcc__switch_root": { + "name": "stbcc__switch_root", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "cbi", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc__cluster_build_info *cbi", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc__cluster_build_info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbcc__cluster_build_info *cbi", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbcc__cluster_build_info" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p", + "type": { + "reference": "stbcc__tinypoint" + }, + "declared_type": { + "reference": "stbcc__tinypoint" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 855, + "column": 1, + "source_line": "static void stbcc__switch_root(stbcc__cluster_build_info *cbi, int x, int y, stbcc__tinypoint p)" + }, + "start": { + "filename": "stb/stb_connected_components.h", + "line": 855, + "column": 1, + "source_line": "static void stbcc__switch_root(stbcc__cluster_build_info *cbi, int x, int y, stbcc__tinypoint p)" + }, + "end": { + "filename": "stb/stb_connected_components.h", + "line": 861, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + } + }, + "structs": { + "st_stbcc_grid": { + "reference": "struct st_stbcc_grid" + } + }, + "unions": {}, + "enums": {}, + "typedefs": { + "stbcc_grid": { + "reference": "stbcc_grid" + }, + "stbcc__clumpid": { + "reference": "stbcc__clumpid" + }, + "stbcc__verify_max_clumps": { + "reference": "stbcc__verify_max_clumps" + }, + "stbcc__verify_max_exits": { + "reference": "stbcc__verify_max_exits" + }, + "stbcc__relative_clumpid": { + "reference": "stbcc__relative_clumpid" + }, + "stbcc__global_clumpid": { + "reference": "stbcc__global_clumpid" + }, + "stbcc__clump": { + "reference": "stbcc__clump" + }, + "stbcc__cluster": { + "reference": "stbcc__cluster" + }, + "stbcc__tinypoint": { + "reference": "stbcc__tinypoint" + }, + "stbcc__cluster_build_info": { + "reference": "stbcc__cluster_build_info" + }, + "stbcc__unpacked_clumpid": { + "reference": "stbcc__unpacked_clumpid" + } + }, + "variables": {}, + "macros": { + "INCLUDE_STB_CONNECTED_COMPONENTS_H": { + "name": "INCLUDE_STB_CONNECTED_COMPONENTS_H", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 84, + "column": 1, + "source_line": "#define INCLUDE_STB_CONNECTED_COMPONENTS_H" + } + }, + "STBCC_NULL_UNIQUE_ID": { + "name": "STBCC_NULL_UNIQUE_ID", + "value": "0xffffffff", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 135, + "column": 1, + "source_line": "#define STBCC_NULL_UNIQUE_ID 0xffffffff // returned for closed map squares" + } + }, + "STBCC__GRID_COUNT_X": { + "name": "STBCC__GRID_COUNT_X", + "value": "(1 << STBCC_GRID_COUNT_X_LOG2)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 152, + "column": 1, + "source_line": "#define STBCC__GRID_COUNT_X (1 << STBCC_GRID_COUNT_X_LOG2)" + } + }, + "STBCC__GRID_COUNT_Y": { + "name": "STBCC__GRID_COUNT_Y", + "value": "(1 << STBCC_GRID_COUNT_Y_LOG2)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 153, + "column": 1, + "source_line": "#define STBCC__GRID_COUNT_Y (1 << STBCC_GRID_COUNT_Y_LOG2)" + } + }, + "STBCC__MAP_STRIDE": { + "name": "STBCC__MAP_STRIDE", + "value": "(1 << (STBCC_GRID_COUNT_X_LOG2-3))", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 155, + "column": 1, + "source_line": "#define STBCC__MAP_STRIDE (1 << (STBCC_GRID_COUNT_X_LOG2-3))" + } + }, + "STBCC_CLUSTER_SIZE_X_LOG2": { + "name": "STBCC_CLUSTER_SIZE_X_LOG2", + "value": "6", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 161, + "column": 4, + "source_line": " #define STBCC_CLUSTER_SIZE_X_LOG2 6" + } + }, + "STBCC_CLUSTER_SIZE_Y_LOG2": { + "name": "STBCC_CLUSTER_SIZE_Y_LOG2", + "value": "6", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 169, + "column": 4, + "source_line": " #define STBCC_CLUSTER_SIZE_Y_LOG2 6" + } + }, + "STBCC__CLUSTER_SIZE_X": { + "name": "STBCC__CLUSTER_SIZE_X", + "value": "(1 << STBCC_CLUSTER_SIZE_X_LOG2)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 173, + "column": 1, + "source_line": "#define STBCC__CLUSTER_SIZE_X (1 << STBCC_CLUSTER_SIZE_X_LOG2)" + } + }, + "STBCC__CLUSTER_SIZE_Y": { + "name": "STBCC__CLUSTER_SIZE_Y", + "value": "(1 << STBCC_CLUSTER_SIZE_Y_LOG2)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 174, + "column": 1, + "source_line": "#define STBCC__CLUSTER_SIZE_Y (1 << STBCC_CLUSTER_SIZE_Y_LOG2)" + } + }, + "STBCC__CLUSTER_COUNT_X_LOG2": { + "name": "STBCC__CLUSTER_COUNT_X_LOG2", + "value": "(STBCC_GRID_COUNT_X_LOG2 - STBCC_CLUSTER_SIZE_X_LOG2)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 176, + "column": 1, + "source_line": "#define STBCC__CLUSTER_COUNT_X_LOG2 (STBCC_GRID_COUNT_X_LOG2 - STBCC_CLUSTER_SIZE_X_LOG2)" + } + }, + "STBCC__CLUSTER_COUNT_Y_LOG2": { + "name": "STBCC__CLUSTER_COUNT_Y_LOG2", + "value": "(STBCC_GRID_COUNT_Y_LOG2 - STBCC_CLUSTER_SIZE_Y_LOG2)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 177, + "column": 1, + "source_line": "#define STBCC__CLUSTER_COUNT_Y_LOG2 (STBCC_GRID_COUNT_Y_LOG2 - STBCC_CLUSTER_SIZE_Y_LOG2)" + } + }, + "STBCC__CLUSTER_COUNT_X": { + "name": "STBCC__CLUSTER_COUNT_X", + "value": "(1 << STBCC__CLUSTER_COUNT_X_LOG2)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 179, + "column": 1, + "source_line": "#define STBCC__CLUSTER_COUNT_X (1 << STBCC__CLUSTER_COUNT_X_LOG2)" + } + }, + "STBCC__CLUSTER_COUNT_Y": { + "name": "STBCC__CLUSTER_COUNT_Y", + "value": "(1 << STBCC__CLUSTER_COUNT_Y_LOG2)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 180, + "column": 1, + "source_line": "#define STBCC__CLUSTER_COUNT_Y (1 << STBCC__CLUSTER_COUNT_Y_LOG2)" + } + }, + "STBCC__MAX_CLUMPS_PER_CLUSTER_LOG2": { + "name": "STBCC__MAX_CLUMPS_PER_CLUSTER_LOG2", + "value": "(STBCC_CLUSTER_SIZE_X_LOG2 + STBCC_CLUSTER_SIZE_Y_LOG2-1)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 187, + "column": 1, + "source_line": "#define STBCC__MAX_CLUMPS_PER_CLUSTER_LOG2 (STBCC_CLUSTER_SIZE_X_LOG2 + STBCC_CLUSTER_SIZE_Y_LOG2-1)" + } + }, + "STBCC__MAX_CLUMPS_PER_CLUSTER": { + "name": "STBCC__MAX_CLUMPS_PER_CLUSTER", + "value": "(1 << STBCC__MAX_CLUMPS_PER_CLUSTER_LOG2)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 188, + "column": 1, + "source_line": "#define STBCC__MAX_CLUMPS_PER_CLUSTER (1 << STBCC__MAX_CLUMPS_PER_CLUSTER_LOG2)" + } + }, + "STBCC__MAX_CLUMPS": { + "name": "STBCC__MAX_CLUMPS", + "value": "(STBCC__MAX_CLUMPS_PER_CLUSTER * STBCC__CLUSTER_COUNT_X * STBCC__CLUSTER_COUNT_Y)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 189, + "column": 1, + "source_line": "#define STBCC__MAX_CLUMPS (STBCC__MAX_CLUMPS_PER_CLUSTER * STBCC__CLUSTER_COUNT_X * STBCC__CLUSTER_COUNT_Y)" + } + }, + "STBCC__NULL_CLUMPID": { + "name": "STBCC__NULL_CLUMPID", + "value": "STBCC__MAX_CLUMPS_PER_CLUSTER", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 190, + "column": 1, + "source_line": "#define STBCC__NULL_CLUMPID STBCC__MAX_CLUMPS_PER_CLUSTER" + } + }, + "STBCC__CLUSTER_X_FOR_COORD_X": { + "name": "STBCC__CLUSTER_X_FOR_COORD_X", + "value": "((x) >> STBCC_CLUSTER_SIZE_X_LOG2)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 192, + "column": 1, + "source_line": "#define STBCC__CLUSTER_X_FOR_COORD_X(x) ((x) >> STBCC_CLUSTER_SIZE_X_LOG2)" + } + }, + "STBCC__CLUSTER_Y_FOR_COORD_Y": { + "name": "STBCC__CLUSTER_Y_FOR_COORD_Y", + "value": "((y) >> STBCC_CLUSTER_SIZE_Y_LOG2)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 193, + "column": 1, + "source_line": "#define STBCC__CLUSTER_Y_FOR_COORD_Y(y) ((y) >> STBCC_CLUSTER_SIZE_Y_LOG2)" + } + }, + "STBCC__MAP_BYTE_MASK": { + "name": "STBCC__MAP_BYTE_MASK", + "value": "(1 << ((x) & 7))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 195, + "column": 1, + "source_line": "#define STBCC__MAP_BYTE_MASK(x,y) (1 << ((x) & 7))" + } + }, + "STBCC__MAP_BYTE": { + "name": "STBCC__MAP_BYTE", + "value": "((g)->map[y][(x) >> 3])", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 196, + "column": 1, + "source_line": "#define STBCC__MAP_BYTE(g,x,y) ((g)->map[y][(x) >> 3])" + } + }, + "STBCC__MAP_OPEN": { + "name": "STBCC__MAP_OPEN", + "value": "(STBCC__MAP_BYTE(g,x,y) & STBCC__MAP_BYTE_MASK(x,y))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 197, + "column": 1, + "source_line": "#define STBCC__MAP_OPEN(g,x,y) (STBCC__MAP_BYTE(g,x,y) & STBCC__MAP_BYTE_MASK(x,y))" + } + }, + "STBCC__MAX_EXITS_PER_CLUSTER": { + "name": "STBCC__MAX_EXITS_PER_CLUSTER", + "value": "(STBCC__CLUSTER_SIZE_X + STBCC__CLUSTER_SIZE_Y)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 202, + "column": 1, + "source_line": "#define STBCC__MAX_EXITS_PER_CLUSTER (STBCC__CLUSTER_SIZE_X + STBCC__CLUSTER_SIZE_Y) // 64 for 32x32" + } + }, + "STBCC__MAX_EXITS_PER_CLUMP": { + "name": "STBCC__MAX_EXITS_PER_CLUMP", + "value": "(STBCC__CLUSTER_SIZE_X + STBCC__CLUSTER_SIZE_Y)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 203, + "column": 1, + "source_line": "#define STBCC__MAX_EXITS_PER_CLUMP (STBCC__CLUSTER_SIZE_X + STBCC__CLUSTER_SIZE_Y) // 64 for 32x32" + } + }, + "STBCC__MAX_EDGE_CLUMPS_PER_CLUSTER": { + "name": "STBCC__MAX_EDGE_CLUMPS_PER_CLUSTER", + "value": "(STBCC__MAX_EXITS_PER_CLUMP)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 204, + "column": 1, + "source_line": "#define STBCC__MAX_EDGE_CLUMPS_PER_CLUSTER (STBCC__MAX_EXITS_PER_CLUMP)" + } + }, + "STBCC__CLUSTER_ADJACENCY_COUNT": { + "name": "STBCC__CLUSTER_ADJACENCY_COUNT", + "value": "(STBCC__MAX_EXITS_PER_CLUSTER*2)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 252, + "column": 1, + "source_line": "#define STBCC__CLUSTER_ADJACENCY_COUNT (STBCC__MAX_EXITS_PER_CLUSTER*2)" + } + } + }, + "includes": { + "stb/stb_connected_components.h:stdlib.h": { + "target": "stdlib.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 86, + "column": 1, + "source_line": "#include " + } + }, + "stb/stb_connected_components.h:assert.h": { + "target": "assert.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 145, + "column": 1, + "source_line": "#include " + } + }, + "stb/stb_connected_components.h:string.h": { + "target": "string.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_connected_components.h", + "line": 146, + "column": 1, + "source_line": "#include // memset" + } + } + }, + "functions_by_file": { + "stb/stb_connected_components.h": [ + "stbcc_query_grid_node_connection", + "stbcc_query_grid_open", + "stbcc_get_unique_id", + "stbcc__build_clumps_for_cluster", + "stbcc__remove_connections_to_adjacent_cluster", + "stbcc__add_connections_to_adjacent_cluster", + "stbcc__clump_find", + "stbcc__clump_union", + "stbcc__build_connected_components_for_clumps", + "stbcc__build_all_connections_for_cluster", + "stbcc__add_connections_to_adjacent_cluster_with_rebuild", + "stbcc_update_grid", + "stbcc_update_batch_begin", + "stbcc_update_batch_end", + "stbcc_grid_sizeof", + "stbcc_init_grid", + "stbcc__add_clump_connection", + "stbcc__remove_clump_connection", + "stbcc__incluster_find", + "stbcc__incluster_union", + "stbcc__switch_root" + ] + }, + "enum_constants": {}, + "include_graph": { + "stb/stb_connected_components.h": [] + }, + "system_includes": { + "stb/stb_connected_components.h": [ + "assert.h", + "stdlib.h", + "string.h" + ] + }, + "unresolved_includes": { + "stb/stb_connected_components.h": [] + }, + "header_source_pairs": { + "stb/stb_connected_components.h": [] + }, + "diagnostics": [ + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBCC__CLUSTER_X_FOR_COORD_X' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_connected_components.h", + "line": 192, + "column": 1, + "source_line": "#define STBCC__CLUSTER_X_FOR_COORD_X(x) ((x) >> STBCC_CLUSTER_SIZE_X_LOG2)" + }, + "unit_kind": "macro", + "unit_name": "STBCC__CLUSTER_X_FOR_COORD_X" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBCC__CLUSTER_Y_FOR_COORD_Y' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_connected_components.h", + "line": 193, + "column": 1, + "source_line": "#define STBCC__CLUSTER_Y_FOR_COORD_Y(y) ((y) >> STBCC_CLUSTER_SIZE_Y_LOG2)" + }, + "unit_kind": "macro", + "unit_name": "STBCC__CLUSTER_Y_FOR_COORD_Y" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBCC__MAP_BYTE_MASK' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_connected_components.h", + "line": 195, + "column": 1, + "source_line": "#define STBCC__MAP_BYTE_MASK(x,y) (1 << ((x) & 7))" + }, + "unit_kind": "macro", + "unit_name": "STBCC__MAP_BYTE_MASK" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBCC__MAP_BYTE' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_connected_components.h", + "line": 196, + "column": 1, + "source_line": "#define STBCC__MAP_BYTE(g,x,y) ((g)->map[y][(x) >> 3])" + }, + "unit_kind": "macro", + "unit_name": "STBCC__MAP_BYTE" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBCC__MAP_OPEN' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_connected_components.h", + "line": 197, + "column": 1, + "source_line": "#define STBCC__MAP_OPEN(g,x,y) (STBCC__MAP_BYTE(g,x,y) & STBCC__MAP_BYTE_MASK(x,y))" + }, + "unit_kind": "macro", + "unit_name": "STBCC__MAP_OPEN" + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '\"C\"'.", + "severity": "warning", + "location": { + "filename": "stb/stb_connected_components.h", + "line": 91, + "column": 1, + "source_line": "extern \"C\" {" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_FIELD_DECLARATION", + "message": "Nested aggregate field definitions are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_connected_components.h", + "line": 231, + "column": 4, + "source_line": " struct {" + }, + "unit_kind": "union_field", + "unit_name": null + } + ] +} diff --git a/tests/parser/c/fixtures/stb/stb_divide.json b/tests/parser/c/fixtures/stb/stb_divide.json new file mode 100644 index 000000000..a44622834 --- /dev/null +++ b/tests/parser/c/fixtures/stb/stb_divide.json @@ -0,0 +1,2400 @@ +{ + "files": { + "stb/stb_divide.h": { + "filename": "stb/stb_divide.h", + "language": "c", + "parser_status": "partial", + "preprocessing": "raw", + "functions": [ + { + "name": "stb_div_trunc", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "v1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "v2", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v2" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v2" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_divide.h", + "line": 147, + "column": 1, + "source_line": "int stb_div_trunc(int v1, int v2)" + }, + "start": { + "filename": "stb/stb_divide.h", + "line": 147, + "column": 1, + "source_line": "int stb_div_trunc(int v1, int v2)" + }, + "end": { + "filename": "stb/stb_divide.h", + "line": 162, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_div_floor", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "v1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "v2", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v2" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v2" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_divide.h", + "line": 164, + "column": 1, + "source_line": "int stb_div_floor(int v1, int v2)" + }, + "start": { + "filename": "stb/stb_divide.h", + "line": 164, + "column": 1, + "source_line": "int stb_div_floor(int v1, int v2)" + }, + "end": { + "filename": "stb/stb_divide.h", + "line": 186, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_div_eucl", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "v1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "v2", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v2" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v2" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_divide.h", + "line": 188, + "column": 1, + "source_line": "int stb_div_eucl(int v1, int v2)" + }, + "start": { + "filename": "stb/stb_divide.h", + "line": 188, + "column": 1, + "source_line": "int stb_div_eucl(int v1, int v2)" + }, + "end": { + "filename": "stb/stb_divide.h", + "line": 222, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_mod_trunc", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "v1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "v2", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v2" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v2" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_divide.h", + "line": 224, + "column": 1, + "source_line": "int stb_mod_trunc(int v1, int v2)" + }, + "start": { + "filename": "stb/stb_divide.h", + "line": 224, + "column": 1, + "source_line": "int stb_mod_trunc(int v1, int v2)" + }, + "end": { + "filename": "stb/stb_divide.h", + "line": 243, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_mod_floor", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "v1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "v2", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v2" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v2" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_divide.h", + "line": 245, + "column": 1, + "source_line": "int stb_mod_floor(int v1, int v2)" + }, + "start": { + "filename": "stb/stb_divide.h", + "line": 245, + "column": 1, + "source_line": "int stb_mod_floor(int v1, int v2)" + }, + "end": { + "filename": "stb/stb_divide.h", + "line": 264, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_mod_eucl", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "v1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "v2", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v2" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v2" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_divide.h", + "line": 266, + "column": 1, + "source_line": "int stb_mod_eucl(int v1, int v2)" + }, + "start": { + "filename": "stb/stb_divide.h", + "line": 266, + "column": 1, + "source_line": "int stb_mod_eucl(int v1, int v2)" + }, + "end": { + "filename": "stb/stb_divide.h", + "line": 274, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbdiv_check", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "q", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int q" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int q" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "r", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int r" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int r" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "a", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "type", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *type", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *type", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dir", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int dir" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int dir" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_divide.h", + "line": 284, + "column": 1, + "source_line": "void stbdiv_check(int q, int r, int a, int b, char *type, int dir)" + }, + "start": { + "filename": "stb/stb_divide.h", + "line": 284, + "column": 1, + "source_line": "void stbdiv_check(int q, int r, int a, int b, char *type, int dir)" + }, + "end": { + "filename": "stb/stb_divide.h", + "line": 309, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "test", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_divide.h", + "line": 311, + "column": 1, + "source_line": "void test(int a, int b)" + }, + "start": { + "filename": "stb/stb_divide.h", + "line": 311, + "column": 1, + "source_line": "void test(int a, int b)" + }, + "end": { + "filename": "stb/stb_divide.h", + "line": 321, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "testh", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_divide.h", + "line": 323, + "column": 1, + "source_line": "void testh(int a, int b)" + }, + "start": { + "filename": "stb/stb_divide.h", + "line": 323, + "column": 1, + "source_line": "void testh(int a, int b)" + }, + "end": { + "filename": "stb/stb_divide.h", + "line": 333, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "main", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "argc", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int argc" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int argc" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "argv", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char **argv", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char **argv", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_divide.h", + "line": 335, + "column": 1, + "source_line": "int main(int argc, char **argv)" + }, + "start": { + "filename": "stb/stb_divide.h", + "line": 335, + "column": 1, + "source_line": "int main(int argc, char **argv)" + }, + "end": { + "filename": "stb/stb_divide.h", + "line": 388, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + } + ], + "structs": [], + "unions": [], + "enums": [], + "typedefs": [], + "variables": [ + { + "name": "show", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int show" + }, + "storage": [], + "initializer": { + "source_text": "0" + }, + "bit_width": null, + "source_location": { + "filename": "stb/stb_divide.h", + "line": 281, + "column": 1, + "source_line": "int show=0;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "err", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int err" + }, + "storage": [], + "initializer": { + "source_text": "0" + }, + "bit_width": null, + "source_location": { + "filename": "stb/stb_divide.h", + "line": 282, + "column": 1, + "source_line": "int err=0;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "macros": [ + { + "name": "INCLUDE_STB_DIVIDE_H", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_divide.h", + "line": 88, + "column": 1, + "source_line": "#define INCLUDE_STB_DIVIDE_H" + } + }, + { + "name": "C_INTEGER_DIVISION_TRUNCATES", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_divide.h", + "line": 109, + "column": 7, + "source_line": " #define C_INTEGER_DIVISION_TRUNCATES" + } + }, + { + "name": "stb__div", + "value": "((a)/(b))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_divide.h", + "line": 120, + "column": 4, + "source_line": " #define stb__div(a,b) ((a)/(b))" + } + }, + { + "name": "stb__mod", + "value": "((a)%(b))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_divide.h", + "line": 121, + "column": 4, + "source_line": " #define stb__mod(a,b) ((a)%(b))" + } + }, + { + "name": "C_INTEGER_DIVISION_TRUNCATES", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_divide.h", + "line": 127, + "column": 4, + "source_line": " #undef C_INTEGER_DIVISION_TRUNCATES" + } + } + ], + "includes": [ + { + "target": "limits.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_divide.h", + "line": 114, + "column": 1, + "source_line": "#include // if you have no limits.h, #define INT_MIN yourself" + } + }, + { + "target": "stdio.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_divide.h", + "line": 277, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "math.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_divide.h", + "line": 278, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "limits.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_divide.h", + "line": 279, + "column": 1, + "source_line": "#include " + } + } + ], + "raw_directives": [ + { + "directive": "ifndef", + "argument": "INCLUDE_STB_DIVIDE_H", + "source_location": { + "filename": "stb/stb_divide.h", + "line": 87, + "column": 1, + "source_line": "#ifndef INCLUDE_STB_DIVIDE_H" + } + }, + { + "directive": "ifdef", + "argument": "__cplusplus", + "source_location": { + "filename": "stb/stb_divide.h", + "line": 90, + "column": 1, + "source_line": "#ifdef __cplusplus" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_divide.h", + "line": 92, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "__cplusplus", + "source_location": { + "filename": "stb/stb_divide.h", + "line": 101, + "column": 1, + "source_line": "#ifdef __cplusplus" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_divide.h", + "line": 103, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STB_DIVIDE_IMPLEMENTATION", + "source_location": { + "filename": "stb/stb_divide.h", + "line": 105, + "column": 1, + "source_line": "#ifdef STB_DIVIDE_IMPLEMENTATION" + } + }, + { + "directive": "if", + "argument": "defined(__STDC_VERSION) && __STDC_VERSION__ >= 19901", + "source_location": { + "filename": "stb/stb_divide.h", + "line": 107, + "column": 1, + "source_line": "#if defined(__STDC_VERSION) && __STDC_VERSION__ >= 19901" + } + }, + { + "directive": "ifndef", + "argument": "C_INTEGER_DIVISION_TRUNCATES", + "source_location": { + "filename": "stb/stb_divide.h", + "line": 108, + "column": 4, + "source_line": " #ifndef C_INTEGER_DIVISION_TRUNCATES" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_divide.h", + "line": 110, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_divide.h", + "line": 111, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "INT_MIN", + "source_location": { + "filename": "stb/stb_divide.h", + "line": 113, + "column": 1, + "source_line": "#ifndef INT_MIN" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_divide.h", + "line": 115, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_DIVIDE_TEST_FLOOR", + "source_location": { + "filename": "stb/stb_divide.h", + "line": 119, + "column": 1, + "source_line": "#ifndef STB_DIVIDE_TEST_FLOOR" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_divide.h", + "line": 122, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "ifndef", + "argument": "C_INTEGER_DIVISION_TRUNCATES", + "source_location": { + "filename": "stb/stb_divide.h", + "line": 124, + "column": 4, + "source_line": " #ifndef C_INTEGER_DIVISION_TRUNCATES" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_divide.h", + "line": 126, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_divide.h", + "line": 145, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "C_INTEGER_DIVISION_TRUNCATES", + "source_location": { + "filename": "stb/stb_divide.h", + "line": 149, + "column": 4, + "source_line": " #ifdef C_INTEGER_DIVISION_TRUNCATES" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_divide.h", + "line": 151, + "column": 4, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_divide.h", + "line": 161, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "C_INTEGER_DIVISION_FLOORS", + "source_location": { + "filename": "stb/stb_divide.h", + "line": 166, + "column": 4, + "source_line": " #ifdef C_INTEGER_DIVISION_FLOORS" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_divide.h", + "line": 168, + "column": 4, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_divide.h", + "line": 185, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "C_INTEGER_DIVISION_TRUNCATES", + "source_location": { + "filename": "stb/stb_divide.h", + "line": 191, + "column": 4, + "source_line": " #ifdef C_INTEGER_DIVISION_TRUNCATES" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_divide.h", + "line": 194, + "column": 4, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_divide.h", + "line": 217, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "C_INTEGER_DIVISION_TRUNCATES", + "source_location": { + "filename": "stb/stb_divide.h", + "line": 226, + "column": 4, + "source_line": " #ifdef C_INTEGER_DIVISION_TRUNCATES" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_divide.h", + "line": 228, + "column": 4, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_divide.h", + "line": 242, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "C_INTEGER_DIVISION_FLOORS", + "source_location": { + "filename": "stb/stb_divide.h", + "line": 247, + "column": 4, + "source_line": " #ifdef C_INTEGER_DIVISION_FLOORS" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_divide.h", + "line": 249, + "column": 4, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_divide.h", + "line": 263, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "STB_DIVIDE_TEST", + "source_location": { + "filename": "stb/stb_divide.h", + "line": 276, + "column": 1, + "source_line": "#ifdef STB_DIVIDE_TEST" + } + }, + { + "directive": "ifdef", + "argument": "STB_DIVIDE_TEST_64", + "source_location": { + "filename": "stb/stb_divide.h", + "line": 295, + "column": 4, + "source_line": " #ifdef STB_DIVIDE_TEST_64" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_divide.h", + "line": 303, + "column": 4, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_divide.h", + "line": 308, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_divide.h", + "line": 389, + "column": 1, + "source_line": "#endif // STB_DIVIDE_TEST" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_divide.h", + "line": 390, + "column": 1, + "source_line": "#endif // STB_DIVIDE_IMPLEMENTATION" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_divide.h", + "line": 391, + "column": 1, + "source_line": "#endif // INCLUDE_STB_DIVIDE_H" + } + } + ], + "macro_dependencies": [ + { + "name": "stb__div", + "context": "declaration", + "source_location": { + "filename": "stb/stb_divide.h", + "line": 128, + "column": 4, + "source_line": " int stb__div(int v1, int v2)" + }, + "source_text": "int stb__div(int v1, int v2)" + }, + { + "name": "stb__mod", + "context": "declaration", + "source_location": { + "filename": "stb/stb_divide.h", + "line": 137, + "column": 4, + "source_line": " int stb__mod(int v1, int v2)" + }, + "source_text": "int stb__mod(int v1, int v2)" + } + ], + "diagnostics": [ + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stb__div' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_divide.h", + "line": 120, + "column": 4, + "source_line": " #define stb__div(a,b) ((a)/(b))" + }, + "unit_kind": "macro", + "unit_name": "stb__div" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stb__mod' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_divide.h", + "line": 121, + "column": 4, + "source_line": " #define stb__mod(a,b) ((a)%(b))" + }, + "unit_kind": "macro", + "unit_name": "stb__mod" + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '\"C\"'.", + "severity": "warning", + "location": { + "filename": "stb/stb_divide.h", + "line": 91, + "column": 1, + "source_line": "extern \"C\" {" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'stb__div'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_divide.h", + "line": 128, + "column": 4, + "source_line": " int stb__div(int v1, int v2)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stb__div" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'stb__mod'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_divide.h", + "line": 137, + "column": 4, + "source_line": " int stb__mod(int v1, int v2)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stb__mod" + } + ] + } + }, + "functions": { + "stb_div_trunc": { + "name": "stb_div_trunc", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "v1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "v2", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v2" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v2" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_divide.h", + "line": 147, + "column": 1, + "source_line": "int stb_div_trunc(int v1, int v2)" + }, + "start": { + "filename": "stb/stb_divide.h", + "line": 147, + "column": 1, + "source_line": "int stb_div_trunc(int v1, int v2)" + }, + "end": { + "filename": "stb/stb_divide.h", + "line": 162, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_div_floor": { + "name": "stb_div_floor", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "v1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "v2", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v2" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v2" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_divide.h", + "line": 164, + "column": 1, + "source_line": "int stb_div_floor(int v1, int v2)" + }, + "start": { + "filename": "stb/stb_divide.h", + "line": 164, + "column": 1, + "source_line": "int stb_div_floor(int v1, int v2)" + }, + "end": { + "filename": "stb/stb_divide.h", + "line": 186, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_div_eucl": { + "name": "stb_div_eucl", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "v1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "v2", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v2" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v2" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_divide.h", + "line": 188, + "column": 1, + "source_line": "int stb_div_eucl(int v1, int v2)" + }, + "start": { + "filename": "stb/stb_divide.h", + "line": 188, + "column": 1, + "source_line": "int stb_div_eucl(int v1, int v2)" + }, + "end": { + "filename": "stb/stb_divide.h", + "line": 222, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_mod_trunc": { + "name": "stb_mod_trunc", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "v1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "v2", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v2" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v2" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_divide.h", + "line": 224, + "column": 1, + "source_line": "int stb_mod_trunc(int v1, int v2)" + }, + "start": { + "filename": "stb/stb_divide.h", + "line": 224, + "column": 1, + "source_line": "int stb_mod_trunc(int v1, int v2)" + }, + "end": { + "filename": "stb/stb_divide.h", + "line": 243, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_mod_floor": { + "name": "stb_mod_floor", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "v1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "v2", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v2" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v2" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_divide.h", + "line": 245, + "column": 1, + "source_line": "int stb_mod_floor(int v1, int v2)" + }, + "start": { + "filename": "stb/stb_divide.h", + "line": 245, + "column": 1, + "source_line": "int stb_mod_floor(int v1, int v2)" + }, + "end": { + "filename": "stb/stb_divide.h", + "line": 264, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_mod_eucl": { + "name": "stb_mod_eucl", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "v1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "v2", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v2" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v2" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_divide.h", + "line": 266, + "column": 1, + "source_line": "int stb_mod_eucl(int v1, int v2)" + }, + "start": { + "filename": "stb/stb_divide.h", + "line": 266, + "column": 1, + "source_line": "int stb_mod_eucl(int v1, int v2)" + }, + "end": { + "filename": "stb/stb_divide.h", + "line": 274, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbdiv_check": { + "name": "stbdiv_check", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "q", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int q" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int q" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "r", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int r" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int r" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "a", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "type", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *type", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *type", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dir", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int dir" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int dir" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_divide.h", + "line": 284, + "column": 1, + "source_line": "void stbdiv_check(int q, int r, int a, int b, char *type, int dir)" + }, + "start": { + "filename": "stb/stb_divide.h", + "line": 284, + "column": 1, + "source_line": "void stbdiv_check(int q, int r, int a, int b, char *type, int dir)" + }, + "end": { + "filename": "stb/stb_divide.h", + "line": 309, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "test": { + "name": "test", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_divide.h", + "line": 311, + "column": 1, + "source_line": "void test(int a, int b)" + }, + "start": { + "filename": "stb/stb_divide.h", + "line": 311, + "column": 1, + "source_line": "void test(int a, int b)" + }, + "end": { + "filename": "stb/stb_divide.h", + "line": 321, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "testh": { + "name": "testh", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_divide.h", + "line": 323, + "column": 1, + "source_line": "void testh(int a, int b)" + }, + "start": { + "filename": "stb/stb_divide.h", + "line": 323, + "column": 1, + "source_line": "void testh(int a, int b)" + }, + "end": { + "filename": "stb/stb_divide.h", + "line": 333, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "main": { + "name": "main", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "argc", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int argc" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int argc" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "argv", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char **argv", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char **argv", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_divide.h", + "line": 335, + "column": 1, + "source_line": "int main(int argc, char **argv)" + }, + "start": { + "filename": "stb/stb_divide.h", + "line": 335, + "column": 1, + "source_line": "int main(int argc, char **argv)" + }, + "end": { + "filename": "stb/stb_divide.h", + "line": 388, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + } + }, + "structs": {}, + "unions": {}, + "enums": {}, + "typedefs": {}, + "variables": { + "show": { + "name": "show", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int show" + }, + "storage": [], + "initializer": { + "source_text": "0" + }, + "bit_width": null, + "source_location": { + "filename": "stb/stb_divide.h", + "line": 281, + "column": 1, + "source_line": "int show=0;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + "err": { + "name": "err", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int err" + }, + "storage": [], + "initializer": { + "source_text": "0" + }, + "bit_width": null, + "source_location": { + "filename": "stb/stb_divide.h", + "line": 282, + "column": 1, + "source_line": "int err=0;" + }, + "callback_policy": null, + "declaration_locations": [] + } + }, + "macros": { + "INCLUDE_STB_DIVIDE_H": { + "name": "INCLUDE_STB_DIVIDE_H", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_divide.h", + "line": 88, + "column": 1, + "source_line": "#define INCLUDE_STB_DIVIDE_H" + } + }, + "C_INTEGER_DIVISION_TRUNCATES": { + "name": "C_INTEGER_DIVISION_TRUNCATES", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_divide.h", + "line": 127, + "column": 4, + "source_line": " #undef C_INTEGER_DIVISION_TRUNCATES" + } + }, + "stb__div": { + "name": "stb__div", + "value": "((a)/(b))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_divide.h", + "line": 120, + "column": 4, + "source_line": " #define stb__div(a,b) ((a)/(b))" + } + }, + "stb__mod": { + "name": "stb__mod", + "value": "((a)%(b))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_divide.h", + "line": 121, + "column": 4, + "source_line": " #define stb__mod(a,b) ((a)%(b))" + } + } + }, + "includes": { + "stb/stb_divide.h:limits.h": { + "target": "limits.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_divide.h", + "line": 279, + "column": 1, + "source_line": "#include " + } + }, + "stb/stb_divide.h:stdio.h": { + "target": "stdio.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_divide.h", + "line": 277, + "column": 1, + "source_line": "#include " + } + }, + "stb/stb_divide.h:math.h": { + "target": "math.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_divide.h", + "line": 278, + "column": 1, + "source_line": "#include " + } + } + }, + "functions_by_file": { + "stb/stb_divide.h": [ + "stb_div_trunc", + "stb_div_floor", + "stb_div_eucl", + "stb_mod_trunc", + "stb_mod_floor", + "stb_mod_eucl", + "stbdiv_check", + "test", + "testh", + "main" + ] + }, + "enum_constants": {}, + "include_graph": { + "stb/stb_divide.h": [] + }, + "system_includes": { + "stb/stb_divide.h": [ + "limits.h", + "math.h", + "stdio.h" + ] + }, + "unresolved_includes": { + "stb/stb_divide.h": [] + }, + "header_source_pairs": { + "stb/stb_divide.h": [] + }, + "diagnostics": [ + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stb__div' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_divide.h", + "line": 120, + "column": 4, + "source_line": " #define stb__div(a,b) ((a)/(b))" + }, + "unit_kind": "macro", + "unit_name": "stb__div" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stb__mod' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_divide.h", + "line": 121, + "column": 4, + "source_line": " #define stb__mod(a,b) ((a)%(b))" + }, + "unit_kind": "macro", + "unit_name": "stb__mod" + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '\"C\"'.", + "severity": "warning", + "location": { + "filename": "stb/stb_divide.h", + "line": 91, + "column": 1, + "source_line": "extern \"C\" {" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'stb__div'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_divide.h", + "line": 128, + "column": 4, + "source_line": " int stb__div(int v1, int v2)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stb__div" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'stb__mod'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_divide.h", + "line": 137, + "column": 4, + "source_line": " int stb__mod(int v1, int v2)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stb__mod" + } + ] +} diff --git a/tests/parser/c/fixtures/stb/stb_ds.json b/tests/parser/c/fixtures/stb/stb_ds.json new file mode 100644 index 000000000..65c97b266 --- /dev/null +++ b/tests/parser/c/fixtures/stb/stb_ds.json @@ -0,0 +1,13708 @@ +{ + "files": { + "stb/stb_ds.h": { + "filename": "stb/stb_ds.h", + "language": "c", + "parser_status": "partial", + "preprocessing": "raw", + "functions": [ + { + "name": "stbds_arrgrowf", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "elemsize", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t elemsize", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "addlen", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t addlen", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "min_cap", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t min_cap", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 762, + "column": 1, + "source_line": "void *stbds_arrgrowf(void *a, size_t elemsize, size_t addlen, size_t min_cap)" + }, + "start": { + "filename": "stb/stb_ds.h", + "line": 762, + "column": 1, + "source_line": "void *stbds_arrgrowf(void *a, size_t elemsize, size_t addlen, size_t min_cap)" + }, + "end": { + "filename": "stb/stb_ds.h", + "line": 798, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbds_arrfreef", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 800, + "column": 1, + "source_line": "void stbds_arrfreef(void *a)" + }, + "start": { + "filename": "stb/stb_ds.h", + "line": 800, + "column": 1, + "source_line": "void stbds_arrfreef(void *a)" + }, + "end": { + "filename": "stb/stb_ds.h", + "line": 803, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbds_rand_seed", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "seed", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t seed", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 851, + "column": 1, + "source_line": "void stbds_rand_seed(size_t seed)" + }, + "start": { + "filename": "stb/stb_ds.h", + "line": 851, + "column": 1, + "source_line": "void stbds_rand_seed(size_t seed)" + }, + "end": { + "filename": "stb/stb_ds.h", + "line": 854, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbds_probe_position", + "result_type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "parameters": [ + { + "name": "hash", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t hash", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "slot_count", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t slot_count", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "slot_log2", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t slot_log2", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 863, + "column": 1, + "source_line": "static size_t stbds_probe_position(size_t hash, size_t slot_count, size_t slot_log2)" + }, + "start": { + "filename": "stb/stb_ds.h", + "line": 863, + "column": 1, + "source_line": "static size_t stbds_probe_position(size_t hash, size_t slot_count, size_t slot_log2)" + }, + "end": { + "filename": "stb/stb_ds.h", + "line": 872, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbds_log2", + "result_type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "parameters": [ + { + "name": "slot_count", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t slot_count", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 874, + "column": 1, + "source_line": "static size_t stbds_log2(size_t slot_count)" + }, + "start": { + "filename": "stb/stb_ds.h", + "line": 874, + "column": 1, + "source_line": "static size_t stbds_log2(size_t slot_count)" + }, + "end": { + "filename": "stb/stb_ds.h", + "line": 882, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbds_make_hash_index", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbds_hash_index", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbds_hash_index", + "name": "stbds_hash_index", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "temp_key", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char * temp_key", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 829, + "column": 3, + "source_line": " char * temp_key; // this MUST be the first field of the hash table" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "slot_count", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t slot_count", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 830, + "column": 3, + "source_line": " size_t slot_count;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "used_count", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t used_count", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 831, + "column": 3, + "source_line": " size_t used_count;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "used_count_threshold", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t used_count_threshold", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 832, + "column": 3, + "source_line": " size_t used_count_threshold;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "used_count_shrink_threshold", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t used_count_shrink_threshold", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 833, + "column": 3, + "source_line": " size_t used_count_shrink_threshold;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "tombstone_count", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t tombstone_count", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 834, + "column": 3, + "source_line": " size_t tombstone_count;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "tombstone_count_threshold", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t tombstone_count_threshold", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 835, + "column": 3, + "source_line": " size_t tombstone_count_threshold;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "seed", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t seed", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 836, + "column": 3, + "source_line": " size_t seed;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "slot_count_log2", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t slot_count_log2", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 837, + "column": 3, + "source_line": " size_t slot_count_log2;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "string", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbds_string_arena string", + "name": "stbds_string_arena", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 838, + "column": 3, + "source_line": " stbds_string_arena string;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "storage", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbds_hash_bucket *storage", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbds_hash_bucket", + "name": "stbds_hash_bucket", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "hash", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "size_t hash [STBDS_BUCKET_LENGTH]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STBDS_BUCKET_LENGTH", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 823, + "column": 4, + "source_line": " size_t hash [STBDS_BUCKET_LENGTH];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "index", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "ptrdiff_t index[STBDS_BUCKET_LENGTH]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STBDS_BUCKET_LENGTH", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "ptrdiff_t", + "name": "ptrdiff_t", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 824, + "column": 4, + "source_line": " ptrdiff_t index[STBDS_BUCKET_LENGTH];" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_ds.h:821:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 821, + "column": 1, + "source_line": "typedef struct" + } + }, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 821, + "column": 1, + "source_line": "typedef struct" + }, + "declaration_locations": [] + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 839, + "column": 3, + "source_line": " stbds_hash_bucket *storage; // not a separate allocation, just 64-byte aligned storage after this struct" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_ds.h:827:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 827, + "column": 1, + "source_line": "typedef struct" + } + }, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 827, + "column": 1, + "source_line": "typedef struct" + }, + "declaration_locations": [] + } + ] + }, + "parameters": [ + { + "name": "slot_count", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t slot_count", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ot", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbds_hash_index *ot", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbds_hash_index" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbds_hash_index *ot", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbds_hash_index" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 884, + "column": 1, + "source_line": "static stbds_hash_index *stbds_make_hash_index(size_t slot_count, stbds_hash_index *ot)" + }, + "start": { + "filename": "stb/stb_ds.h", + "line": 884, + "column": 1, + "source_line": "static stbds_hash_index *stbds_make_hash_index(size_t slot_count, stbds_hash_index *ot)" + }, + "end": { + "filename": "stb/stb_ds.h", + "line": 1011, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbds_hash_string", + "result_type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "seed", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t seed", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1016, + "column": 1, + "source_line": "size_t stbds_hash_string(char *str, size_t seed)" + }, + "start": { + "filename": "stb/stb_ds.h", + "line": 1016, + "column": 1, + "source_line": "size_t stbds_hash_string(char *str, size_t seed)" + }, + "end": { + "filename": "stb/stb_ds.h", + "line": 1031, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbds_siphash_bytes", + "result_type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t len", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "seed", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t seed", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1051, + "column": 1, + "source_line": "static size_t stbds_siphash_bytes(void *p, size_t len, size_t seed)" + }, + "start": { + "filename": "stb/stb_ds.h", + "line": 1051, + "column": 1, + "source_line": "static size_t stbds_siphash_bytes(void *p, size_t len, size_t seed)" + }, + "end": { + "filename": "stb/stb_ds.h", + "line": 1114, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbds_hash_bytes", + "result_type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t len", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "seed", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t seed", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1116, + "column": 1, + "source_line": "size_t stbds_hash_bytes(void *p, size_t len, size_t seed)" + }, + "start": { + "filename": "stb/stb_ds.h", + "line": 1116, + "column": 1, + "source_line": "size_t stbds_hash_bytes(void *p, size_t len, size_t seed)" + }, + "end": { + "filename": "stb/stb_ds.h", + "line": 1197, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbds_is_key_equal", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "elemsize", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t elemsize", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "key", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *key", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *key", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "keysize", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t keysize", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "keyoffset", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t keyoffset", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mode", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mode" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mode" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "i", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t i", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1203, + "column": 1, + "source_line": "static int stbds_is_key_equal(void *a, size_t elemsize, void *key, size_t keysize, size_t keyoffset, int mode, size_t i)" + }, + "start": { + "filename": "stb/stb_ds.h", + "line": 1203, + "column": 1, + "source_line": "static int stbds_is_key_equal(void *a, size_t elemsize, void *key, size_t keysize, size_t keyoffset, int mode, size_t i)" + }, + "end": { + "filename": "stb/stb_ds.h", + "line": 1209, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbds_hmfree_func", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "elemsize", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t elemsize", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1216, + "column": 1, + "source_line": "void stbds_hmfree_func(void *a, size_t elemsize)" + }, + "start": { + "filename": "stb/stb_ds.h", + "line": 1216, + "column": 1, + "source_line": "void stbds_hmfree_func(void *a, size_t elemsize)" + }, + "end": { + "filename": "stb/stb_ds.h", + "line": 1230, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbds_hm_find_slot", + "result_type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "ptrdiff_t", + "name": "ptrdiff_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "elemsize", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t elemsize", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "key", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *key", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *key", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "keysize", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t keysize", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "keyoffset", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t keyoffset", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mode", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mode" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mode" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1232, + "column": 1, + "source_line": "static ptrdiff_t stbds_hm_find_slot(void *a, size_t elemsize, void *key, size_t keysize, size_t keyoffset, int mode)" + }, + "start": { + "filename": "stb/stb_ds.h", + "line": 1232, + "column": 1, + "source_line": "static ptrdiff_t stbds_hm_find_slot(void *a, size_t elemsize, void *key, size_t keysize, size_t keyoffset, int mode)" + }, + "end": { + "filename": "stb/stb_ds.h", + "line": 1279, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbds_hmget_key_ts", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "elemsize", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t elemsize", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "key", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *key", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *key", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "keysize", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t keysize", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "temp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "ptrdiff_t *temp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "ptrdiff_t", + "name": "ptrdiff_t", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "ptrdiff_t *temp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "ptrdiff_t" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mode", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mode" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mode" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1281, + "column": 1, + "source_line": "void * stbds_hmget_key_ts(void *a, size_t elemsize, void *key, size_t keysize, ptrdiff_t *temp, int mode)" + }, + "start": { + "filename": "stb/stb_ds.h", + "line": 1281, + "column": 1, + "source_line": "void * stbds_hmget_key_ts(void *a, size_t elemsize, void *key, size_t keysize, ptrdiff_t *temp, int mode)" + }, + "end": { + "filename": "stb/stb_ds.h", + "line": 1310, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbds_hmget_key", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "elemsize", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t elemsize", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "key", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *key", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *key", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "keysize", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t keysize", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mode", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mode" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mode" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1312, + "column": 1, + "source_line": "void * stbds_hmget_key(void *a, size_t elemsize, void *key, size_t keysize, int mode)" + }, + "start": { + "filename": "stb/stb_ds.h", + "line": 1312, + "column": 1, + "source_line": "void * stbds_hmget_key(void *a, size_t elemsize, void *key, size_t keysize, int mode)" + }, + "end": { + "filename": "stb/stb_ds.h", + "line": 1318, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbds_hmput_default", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "elemsize", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t elemsize", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1320, + "column": 1, + "source_line": "void * stbds_hmput_default(void *a, size_t elemsize)" + }, + "start": { + "filename": "stb/stb_ds.h", + "line": 1320, + "column": 1, + "source_line": "void * stbds_hmput_default(void *a, size_t elemsize)" + }, + "end": { + "filename": "stb/stb_ds.h", + "line": 1333, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbds_strdup", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1540, + "column": 1, + "source_line": "static char *stbds_strdup(char *str)" + }, + "start": { + "filename": "stb/stb_ds.h", + "line": 1540, + "column": 1, + "source_line": "static char *stbds_strdup(char *str)" + }, + "end": { + "filename": "stb/stb_ds.h", + "line": 1548, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_ds.h", + "line": 1335, + "column": 1, + "source_line": "static char *stbds_strdup(char *str);" + } + ] + }, + { + "name": "stbds_hmput_key", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "elemsize", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t elemsize", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "key", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *key", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *key", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "keysize", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t keysize", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mode", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mode" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mode" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1337, + "column": 1, + "source_line": "void *stbds_hmput_key(void *a, size_t elemsize, void *key, size_t keysize, int mode)" + }, + "start": { + "filename": "stb/stb_ds.h", + "line": 1337, + "column": 1, + "source_line": "void *stbds_hmput_key(void *a, size_t elemsize, void *key, size_t keysize, int mode)" + }, + "end": { + "filename": "stb/stb_ds.h", + "line": 1459, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbds_shmode_func", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "parameters": [ + { + "name": "elemsize", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t elemsize", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mode", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mode" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mode" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1461, + "column": 1, + "source_line": "void * stbds_shmode_func(size_t elemsize, int mode)" + }, + "start": { + "filename": "stb/stb_ds.h", + "line": 1461, + "column": 1, + "source_line": "void * stbds_shmode_func(size_t elemsize, int mode)" + }, + "end": { + "filename": "stb/stb_ds.h", + "line": 1470, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbds_hmdel_key", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "elemsize", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t elemsize", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "key", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *key", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *key", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "keysize", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t keysize", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "keyoffset", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t keyoffset", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mode", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mode" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mode" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1472, + "column": 1, + "source_line": "void * stbds_hmdel_key(void *a, size_t elemsize, void *key, size_t keysize, size_t keyoffset, int mode)" + }, + "start": { + "filename": "stb/stb_ds.h", + "line": 1472, + "column": 1, + "source_line": "void * stbds_hmdel_key(void *a, size_t elemsize, void *key, size_t keysize, size_t keyoffset, int mode)" + }, + "end": { + "filename": "stb/stb_ds.h", + "line": 1538, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbds_stralloc", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbds_string_arena *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbds_string_arena", + "name": "stbds_string_arena", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbds_string_arena *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbds_string_arena" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1557, + "column": 1, + "source_line": "char *stbds_stralloc(stbds_string_arena *a, char *str)" + }, + "start": { + "filename": "stb/stb_ds.h", + "line": 1557, + "column": 1, + "source_line": "char *stbds_stralloc(stbds_string_arena *a, char *str)" + }, + "end": { + "filename": "stb/stb_ds.h", + "line": 1603, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbds_strreset", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbds_string_arena *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbds_string_arena", + "name": "stbds_string_arena", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbds_string_arena *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbds_string_arena" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1605, + "column": 1, + "source_line": "void stbds_strreset(stbds_string_arena *a)" + }, + "start": { + "filename": "stb/stb_ds.h", + "line": 1605, + "column": 1, + "source_line": "void stbds_strreset(stbds_string_arena *a)" + }, + "end": { + "filename": "stb/stb_ds.h", + "line": 1615, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "strkey", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "parameters": [ + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1638, + "column": 1, + "source_line": "char *strkey(int n)" + }, + "start": { + "filename": "stb/stb_ds.h", + "line": 1638, + "column": 1, + "source_line": "char *strkey(int n)" + }, + "end": { + "filename": "stb/stb_ds.h", + "line": 1646, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbds_unit_tests", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1648, + "column": 1, + "source_line": "void stbds_unit_tests(void)" + }, + "start": { + "filename": "stb/stb_ds.h", + "line": 1648, + "column": 1, + "source_line": "void stbds_unit_tests(void)" + }, + "end": { + "filename": "stb/stb_ds.h", + "line": 1851, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + } + ], + "structs": [ + { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "length", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t length", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 659, + "column": 3, + "source_line": " size_t length;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "capacity", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t capacity", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 660, + "column": 3, + "source_line": " size_t capacity;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "hash_table", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * hash_table", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 661, + "column": 3, + "source_line": " void * hash_table;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "temp", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "ptrdiff_t temp", + "name": "ptrdiff_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 662, + "column": 3, + "source_line": " ptrdiff_t temp;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_ds.h:657:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 657, + "column": 1, + "source_line": "typedef struct" + } + }, + { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": "stbds_string_block", + "members": [ + { + "name": "next", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "struct stbds_string_block *next", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "struct stbds_string_block" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 667, + "column": 3, + "source_line": " struct stbds_string_block *next;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "storage", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char storage[8]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "8", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 668, + "column": 3, + "source_line": " char storage[8];" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": null, + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 665, + "column": 1, + "source_line": "typedef struct stbds_string_block" + } + }, + { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": "stbds_string_arena", + "members": [ + { + "name": "storage", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbds_string_block *storage", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbds_string_block", + "name": "stbds_string_block", + "type": { + "reference": "struct stbds_string_block" + }, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 665, + "column": 1, + "source_line": "typedef struct stbds_string_block" + }, + "declaration_locations": [] + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 673, + "column": 3, + "source_line": " stbds_string_block *storage;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "remaining", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t remaining", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 674, + "column": 3, + "source_line": " size_t remaining;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "block", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char block" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 675, + "column": 3, + "source_line": " unsigned char block;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "mode", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char mode" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 676, + "column": 3, + "source_line": " unsigned char mode; // this isn't used by the string arena itself" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": null, + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 671, + "column": 1, + "source_line": "struct stbds_string_arena" + } + }, + { + "reference": "struct@stb/stb_ds.h:821:1" + }, + { + "reference": "struct@stb/stb_ds.h:827:1" + }, + { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "key", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int key" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1634, + "column": 18, + "source_line": "typedef struct { int key,b,c,d; } stbds_struct;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "b", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1634, + "column": 18, + "source_line": "typedef struct { int key,b,c,d; } stbds_struct;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "c", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1634, + "column": 18, + "source_line": "typedef struct { int key,b,c,d; } stbds_struct;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "d", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int d" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1634, + "column": 18, + "source_line": "typedef struct { int key,b,c,d; } stbds_struct;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_ds.h:1634:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1634, + "column": 1, + "source_line": "typedef struct { int key,b,c,d; } stbds_struct;" + } + }, + { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "key", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int key[2]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "2", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1635, + "column": 18, + "source_line": "typedef struct { int key[2],b,c,d; } stbds_struct2;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "b", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1635, + "column": 18, + "source_line": "typedef struct { int key[2],b,c,d; } stbds_struct2;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "c", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1635, + "column": 18, + "source_line": "typedef struct { int key[2],b,c,d; } stbds_struct2;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "d", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int d" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1635, + "column": 18, + "source_line": "typedef struct { int key[2],b,c,d; } stbds_struct2;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_ds.h:1635:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1635, + "column": 1, + "source_line": "typedef struct { int key[2],b,c,d; } stbds_struct2;" + } + } + ], + "unions": [], + "enums": [ + { + "model": "CEnum", + "qualifiers": [], + "source_text": "", + "name": null, + "constants": [ + { + "name": "STBDS_SH_NONE", + "value": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 682, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBDS_SH_DEFAULT", + "value": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 682, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBDS_SH_STRDUP", + "value": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 682, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBDS_SH_ARENA", + "value": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 682, + "column": 1, + "source_line": "enum" + } + } + ], + "anonymous_id": "enum@stb/stb_ds.h:682:1", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 682, + "column": 1, + "source_line": "enum" + } + } + ], + "typedefs": [ + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbds_array_header", + "name": "stbds_array_header", + "type": { + "reference": "struct@stb/stb_ds.h:657:1" + }, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 657, + "column": 1, + "source_line": "typedef struct" + }, + "declaration_locations": [] + }, + { + "reference": "stbds_string_block" + }, + { + "reference": "stbds_hash_bucket" + }, + { + "reference": "stbds_hash_index" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "STBDS_SIPHASH_2_4_can_only_be_used_in_64_bit_builds", + "name": "STBDS_SIPHASH_2_4_can_only_be_used_in_64_bit_builds", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "typedef int STBDS_SIPHASH_2_4_can_only_be_used_in_64_bit_builds[sizeof(size_t) == 8 ? 1 : -1]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "sizeof(size_t) == 8 ? 1 : -1", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1036, + "column": 1, + "source_line": "typedef int STBDS_SIPHASH_2_4_can_only_be_used_in_64_bit_builds[sizeof(size_t) == 8 ? 1 : -1];" + }, + "declaration_locations": [] + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbds_struct", + "name": "stbds_struct", + "type": { + "reference": "struct@stb/stb_ds.h:1634:1" + }, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1634, + "column": 1, + "source_line": "typedef struct { int key,b,c,d; } stbds_struct;" + }, + "declaration_locations": [] + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbds_struct2", + "name": "stbds_struct2", + "type": { + "reference": "struct@stb/stb_ds.h:1635:1" + }, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1635, + "column": 1, + "source_line": "typedef struct { int key[2],b,c,d; } stbds_struct2;" + }, + "declaration_locations": [] + } + ], + "variables": [ + { + "name": "stbds_array_grow", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t stbds_array_grow", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 743, + "column": 1, + "source_line": "size_t stbds_array_grow;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "stbds_hash_grow", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t stbds_hash_grow", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 744, + "column": 1, + "source_line": "size_t stbds_hash_grow;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "stbds_hash_shrink", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t stbds_hash_shrink", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 745, + "column": 1, + "source_line": "size_t stbds_hash_shrink;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "stbds_hash_rebuild", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t stbds_hash_rebuild", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 746, + "column": 1, + "source_line": "size_t stbds_hash_rebuild;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "stbds_hash_probes", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t stbds_hash_probes", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 747, + "column": 1, + "source_line": "size_t stbds_hash_probes;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "stbds_hash_alloc", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t stbds_hash_alloc", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 748, + "column": 1, + "source_line": "size_t stbds_hash_alloc;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "stbds_rehash_probes", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t stbds_rehash_probes", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 749, + "column": 1, + "source_line": "size_t stbds_rehash_probes;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "stbds_rehash_items", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t stbds_rehash_items", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 750, + "column": 1, + "source_line": "size_t stbds_rehash_items;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "stbds_hash_seed", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "static size_t stbds_hash_seed", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "storage": [ + "static" + ], + "initializer": { + "source_text": "0x31415926" + }, + "bit_width": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 849, + "column": 1, + "source_line": "static size_t stbds_hash_seed=0x31415926;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "static char buffer[256]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "256", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "storage": [ + "static" + ], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1637, + "column": 1, + "source_line": "static char buffer[256];" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "macros": [ + { + "name": "_CRT_SECURE_NO_WARNINGS", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 388, + "column": 1, + "source_line": "#define _CRT_SECURE_NO_WARNINGS" + } + }, + { + "name": "INCLUDE_STB_DS_H", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 392, + "column": 1, + "source_line": "#define INCLUDE_STB_DS_H" + } + }, + { + "name": "arrlen", + "value": "stbds_arrlen", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 398, + "column": 1, + "source_line": "#define arrlen stbds_arrlen" + } + }, + { + "name": "arrlenu", + "value": "stbds_arrlenu", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 399, + "column": 1, + "source_line": "#define arrlenu stbds_arrlenu" + } + }, + { + "name": "arrput", + "value": "stbds_arrput", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 400, + "column": 1, + "source_line": "#define arrput stbds_arrput" + } + }, + { + "name": "arrpush", + "value": "stbds_arrput", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 401, + "column": 1, + "source_line": "#define arrpush stbds_arrput" + } + }, + { + "name": "arrpop", + "value": "stbds_arrpop", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 402, + "column": 1, + "source_line": "#define arrpop stbds_arrpop" + } + }, + { + "name": "arrfree", + "value": "stbds_arrfree", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 403, + "column": 1, + "source_line": "#define arrfree stbds_arrfree" + } + }, + { + "name": "arraddn", + "value": "stbds_arraddn", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 404, + "column": 1, + "source_line": "#define arraddn stbds_arraddn // deprecated, use one of the following instead:" + } + }, + { + "name": "arraddnptr", + "value": "stbds_arraddnptr", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 405, + "column": 1, + "source_line": "#define arraddnptr stbds_arraddnptr" + } + }, + { + "name": "arraddnindex", + "value": "stbds_arraddnindex", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 406, + "column": 1, + "source_line": "#define arraddnindex stbds_arraddnindex" + } + }, + { + "name": "arrsetlen", + "value": "stbds_arrsetlen", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 407, + "column": 1, + "source_line": "#define arrsetlen stbds_arrsetlen" + } + }, + { + "name": "arrlast", + "value": "stbds_arrlast", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 408, + "column": 1, + "source_line": "#define arrlast stbds_arrlast" + } + }, + { + "name": "arrins", + "value": "stbds_arrins", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 409, + "column": 1, + "source_line": "#define arrins stbds_arrins" + } + }, + { + "name": "arrinsn", + "value": "stbds_arrinsn", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 410, + "column": 1, + "source_line": "#define arrinsn stbds_arrinsn" + } + }, + { + "name": "arrdel", + "value": "stbds_arrdel", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 411, + "column": 1, + "source_line": "#define arrdel stbds_arrdel" + } + }, + { + "name": "arrdeln", + "value": "stbds_arrdeln", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 412, + "column": 1, + "source_line": "#define arrdeln stbds_arrdeln" + } + }, + { + "name": "arrdelswap", + "value": "stbds_arrdelswap", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 413, + "column": 1, + "source_line": "#define arrdelswap stbds_arrdelswap" + } + }, + { + "name": "arrcap", + "value": "stbds_arrcap", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 414, + "column": 1, + "source_line": "#define arrcap stbds_arrcap" + } + }, + { + "name": "arrsetcap", + "value": "stbds_arrsetcap", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 415, + "column": 1, + "source_line": "#define arrsetcap stbds_arrsetcap" + } + }, + { + "name": "hmput", + "value": "stbds_hmput", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 417, + "column": 1, + "source_line": "#define hmput stbds_hmput" + } + }, + { + "name": "hmputs", + "value": "stbds_hmputs", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 418, + "column": 1, + "source_line": "#define hmputs stbds_hmputs" + } + }, + { + "name": "hmget", + "value": "stbds_hmget", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 419, + "column": 1, + "source_line": "#define hmget stbds_hmget" + } + }, + { + "name": "hmget_ts", + "value": "stbds_hmget_ts", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 420, + "column": 1, + "source_line": "#define hmget_ts stbds_hmget_ts" + } + }, + { + "name": "hmgets", + "value": "stbds_hmgets", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 421, + "column": 1, + "source_line": "#define hmgets stbds_hmgets" + } + }, + { + "name": "hmgetp", + "value": "stbds_hmgetp", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 422, + "column": 1, + "source_line": "#define hmgetp stbds_hmgetp" + } + }, + { + "name": "hmgetp_ts", + "value": "stbds_hmgetp_ts", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 423, + "column": 1, + "source_line": "#define hmgetp_ts stbds_hmgetp_ts" + } + }, + { + "name": "hmgetp_null", + "value": "stbds_hmgetp_null", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 424, + "column": 1, + "source_line": "#define hmgetp_null stbds_hmgetp_null" + } + }, + { + "name": "hmgeti", + "value": "stbds_hmgeti", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 425, + "column": 1, + "source_line": "#define hmgeti stbds_hmgeti" + } + }, + { + "name": "hmgeti_ts", + "value": "stbds_hmgeti_ts", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 426, + "column": 1, + "source_line": "#define hmgeti_ts stbds_hmgeti_ts" + } + }, + { + "name": "hmdel", + "value": "stbds_hmdel", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 427, + "column": 1, + "source_line": "#define hmdel stbds_hmdel" + } + }, + { + "name": "hmlen", + "value": "stbds_hmlen", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 428, + "column": 1, + "source_line": "#define hmlen stbds_hmlen" + } + }, + { + "name": "hmlenu", + "value": "stbds_hmlenu", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 429, + "column": 1, + "source_line": "#define hmlenu stbds_hmlenu" + } + }, + { + "name": "hmfree", + "value": "stbds_hmfree", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 430, + "column": 1, + "source_line": "#define hmfree stbds_hmfree" + } + }, + { + "name": "hmdefault", + "value": "stbds_hmdefault", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 431, + "column": 1, + "source_line": "#define hmdefault stbds_hmdefault" + } + }, + { + "name": "hmdefaults", + "value": "stbds_hmdefaults", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 432, + "column": 1, + "source_line": "#define hmdefaults stbds_hmdefaults" + } + }, + { + "name": "shput", + "value": "stbds_shput", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 434, + "column": 1, + "source_line": "#define shput stbds_shput" + } + }, + { + "name": "shputi", + "value": "stbds_shputi", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 435, + "column": 1, + "source_line": "#define shputi stbds_shputi" + } + }, + { + "name": "shputs", + "value": "stbds_shputs", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 436, + "column": 1, + "source_line": "#define shputs stbds_shputs" + } + }, + { + "name": "shget", + "value": "stbds_shget", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 437, + "column": 1, + "source_line": "#define shget stbds_shget" + } + }, + { + "name": "shgeti", + "value": "stbds_shgeti", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 438, + "column": 1, + "source_line": "#define shgeti stbds_shgeti" + } + }, + { + "name": "shgets", + "value": "stbds_shgets", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 439, + "column": 1, + "source_line": "#define shgets stbds_shgets" + } + }, + { + "name": "shgetp", + "value": "stbds_shgetp", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 440, + "column": 1, + "source_line": "#define shgetp stbds_shgetp" + } + }, + { + "name": "shgetp_null", + "value": "stbds_shgetp_null", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 441, + "column": 1, + "source_line": "#define shgetp_null stbds_shgetp_null" + } + }, + { + "name": "shdel", + "value": "stbds_shdel", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 442, + "column": 1, + "source_line": "#define shdel stbds_shdel" + } + }, + { + "name": "shlen", + "value": "stbds_shlen", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 443, + "column": 1, + "source_line": "#define shlen stbds_shlen" + } + }, + { + "name": "shlenu", + "value": "stbds_shlenu", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 444, + "column": 1, + "source_line": "#define shlenu stbds_shlenu" + } + }, + { + "name": "shfree", + "value": "stbds_shfree", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 445, + "column": 1, + "source_line": "#define shfree stbds_shfree" + } + }, + { + "name": "shdefault", + "value": "stbds_shdefault", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 446, + "column": 1, + "source_line": "#define shdefault stbds_shdefault" + } + }, + { + "name": "shdefaults", + "value": "stbds_shdefaults", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 447, + "column": 1, + "source_line": "#define shdefaults stbds_shdefaults" + } + }, + { + "name": "sh_new_arena", + "value": "stbds_sh_new_arena", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 448, + "column": 1, + "source_line": "#define sh_new_arena stbds_sh_new_arena" + } + }, + { + "name": "sh_new_strdup", + "value": "stbds_sh_new_strdup", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 449, + "column": 1, + "source_line": "#define sh_new_strdup stbds_sh_new_strdup" + } + }, + { + "name": "stralloc", + "value": "stbds_stralloc", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 451, + "column": 1, + "source_line": "#define stralloc stbds_stralloc" + } + }, + { + "name": "strreset", + "value": "stbds_strreset", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 452, + "column": 1, + "source_line": "#define strreset stbds_strreset" + } + }, + { + "name": "STBDS_REALLOC", + "value": "realloc(p,s)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 460, + "column": 1, + "source_line": "#define STBDS_REALLOC(c,p,s) realloc(p,s)" + } + }, + { + "name": "STBDS_FREE", + "value": "free(p)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 461, + "column": 1, + "source_line": "#define STBDS_FREE(c,p) free(p)" + } + }, + { + "name": "STBDS_NOTUSED", + "value": "(void)(v)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 465, + "column": 1, + "source_line": "#define STBDS_NOTUSED(v) (void)(v)" + } + }, + { + "name": "STBDS_NOTUSED", + "value": "(void)sizeof(v)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 467, + "column": 1, + "source_line": "#define STBDS_NOTUSED(v) (void)sizeof(v)" + } + }, + { + "name": "STBDS_HAS_TYPEOF", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 509, + "column": 1, + "source_line": "#define STBDS_HAS_TYPEOF" + } + }, + { + "name": "STBDS_HAS_LITERAL_ARRAY", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 517, + "column": 1, + "source_line": "#define STBDS_HAS_LITERAL_ARRAY" + } + }, + { + "name": "STBDS_ADDRESSOF", + "value": "((__typeof__(typevar)[1]){value})", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 524, + "column": 3, + "source_line": " #define STBDS_ADDRESSOF(typevar, value) ((__typeof__(typevar)[1]){value}) // literal array decays to pointer to value" + } + }, + { + "name": "STBDS_ADDRESSOF", + "value": "((typeof(typevar)[1]){value})", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 526, + "column": 3, + "source_line": " #define STBDS_ADDRESSOF(typevar, value) ((typeof(typevar)[1]){value}) // literal array decays to pointer to value" + } + }, + { + "name": "STBDS_ADDRESSOF", + "value": "&(value)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 529, + "column": 1, + "source_line": "#define STBDS_ADDRESSOF(typevar, value) &(value)" + } + }, + { + "name": "STBDS_OFFSETOF", + "value": "((char *) &(var)->field - (char *) (var))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 532, + "column": 1, + "source_line": "#define STBDS_OFFSETOF(var,field) ((char *) &(var)->field - (char *) (var))" + } + }, + { + "name": "stbds_header", + "value": "((stbds_array_header *) (t) - 1)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 534, + "column": 1, + "source_line": "#define stbds_header(t) ((stbds_array_header *) (t) - 1)" + } + }, + { + "name": "stbds_temp", + "value": "stbds_header(t)->temp", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 535, + "column": 1, + "source_line": "#define stbds_temp(t) stbds_header(t)->temp" + } + }, + { + "name": "stbds_temp_key", + "value": "(*(char **) stbds_header(t)->hash_table)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 536, + "column": 1, + "source_line": "#define stbds_temp_key(t) (*(char **) stbds_header(t)->hash_table)" + } + }, + { + "name": "stbds_arrsetcap", + "value": "(stbds_arrgrow(a,0,n))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 538, + "column": 1, + "source_line": "#define stbds_arrsetcap(a,n) (stbds_arrgrow(a,0,n))" + } + }, + { + "name": "stbds_arrsetlen", + "value": "((stbds_arrcap(a) < (size_t) (n) ? stbds_arrsetcap((a),(size_t)(n)),0 : 0), (a) ? stbds_header(a)->length = (size_t) (n) : 0)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 539, + "column": 1, + "source_line": "#define stbds_arrsetlen(a,n) ((stbds_arrcap(a) < (size_t) (n) ? stbds_arrsetcap((a),(size_t)(n)),0 : 0), (a) ? stbds_header(a)->length = (size_t) (n) : 0)" + } + }, + { + "name": "stbds_arrcap", + "value": "((a) ? stbds_header(a)->capacity : 0)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 540, + "column": 1, + "source_line": "#define stbds_arrcap(a) ((a) ? stbds_header(a)->capacity : 0)" + } + }, + { + "name": "stbds_arrlen", + "value": "((a) ? (ptrdiff_t) stbds_header(a)->length : 0)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 541, + "column": 1, + "source_line": "#define stbds_arrlen(a) ((a) ? (ptrdiff_t) stbds_header(a)->length : 0)" + } + }, + { + "name": "stbds_arrlenu", + "value": "((a) ? stbds_header(a)->length : 0)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 542, + "column": 1, + "source_line": "#define stbds_arrlenu(a) ((a) ? stbds_header(a)->length : 0)" + } + }, + { + "name": "stbds_arrput", + "value": "(stbds_arrmaybegrow(a,1), (a)[stbds_header(a)->length++] = (v))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 543, + "column": 1, + "source_line": "#define stbds_arrput(a,v) (stbds_arrmaybegrow(a,1), (a)[stbds_header(a)->length++] = (v))" + } + }, + { + "name": "stbds_arrpush", + "value": "stbds_arrput", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 544, + "column": 1, + "source_line": "#define stbds_arrpush stbds_arrput // synonym" + } + }, + { + "name": "stbds_arrpop", + "value": "(stbds_header(a)->length--, (a)[stbds_header(a)->length])", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 545, + "column": 1, + "source_line": "#define stbds_arrpop(a) (stbds_header(a)->length--, (a)[stbds_header(a)->length])" + } + }, + { + "name": "stbds_arraddn", + "value": "((void)(stbds_arraddnindex(a, n)))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 546, + "column": 1, + "source_line": "#define stbds_arraddn(a,n) ((void)(stbds_arraddnindex(a, n))) // deprecated, use one of the following instead:" + } + }, + { + "name": "stbds_arraddnptr", + "value": "(stbds_arrmaybegrow(a,n), (n) ? (stbds_header(a)->length += (n), &(a)[stbds_header(a)->length-(n)]) : (a))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 547, + "column": 1, + "source_line": "#define stbds_arraddnptr(a,n) (stbds_arrmaybegrow(a,n), (n) ? (stbds_header(a)->length += (n), &(a)[stbds_header(a)->length-(n)]) : (a))" + } + }, + { + "name": "stbds_arraddnoff", + "value": "stbds_arraddnindex", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 549, + "column": 1, + "source_line": "#define stbds_arraddnoff stbds_arraddnindex" + } + }, + { + "name": "stbds_arrlast", + "value": "((a)[stbds_header(a)->length-1])", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 550, + "column": 1, + "source_line": "#define stbds_arrlast(a) ((a)[stbds_header(a)->length-1])" + } + }, + { + "name": "stbds_arrfree", + "value": "((void) ((a) ? STBDS_FREE(NULL,stbds_header(a)) : (void)0), (a)=NULL)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 551, + "column": 1, + "source_line": "#define stbds_arrfree(a) ((void) ((a) ? STBDS_FREE(NULL,stbds_header(a)) : (void)0), (a)=NULL)" + } + }, + { + "name": "stbds_arrdel", + "value": "stbds_arrdeln(a,i,1)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 552, + "column": 1, + "source_line": "#define stbds_arrdel(a,i) stbds_arrdeln(a,i,1)" + } + }, + { + "name": "stbds_arrdeln", + "value": "(memmove(&(a)[i], &(a)[(i)+(n)], sizeof *(a) * (stbds_header(a)->length-(n)-(i))), stbds_header(a)->length -= (n))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 553, + "column": 1, + "source_line": "#define stbds_arrdeln(a,i,n) (memmove(&(a)[i], &(a)[(i)+(n)], sizeof *(a) * (stbds_header(a)->length-(n)-(i))), stbds_header(a)->length -= (n))" + } + }, + { + "name": "stbds_arrdelswap", + "value": "((a)[i] = stbds_arrlast(a), stbds_header(a)->length -= 1)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 554, + "column": 1, + "source_line": "#define stbds_arrdelswap(a,i) ((a)[i] = stbds_arrlast(a), stbds_header(a)->length -= 1)" + } + }, + { + "name": "stbds_arrinsn", + "value": "(stbds_arraddn((a),(n)), memmove(&(a)[(i)+(n)], &(a)[i], sizeof *(a) * (stbds_header(a)->length-(n)-(i))))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 555, + "column": 1, + "source_line": "#define stbds_arrinsn(a,i,n) (stbds_arraddn((a),(n)), memmove(&(a)[(i)+(n)], &(a)[i], sizeof *(a) * (stbds_header(a)->length-(n)-(i))))" + } + }, + { + "name": "stbds_arrins", + "value": "(stbds_arrinsn((a),(i),1), (a)[i]=(v))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 556, + "column": 1, + "source_line": "#define stbds_arrins(a,i,v) (stbds_arrinsn((a),(i),1), (a)[i]=(v))" + } + }, + { + "name": "stbds_arrmaybegrow", + "value": "((!(a) || stbds_header(a)->length + (n) > stbds_header(a)->capacity) ? (stbds_arrgrow(a,n,0),0) : 0)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 558, + "column": 1, + "source_line": "#define stbds_arrmaybegrow(a,n) ((!(a) || stbds_header(a)->length + (n) > stbds_header(a)->capacity) \\" + } + }, + { + "name": "stbds_arrgrow", + "value": "((a) = stbds_arrgrowf_wrapper((a), sizeof *(a), (b), (c)))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 561, + "column": 1, + "source_line": "#define stbds_arrgrow(a,b,c) ((a) = stbds_arrgrowf_wrapper((a), sizeof *(a), (b), (c)))" + } + }, + { + "name": "stbds_hmput", + "value": "((t) = stbds_hmput_key_wrapper((t), sizeof *(t), (void*) STBDS_ADDRESSOF((t)->key, (k)), sizeof (t)->key, 0), (t)[stbds_temp((t)-1)].key = (k), (t)[stbds_temp((t)-1)].value = (v))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 563, + "column": 1, + "source_line": "#define stbds_hmput(t, k, v) \\" + } + }, + { + "name": "stbds_hmputs", + "value": "((t) = stbds_hmput_key_wrapper((t), sizeof *(t), &(s).key, sizeof (s).key, STBDS_HM_BINARY), (t)[stbds_temp((t)-1)] = (s))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 568, + "column": 1, + "source_line": "#define stbds_hmputs(t, s) \\" + } + }, + { + "name": "stbds_hmgeti", + "value": "((t) = stbds_hmget_key_wrapper((t), sizeof *(t), (void*) STBDS_ADDRESSOF((t)->key, (k)), sizeof (t)->key, STBDS_HM_BINARY), stbds_temp((t)-1))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 572, + "column": 1, + "source_line": "#define stbds_hmgeti(t,k) \\" + } + }, + { + "name": "stbds_hmgeti_ts", + "value": "((t) = stbds_hmget_key_ts_wrapper((t), sizeof *(t), (void*) STBDS_ADDRESSOF((t)->key, (k)), sizeof (t)->key, &(temp), STBDS_HM_BINARY), (temp))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 576, + "column": 1, + "source_line": "#define stbds_hmgeti_ts(t,k,temp) \\" + } + }, + { + "name": "stbds_hmgetp", + "value": "((void) stbds_hmgeti(t,k), &(t)[stbds_temp((t)-1)])", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 580, + "column": 1, + "source_line": "#define stbds_hmgetp(t, k) \\" + } + }, + { + "name": "stbds_hmgetp_ts", + "value": "((void) stbds_hmgeti_ts(t,k,temp), &(t)[temp])", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 583, + "column": 1, + "source_line": "#define stbds_hmgetp_ts(t, k, temp) \\" + } + }, + { + "name": "stbds_hmdel", + "value": "(((t) = stbds_hmdel_key_wrapper((t),sizeof *(t), (void*) STBDS_ADDRESSOF((t)->key, (k)), sizeof (t)->key, STBDS_OFFSETOF((t),key), STBDS_HM_BINARY)),(t)?stbds_temp((t)-1):0)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 586, + "column": 1, + "source_line": "#define stbds_hmdel(t,k) \\" + } + }, + { + "name": "stbds_hmdefault", + "value": "((t) = stbds_hmput_default_wrapper((t), sizeof *(t)), (t)[-1].value = (v))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 589, + "column": 1, + "source_line": "#define stbds_hmdefault(t, v) \\" + } + }, + { + "name": "stbds_hmdefaults", + "value": "((t) = stbds_hmput_default_wrapper((t), sizeof *(t)), (t)[-1] = (s))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 592, + "column": 1, + "source_line": "#define stbds_hmdefaults(t, s) \\" + } + }, + { + "name": "stbds_hmfree", + "value": "((void) ((p) != NULL ? stbds_hmfree_func((p)-1,sizeof*(p)),0 : 0),(p)=NULL)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 595, + "column": 1, + "source_line": "#define stbds_hmfree(p) \\" + } + }, + { + "name": "stbds_hmgets", + "value": "(*stbds_hmgetp(t,k))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 598, + "column": 1, + "source_line": "#define stbds_hmgets(t, k) (*stbds_hmgetp(t,k))" + } + }, + { + "name": "stbds_hmget", + "value": "(stbds_hmgetp(t,k)->value)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 599, + "column": 1, + "source_line": "#define stbds_hmget(t, k) (stbds_hmgetp(t,k)->value)" + } + }, + { + "name": "stbds_hmget_ts", + "value": "(stbds_hmgetp_ts(t,k,temp)->value)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 600, + "column": 1, + "source_line": "#define stbds_hmget_ts(t, k, temp) (stbds_hmgetp_ts(t,k,temp)->value)" + } + }, + { + "name": "stbds_hmlen", + "value": "((t) ? (ptrdiff_t) stbds_header((t)-1)->length-1 : 0)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 601, + "column": 1, + "source_line": "#define stbds_hmlen(t) ((t) ? (ptrdiff_t) stbds_header((t)-1)->length-1 : 0)" + } + }, + { + "name": "stbds_hmlenu", + "value": "((t) ? stbds_header((t)-1)->length-1 : 0)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 602, + "column": 1, + "source_line": "#define stbds_hmlenu(t) ((t) ? stbds_header((t)-1)->length-1 : 0)" + } + }, + { + "name": "stbds_hmgetp_null", + "value": "(stbds_hmgeti(t,k) == -1 ? NULL : &(t)[stbds_temp((t)-1)])", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 603, + "column": 1, + "source_line": "#define stbds_hmgetp_null(t,k) (stbds_hmgeti(t,k) == -1 ? NULL : &(t)[stbds_temp((t)-1)])" + } + }, + { + "name": "stbds_shput", + "value": "((t) = stbds_hmput_key_wrapper((t), sizeof *(t), (void*) (k), sizeof (t)->key, STBDS_HM_STRING), (t)[stbds_temp((t)-1)].value = (v))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 605, + "column": 1, + "source_line": "#define stbds_shput(t, k, v) \\" + } + }, + { + "name": "stbds_shputi", + "value": "((t) = stbds_hmput_key_wrapper((t), sizeof *(t), (void*) (k), sizeof (t)->key, STBDS_HM_STRING), (t)[stbds_temp((t)-1)].value = (v), stbds_temp((t)-1))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 609, + "column": 1, + "source_line": "#define stbds_shputi(t, k, v) \\" + } + }, + { + "name": "stbds_shputs", + "value": "((t) = stbds_hmput_key_wrapper((t), sizeof *(t), (void*) (s).key, sizeof (s).key, STBDS_HM_STRING), (t)[stbds_temp((t)-1)] = (s), (t)[stbds_temp((t)-1)].key = stbds_temp_key((t)-1))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 613, + "column": 1, + "source_line": "#define stbds_shputs(t, s) \\" + } + }, + { + "name": "stbds_pshput", + "value": "((t) = stbds_hmput_key_wrapper((t), sizeof *(t), (void*) (p)->key, sizeof (p)->key, STBDS_HM_PTR_TO_STRING), (t)[stbds_temp((t)-1)] = (p))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 618, + "column": 1, + "source_line": "#define stbds_pshput(t, p) \\" + } + }, + { + "name": "stbds_shgeti", + "value": "((t) = stbds_hmget_key_wrapper((t), sizeof *(t), (void*) (k), sizeof (t)->key, STBDS_HM_STRING), stbds_temp((t)-1))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 622, + "column": 1, + "source_line": "#define stbds_shgeti(t,k) \\" + } + }, + { + "name": "stbds_pshgeti", + "value": "((t) = stbds_hmget_key_wrapper((t), sizeof *(t), (void*) (k), sizeof (*(t))->key, STBDS_HM_PTR_TO_STRING), stbds_temp((t)-1))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 626, + "column": 1, + "source_line": "#define stbds_pshgeti(t,k) \\" + } + }, + { + "name": "stbds_shgetp", + "value": "((void) stbds_shgeti(t,k), &(t)[stbds_temp((t)-1)])", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 630, + "column": 1, + "source_line": "#define stbds_shgetp(t, k) \\" + } + }, + { + "name": "stbds_pshget", + "value": "((void) stbds_pshgeti(t,k), (t)[stbds_temp((t)-1)])", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 633, + "column": 1, + "source_line": "#define stbds_pshget(t, k) \\" + } + }, + { + "name": "stbds_shdel", + "value": "(((t) = stbds_hmdel_key_wrapper((t),sizeof *(t), (void*) (k), sizeof (t)->key, STBDS_OFFSETOF((t),key), STBDS_HM_STRING)),(t)?stbds_temp((t)-1):0)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 636, + "column": 1, + "source_line": "#define stbds_shdel(t,k) \\" + } + }, + { + "name": "stbds_pshdel", + "value": "(((t) = stbds_hmdel_key_wrapper((t),sizeof *(t), (void*) (k), sizeof (*(t))->key, STBDS_OFFSETOF(*(t),key), STBDS_HM_PTR_TO_STRING)),(t)?stbds_temp((t)-1):0)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 638, + "column": 1, + "source_line": "#define stbds_pshdel(t,k) \\" + } + }, + { + "name": "stbds_sh_new_arena", + "value": "((t) = stbds_shmode_func_wrapper(t, sizeof *(t), STBDS_SH_ARENA))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 641, + "column": 1, + "source_line": "#define stbds_sh_new_arena(t) \\" + } + }, + { + "name": "stbds_sh_new_strdup", + "value": "((t) = stbds_shmode_func_wrapper(t, sizeof *(t), STBDS_SH_STRDUP))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 643, + "column": 1, + "source_line": "#define stbds_sh_new_strdup(t) \\" + } + }, + { + "name": "stbds_shdefault", + "value": "stbds_hmdefault(t,v)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 646, + "column": 1, + "source_line": "#define stbds_shdefault(t, v) stbds_hmdefault(t,v)" + } + }, + { + "name": "stbds_shdefaults", + "value": "stbds_hmdefaults(t,s)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 647, + "column": 1, + "source_line": "#define stbds_shdefaults(t, s) stbds_hmdefaults(t,s)" + } + }, + { + "name": "stbds_shfree", + "value": "stbds_hmfree", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 649, + "column": 1, + "source_line": "#define stbds_shfree stbds_hmfree" + } + }, + { + "name": "stbds_shlenu", + "value": "stbds_hmlenu", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 650, + "column": 1, + "source_line": "#define stbds_shlenu stbds_hmlenu" + } + }, + { + "name": "stbds_shgets", + "value": "(*stbds_shgetp(t,k))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 652, + "column": 1, + "source_line": "#define stbds_shgets(t, k) (*stbds_shgetp(t,k))" + } + }, + { + "name": "stbds_shget", + "value": "(stbds_shgetp(t,k)->value)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 653, + "column": 1, + "source_line": "#define stbds_shget(t, k) (stbds_shgetp(t,k)->value)" + } + }, + { + "name": "stbds_shgetp_null", + "value": "(stbds_shgeti(t,k) == -1 ? NULL : &(t)[stbds_temp((t)-1)])", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 654, + "column": 1, + "source_line": "#define stbds_shgetp_null(t,k) (stbds_shgeti(t,k) == -1 ? NULL : &(t)[stbds_temp((t)-1)])" + } + }, + { + "name": "stbds_shlen", + "value": "stbds_hmlen", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 655, + "column": 1, + "source_line": "#define stbds_shlen stbds_hmlen" + } + }, + { + "name": "STBDS_HM_BINARY", + "value": "0", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 679, + "column": 1, + "source_line": "#define STBDS_HM_BINARY 0" + } + }, + { + "name": "STBDS_HM_STRING", + "value": "1", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 680, + "column": 1, + "source_line": "#define STBDS_HM_STRING 1" + } + }, + { + "name": "stbds_arrgrowf_wrapper", + "value": "stbds_arrgrowf", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 715, + "column": 1, + "source_line": "#define stbds_arrgrowf_wrapper stbds_arrgrowf" + } + }, + { + "name": "stbds_hmget_key_wrapper", + "value": "stbds_hmget_key", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 716, + "column": 1, + "source_line": "#define stbds_hmget_key_wrapper stbds_hmget_key" + } + }, + { + "name": "stbds_hmget_key_ts_wrapper", + "value": "stbds_hmget_key_ts", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 717, + "column": 1, + "source_line": "#define stbds_hmget_key_ts_wrapper stbds_hmget_key_ts" + } + }, + { + "name": "stbds_hmput_default_wrapper", + "value": "stbds_hmput_default", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 718, + "column": 1, + "source_line": "#define stbds_hmput_default_wrapper stbds_hmput_default" + } + }, + { + "name": "stbds_hmput_key_wrapper", + "value": "stbds_hmput_key", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 719, + "column": 1, + "source_line": "#define stbds_hmput_key_wrapper stbds_hmput_key" + } + }, + { + "name": "stbds_hmdel_key_wrapper", + "value": "stbds_hmdel_key", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 720, + "column": 1, + "source_line": "#define stbds_hmdel_key_wrapper stbds_hmdel_key" + } + }, + { + "name": "stbds_shmode_func_wrapper", + "value": "stbds_shmode_func(e,m)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 721, + "column": 1, + "source_line": "#define stbds_shmode_func_wrapper(t,e,m) stbds_shmode_func(e,m)" + } + }, + { + "name": "STBDS_ASSERT_WAS_UNDEFINED", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 737, + "column": 1, + "source_line": "#define STBDS_ASSERT_WAS_UNDEFINED" + } + }, + { + "name": "STBDS_ASSERT", + "value": "((void) 0)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 738, + "column": 1, + "source_line": "#define STBDS_ASSERT(x) ((void) 0)" + } + }, + { + "name": "STBDS_STATS", + "value": "x", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 742, + "column": 1, + "source_line": "#define STBDS_STATS(x) x" + } + }, + { + "name": "STBDS_STATS", + "value": null, + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 752, + "column": 1, + "source_line": "#define STBDS_STATS(x)" + } + }, + { + "name": "STBDS_BUCKET_LENGTH", + "value": "4", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 810, + "column": 1, + "source_line": "#define STBDS_BUCKET_LENGTH 4" + } + }, + { + "name": "STBDS_BUCKET_LENGTH", + "value": "8", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 812, + "column": 1, + "source_line": "#define STBDS_BUCKET_LENGTH 8" + } + }, + { + "name": "STBDS_BUCKET_SHIFT", + "value": "(STBDS_BUCKET_LENGTH == 8 ? 3 : 2)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 815, + "column": 1, + "source_line": "#define STBDS_BUCKET_SHIFT (STBDS_BUCKET_LENGTH == 8 ? 3 : 2)" + } + }, + { + "name": "STBDS_BUCKET_MASK", + "value": "(STBDS_BUCKET_LENGTH-1)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 816, + "column": 1, + "source_line": "#define STBDS_BUCKET_MASK (STBDS_BUCKET_LENGTH-1)" + } + }, + { + "name": "STBDS_CACHE_LINE_SIZE", + "value": "64", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 817, + "column": 1, + "source_line": "#define STBDS_CACHE_LINE_SIZE 64" + } + }, + { + "name": "STBDS_ALIGN_FWD", + "value": "(((n) + (a) - 1) & ~((a)-1))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 819, + "column": 1, + "source_line": "#define STBDS_ALIGN_FWD(n,a) (((n) + (a) - 1) & ~((a)-1))" + } + }, + { + "name": "STBDS_INDEX_EMPTY", + "value": "-1", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 842, + "column": 1, + "source_line": "#define STBDS_INDEX_EMPTY -1" + } + }, + { + "name": "STBDS_INDEX_DELETED", + "value": "-2", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 843, + "column": 1, + "source_line": "#define STBDS_INDEX_DELETED -2" + } + }, + { + "name": "STBDS_INDEX_IN_USE", + "value": "((x) >= 0)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 844, + "column": 1, + "source_line": "#define STBDS_INDEX_IN_USE(x) ((x) >= 0)" + } + }, + { + "name": "STBDS_HASH_EMPTY", + "value": "0", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 846, + "column": 1, + "source_line": "#define STBDS_HASH_EMPTY 0" + } + }, + { + "name": "STBDS_HASH_DELETED", + "value": "1", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 847, + "column": 1, + "source_line": "#define STBDS_HASH_DELETED 1" + } + }, + { + "name": "stbds_load_32_or_64", + "value": "temp = v64_lo ^ v32, temp <<= 16, temp <<= 16, temp >>= 16, temp >>= 16, var = v64_hi, var <<= 16, var <<= 16, var ^= temp ^ v32", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 856, + "column": 1, + "source_line": "#define stbds_load_32_or_64(var, temp, v32, v64_hi, v64_lo) \\" + } + }, + { + "name": "STBDS_SIZE_T_BITS", + "value": "((sizeof (size_t)) * 8)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 861, + "column": 1, + "source_line": "#define STBDS_SIZE_T_BITS ((sizeof (size_t)) * 8)" + } + }, + { + "name": "STBDS_ROTATE_LEFT", + "value": "(((val) << (n)) | ((val) >> (STBDS_SIZE_T_BITS - (n))))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1013, + "column": 1, + "source_line": "#define STBDS_ROTATE_LEFT(val, n) (((val) << (n)) | ((val) >> (STBDS_SIZE_T_BITS - (n))))" + } + }, + { + "name": "STBDS_ROTATE_RIGHT", + "value": "(((val) >> (n)) | ((val) << (STBDS_SIZE_T_BITS - (n))))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1014, + "column": 1, + "source_line": "#define STBDS_ROTATE_RIGHT(val, n) (((val) >> (n)) | ((val) << (STBDS_SIZE_T_BITS - (n))))" + } + }, + { + "name": "STBDS_SIPHASH_C_ROUNDS", + "value": "2", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1034, + "column": 1, + "source_line": "#define STBDS_SIPHASH_C_ROUNDS 2" + } + }, + { + "name": "STBDS_SIPHASH_D_ROUNDS", + "value": "4", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1035, + "column": 1, + "source_line": "#define STBDS_SIPHASH_D_ROUNDS 4" + } + }, + { + "name": "STBDS_SIPHASH_C_ROUNDS", + "value": "1", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1040, + "column": 1, + "source_line": "#define STBDS_SIPHASH_C_ROUNDS 1" + } + }, + { + "name": "STBDS_SIPHASH_D_ROUNDS", + "value": "1", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1043, + "column": 1, + "source_line": "#define STBDS_SIPHASH_D_ROUNDS 1" + } + }, + { + "name": "STBDS_SIPROUND", + "value": "do { v0 += v1; v1 = STBDS_ROTATE_LEFT(v1, 13); v1 ^= v0; v0 = STBDS_ROTATE_LEFT(v0,STBDS_SIZE_T_BITS/2); v2 += v3; v3 = STBDS_ROTATE_LEFT(v3, 16); v3 ^= v2; v2 += v1; v1 = STBDS_ROTATE_LEFT(v1, 17); v1 ^= v2; v2 = STBDS_ROTATE_LEFT(v2,STBDS_SIZE_T_BITS/2); v0 += v3; v3 = STBDS_ROTATE_LEFT(v3, 21); v3 ^= v0; } while (0)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1073, + "column": 3, + "source_line": " #define STBDS_SIPROUND() \\" + } + }, + { + "name": "STBDS_HASH_TO_ARR", + "value": "((char*) (x) - (elemsize))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1211, + "column": 1, + "source_line": "#define STBDS_HASH_TO_ARR(x,elemsize) ((char*) (x) - (elemsize))" + } + }, + { + "name": "STBDS_ARR_TO_HASH", + "value": "((char*) (x) + (elemsize))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1212, + "column": 1, + "source_line": "#define STBDS_ARR_TO_HASH(x,elemsize) ((char*) (x) + (elemsize))" + } + }, + { + "name": "stbds_hash_table", + "value": "((stbds_hash_index *) stbds_header(a)->hash_table)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1214, + "column": 1, + "source_line": "#define stbds_hash_table(a) ((stbds_hash_index *) stbds_header(a)->hash_table)" + } + }, + { + "name": "STBDS_STRING_ARENA_BLOCKSIZE_MIN", + "value": "512u", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1551, + "column": 1, + "source_line": "#define STBDS_STRING_ARENA_BLOCKSIZE_MIN 512u" + } + }, + { + "name": "STBDS_STRING_ARENA_BLOCKSIZE_MAX", + "value": "(1u<<20)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1554, + "column": 1, + "source_line": "#define STBDS_STRING_ARENA_BLOCKSIZE_MAX (1u<<20)" + } + }, + { + "name": "STBDS_ASSERT", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1627, + "column": 1, + "source_line": "#undef STBDS_ASSERT" + } + }, + { + "name": "STBDS_ASSERT", + "value": "assert", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1630, + "column": 1, + "source_line": "#define STBDS_ASSERT assert" + } + } + ], + "includes": [ + { + "target": "stddef.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 394, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "string.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 395, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "stdlib.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 459, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "assert.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 733, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "string.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 734, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "stdio.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1625, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "assert.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1631, + "column": 1, + "source_line": "#include " + } + } + ], + "raw_directives": [ + { + "directive": "ifdef", + "argument": "STBDS_UNIT_TESTS", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 387, + "column": 1, + "source_line": "#ifdef STBDS_UNIT_TESTS" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 389, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "INCLUDE_STB_DS_H", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 391, + "column": 1, + "source_line": "#ifndef INCLUDE_STB_DS_H" + } + }, + { + "directive": "ifndef", + "argument": "STBDS_NO_SHORT_NAMES", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 397, + "column": 1, + "source_line": "#ifndef STBDS_NO_SHORT_NAMES" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 453, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "defined(STBDS_REALLOC) && !defined(STBDS_FREE) || !defined(STBDS_REALLOC) && defined(STBDS_FREE)", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 455, + "column": 1, + "source_line": "#if defined(STBDS_REALLOC) && !defined(STBDS_FREE) || !defined(STBDS_REALLOC) && defined(STBDS_FREE)" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 457, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "!defined(STBDS_REALLOC) && !defined(STBDS_FREE)", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 458, + "column": 1, + "source_line": "#if !defined(STBDS_REALLOC) && !defined(STBDS_FREE)" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 462, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "_MSC_VER", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 464, + "column": 1, + "source_line": "#ifdef _MSC_VER" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 466, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 468, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "__cplusplus", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 470, + "column": 1, + "source_line": "#ifdef __cplusplus" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 472, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "__cplusplus", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 504, + "column": 1, + "source_line": "#ifdef __cplusplus" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 506, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "defined(__GNUC__) || defined(__clang__)", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 508, + "column": 1, + "source_line": "#if defined(__GNUC__) || defined(__clang__)" + } + }, + { + "directive": "ifdef", + "argument": "__cplusplus", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 510, + "column": 1, + "source_line": "#ifdef __cplusplus" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 512, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 513, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "!defined(__cplusplus)", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 515, + "column": 1, + "source_line": "#if !defined(__cplusplus)" + } + }, + { + "directive": "if", + "argument": "defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 516, + "column": 1, + "source_line": "#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 518, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 519, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "defined(STBDS_HAS_LITERAL_ARRAY) && defined(STBDS_HAS_TYPEOF)", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 522, + "column": 1, + "source_line": "#if defined(STBDS_HAS_LITERAL_ARRAY) && defined(STBDS_HAS_TYPEOF)" + } + }, + { + "directive": "if", + "argument": "__clang__", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 523, + "column": 3, + "source_line": " #if __clang__" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 525, + "column": 3, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 527, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 528, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 530, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "__cplusplus", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 690, + "column": 1, + "source_line": "#ifdef __cplusplus" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 714, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 722, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 724, + "column": 1, + "source_line": "#endif // INCLUDE_STB_DS_H" + } + }, + { + "directive": "ifdef", + "argument": "STB_DS_IMPLEMENTATION", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 732, + "column": 1, + "source_line": "#ifdef STB_DS_IMPLEMENTATION" + } + }, + { + "directive": "ifndef", + "argument": "STBDS_ASSERT", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 736, + "column": 1, + "source_line": "#ifndef STBDS_ASSERT" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 739, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBDS_STATISTICS", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 741, + "column": 1, + "source_line": "#ifdef STBDS_STATISTICS" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 751, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 753, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBDS_INTERNAL_SMALL_BUCKET", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 809, + "column": 1, + "source_line": "#ifdef STBDS_INTERNAL_SMALL_BUCKET" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 811, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 813, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBDS_INTERNAL_BUCKET_START", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 868, + "column": 3, + "source_line": " #ifdef STBDS_INTERNAL_BUCKET_START" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 870, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "0", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 894, + "column": 3, + "source_line": " #if 0 // A1" + } + }, + { + "directive": "elif", + "argument": "1", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 898, + "column": 3, + "source_line": " #elif 1 // A2" + } + }, + { + "directive": "elif", + "argument": "0", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 908, + "column": 3, + "source_line": " #elif 0 // B1" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 912, + "column": 3, + "source_line": " #else // C1" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 916, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "STBDS_SIPHASH_2_4", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1033, + "column": 1, + "source_line": "#ifdef STBDS_SIPHASH_2_4" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1037, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBDS_SIPHASH_C_ROUNDS", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1039, + "column": 1, + "source_line": "#ifndef STBDS_SIPHASH_C_ROUNDS" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1041, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBDS_SIPHASH_D_ROUNDS", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1042, + "column": 1, + "source_line": "#ifndef STBDS_SIPHASH_D_ROUNDS" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1044, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "_MSC_VER", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1046, + "column": 1, + "source_line": "#ifdef _MSC_VER" + } + }, + { + "directive": "pragma", + "argument": "warning(push)", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1047, + "column": 1, + "source_line": "#pragma warning(push)" + } + }, + { + "directive": "pragma", + "argument": "warning(disable:4127)", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1048, + "column": 1, + "source_line": "#pragma warning(disable:4127) // conditional expression is constant, for do..while(0) and sizeof()==" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1049, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBDS_TEST_SIPHASH_2_4", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1065, + "column": 3, + "source_line": " #ifdef STBDS_TEST_SIPHASH_2_4" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1071, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "STBDS_SIPHASH_2_4", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1109, + "column": 1, + "source_line": "#ifdef STBDS_SIPHASH_2_4" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1111, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1113, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBDS_SIPHASH_2_4", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1118, + "column": 1, + "source_line": "#ifdef STBDS_SIPHASH_2_4" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1120, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "if", + "argument": "0", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1125, + "column": 5, + "source_line": " #if 0" + } + }, + { + "directive": "elif", + "argument": "1", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1136, + "column": 5, + "source_line": " #elif 1" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1147, + "column": 5, + "source_line": " #else // HASH32-C - Murmur3" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1161, + "column": 5, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1196, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "_MSC_VER", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1198, + "column": 1, + "source_line": "#ifdef _MSC_VER" + } + }, + { + "directive": "pragma", + "argument": "warning(pop)", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1199, + "column": 1, + "source_line": "#pragma warning(pop)" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1200, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBDS_STRING_ARENA_BLOCKSIZE_MIN", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1550, + "column": 1, + "source_line": "#ifndef STBDS_STRING_ARENA_BLOCKSIZE_MIN" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1552, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBDS_STRING_ARENA_BLOCKSIZE_MAX", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1553, + "column": 1, + "source_line": "#ifndef STBDS_STRING_ARENA_BLOCKSIZE_MAX" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1555, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1617, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBDS_UNIT_TESTS", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1624, + "column": 1, + "source_line": "#ifdef STBDS_UNIT_TESTS" + } + }, + { + "directive": "ifdef", + "argument": "STBDS_ASSERT_WAS_UNDEFINED", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1626, + "column": 1, + "source_line": "#ifdef STBDS_ASSERT_WAS_UNDEFINED" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1628, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBDS_ASSERT", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1629, + "column": 1, + "source_line": "#ifndef STBDS_ASSERT" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1632, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "defined(_WIN32) && defined(__STDC_WANT_SECURE_LIB__)", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1640, + "column": 1, + "source_line": "#if defined(_WIN32) && defined(__STDC_WANT_SECURE_LIB__)" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1642, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1644, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "defined(_MSC_VER) && _MSC_VER <= 1200 && defined(__cplusplus)", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1650, + "column": 1, + "source_line": "#if defined(_MSC_VER) && _MSC_VER <= 1200 && defined(__cplusplus)" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1653, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "if", + "argument": "defined(__clang__) || defined(__GNUC__)", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1725, + "column": 3, + "source_line": " #if defined(__clang__) || defined(__GNUC__)" + } + }, + { + "directive": "ifndef", + "argument": "__cplusplus", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1726, + "column": 3, + "source_line": " #ifndef __cplusplus" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1734, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1735, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1850, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1852, + "column": 1, + "source_line": "#endif" + } + } + ], + "macro_dependencies": [ + { + "name": "stbds_shmode_func_wrapper", + "context": "declaration", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 711, + "column": 1, + "source_line": "template static T * stbds_shmode_func_wrapper(T *, size_t elemsize, int mode) {" + }, + "source_text": "template static T * stbds_shmode_func_wrapper(T *, size_t elemsize, int mode)" + } + ], + "diagnostics": [ + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBDS_REALLOC' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 460, + "column": 1, + "source_line": "#define STBDS_REALLOC(c,p,s) realloc(p,s)" + }, + "unit_kind": "macro", + "unit_name": "STBDS_REALLOC" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBDS_FREE' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 461, + "column": 1, + "source_line": "#define STBDS_FREE(c,p) free(p)" + }, + "unit_kind": "macro", + "unit_name": "STBDS_FREE" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBDS_NOTUSED' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 465, + "column": 1, + "source_line": "#define STBDS_NOTUSED(v) (void)(v)" + }, + "unit_kind": "macro", + "unit_name": "STBDS_NOTUSED" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBDS_NOTUSED' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 467, + "column": 1, + "source_line": "#define STBDS_NOTUSED(v) (void)sizeof(v)" + }, + "unit_kind": "macro", + "unit_name": "STBDS_NOTUSED" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBDS_ADDRESSOF' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 524, + "column": 3, + "source_line": " #define STBDS_ADDRESSOF(typevar, value) ((__typeof__(typevar)[1]){value}) // literal array decays to pointer to value" + }, + "unit_kind": "macro", + "unit_name": "STBDS_ADDRESSOF" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBDS_ADDRESSOF' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 526, + "column": 3, + "source_line": " #define STBDS_ADDRESSOF(typevar, value) ((typeof(typevar)[1]){value}) // literal array decays to pointer to value" + }, + "unit_kind": "macro", + "unit_name": "STBDS_ADDRESSOF" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBDS_ADDRESSOF' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 529, + "column": 1, + "source_line": "#define STBDS_ADDRESSOF(typevar, value) &(value)" + }, + "unit_kind": "macro", + "unit_name": "STBDS_ADDRESSOF" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBDS_OFFSETOF' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 532, + "column": 1, + "source_line": "#define STBDS_OFFSETOF(var,field) ((char *) &(var)->field - (char *) (var))" + }, + "unit_kind": "macro", + "unit_name": "STBDS_OFFSETOF" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_header' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 534, + "column": 1, + "source_line": "#define stbds_header(t) ((stbds_array_header *) (t) - 1)" + }, + "unit_kind": "macro", + "unit_name": "stbds_header" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_temp' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 535, + "column": 1, + "source_line": "#define stbds_temp(t) stbds_header(t)->temp" + }, + "unit_kind": "macro", + "unit_name": "stbds_temp" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_temp_key' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 536, + "column": 1, + "source_line": "#define stbds_temp_key(t) (*(char **) stbds_header(t)->hash_table)" + }, + "unit_kind": "macro", + "unit_name": "stbds_temp_key" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_arrsetcap' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 538, + "column": 1, + "source_line": "#define stbds_arrsetcap(a,n) (stbds_arrgrow(a,0,n))" + }, + "unit_kind": "macro", + "unit_name": "stbds_arrsetcap" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_arrsetlen' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 539, + "column": 1, + "source_line": "#define stbds_arrsetlen(a,n) ((stbds_arrcap(a) < (size_t) (n) ? stbds_arrsetcap((a),(size_t)(n)),0 : 0), (a) ? stbds_header(a)->length = (size_t) (n) : 0)" + }, + "unit_kind": "macro", + "unit_name": "stbds_arrsetlen" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_arrcap' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 540, + "column": 1, + "source_line": "#define stbds_arrcap(a) ((a) ? stbds_header(a)->capacity : 0)" + }, + "unit_kind": "macro", + "unit_name": "stbds_arrcap" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_arrlen' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 541, + "column": 1, + "source_line": "#define stbds_arrlen(a) ((a) ? (ptrdiff_t) stbds_header(a)->length : 0)" + }, + "unit_kind": "macro", + "unit_name": "stbds_arrlen" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_arrlenu' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 542, + "column": 1, + "source_line": "#define stbds_arrlenu(a) ((a) ? stbds_header(a)->length : 0)" + }, + "unit_kind": "macro", + "unit_name": "stbds_arrlenu" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_arrput' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 543, + "column": 1, + "source_line": "#define stbds_arrput(a,v) (stbds_arrmaybegrow(a,1), (a)[stbds_header(a)->length++] = (v))" + }, + "unit_kind": "macro", + "unit_name": "stbds_arrput" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_arrpop' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 545, + "column": 1, + "source_line": "#define stbds_arrpop(a) (stbds_header(a)->length--, (a)[stbds_header(a)->length])" + }, + "unit_kind": "macro", + "unit_name": "stbds_arrpop" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_arraddn' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 546, + "column": 1, + "source_line": "#define stbds_arraddn(a,n) ((void)(stbds_arraddnindex(a, n))) // deprecated, use one of the following instead:" + }, + "unit_kind": "macro", + "unit_name": "stbds_arraddn" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_arraddnptr' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 547, + "column": 1, + "source_line": "#define stbds_arraddnptr(a,n) (stbds_arrmaybegrow(a,n), (n) ? (stbds_header(a)->length += (n), &(a)[stbds_header(a)->length-(n)]) : (a))" + }, + "unit_kind": "macro", + "unit_name": "stbds_arraddnptr" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_arrlast' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 550, + "column": 1, + "source_line": "#define stbds_arrlast(a) ((a)[stbds_header(a)->length-1])" + }, + "unit_kind": "macro", + "unit_name": "stbds_arrlast" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_arrfree' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 551, + "column": 1, + "source_line": "#define stbds_arrfree(a) ((void) ((a) ? STBDS_FREE(NULL,stbds_header(a)) : (void)0), (a)=NULL)" + }, + "unit_kind": "macro", + "unit_name": "stbds_arrfree" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_arrdel' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 552, + "column": 1, + "source_line": "#define stbds_arrdel(a,i) stbds_arrdeln(a,i,1)" + }, + "unit_kind": "macro", + "unit_name": "stbds_arrdel" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_arrdeln' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 553, + "column": 1, + "source_line": "#define stbds_arrdeln(a,i,n) (memmove(&(a)[i], &(a)[(i)+(n)], sizeof *(a) * (stbds_header(a)->length-(n)-(i))), stbds_header(a)->length -= (n))" + }, + "unit_kind": "macro", + "unit_name": "stbds_arrdeln" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_arrdelswap' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 554, + "column": 1, + "source_line": "#define stbds_arrdelswap(a,i) ((a)[i] = stbds_arrlast(a), stbds_header(a)->length -= 1)" + }, + "unit_kind": "macro", + "unit_name": "stbds_arrdelswap" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_arrinsn' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 555, + "column": 1, + "source_line": "#define stbds_arrinsn(a,i,n) (stbds_arraddn((a),(n)), memmove(&(a)[(i)+(n)], &(a)[i], sizeof *(a) * (stbds_header(a)->length-(n)-(i))))" + }, + "unit_kind": "macro", + "unit_name": "stbds_arrinsn" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_arrins' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 556, + "column": 1, + "source_line": "#define stbds_arrins(a,i,v) (stbds_arrinsn((a),(i),1), (a)[i]=(v))" + }, + "unit_kind": "macro", + "unit_name": "stbds_arrins" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_arrmaybegrow' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 558, + "column": 1, + "source_line": "#define stbds_arrmaybegrow(a,n) ((!(a) || stbds_header(a)->length + (n) > stbds_header(a)->capacity) \\" + }, + "unit_kind": "macro", + "unit_name": "stbds_arrmaybegrow" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_arrgrow' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 561, + "column": 1, + "source_line": "#define stbds_arrgrow(a,b,c) ((a) = stbds_arrgrowf_wrapper((a), sizeof *(a), (b), (c)))" + }, + "unit_kind": "macro", + "unit_name": "stbds_arrgrow" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_hmput' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 563, + "column": 1, + "source_line": "#define stbds_hmput(t, k, v) \\" + }, + "unit_kind": "macro", + "unit_name": "stbds_hmput" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_hmputs' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 568, + "column": 1, + "source_line": "#define stbds_hmputs(t, s) \\" + }, + "unit_kind": "macro", + "unit_name": "stbds_hmputs" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_hmgeti' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 572, + "column": 1, + "source_line": "#define stbds_hmgeti(t,k) \\" + }, + "unit_kind": "macro", + "unit_name": "stbds_hmgeti" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_hmgeti_ts' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 576, + "column": 1, + "source_line": "#define stbds_hmgeti_ts(t,k,temp) \\" + }, + "unit_kind": "macro", + "unit_name": "stbds_hmgeti_ts" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_hmgetp' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 580, + "column": 1, + "source_line": "#define stbds_hmgetp(t, k) \\" + }, + "unit_kind": "macro", + "unit_name": "stbds_hmgetp" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_hmgetp_ts' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 583, + "column": 1, + "source_line": "#define stbds_hmgetp_ts(t, k, temp) \\" + }, + "unit_kind": "macro", + "unit_name": "stbds_hmgetp_ts" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_hmdel' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 586, + "column": 1, + "source_line": "#define stbds_hmdel(t,k) \\" + }, + "unit_kind": "macro", + "unit_name": "stbds_hmdel" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_hmdefault' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 589, + "column": 1, + "source_line": "#define stbds_hmdefault(t, v) \\" + }, + "unit_kind": "macro", + "unit_name": "stbds_hmdefault" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_hmdefaults' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 592, + "column": 1, + "source_line": "#define stbds_hmdefaults(t, s) \\" + }, + "unit_kind": "macro", + "unit_name": "stbds_hmdefaults" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_hmfree' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 595, + "column": 1, + "source_line": "#define stbds_hmfree(p) \\" + }, + "unit_kind": "macro", + "unit_name": "stbds_hmfree" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_hmgets' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 598, + "column": 1, + "source_line": "#define stbds_hmgets(t, k) (*stbds_hmgetp(t,k))" + }, + "unit_kind": "macro", + "unit_name": "stbds_hmgets" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_hmget' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 599, + "column": 1, + "source_line": "#define stbds_hmget(t, k) (stbds_hmgetp(t,k)->value)" + }, + "unit_kind": "macro", + "unit_name": "stbds_hmget" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_hmget_ts' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 600, + "column": 1, + "source_line": "#define stbds_hmget_ts(t, k, temp) (stbds_hmgetp_ts(t,k,temp)->value)" + }, + "unit_kind": "macro", + "unit_name": "stbds_hmget_ts" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_hmlen' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 601, + "column": 1, + "source_line": "#define stbds_hmlen(t) ((t) ? (ptrdiff_t) stbds_header((t)-1)->length-1 : 0)" + }, + "unit_kind": "macro", + "unit_name": "stbds_hmlen" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_hmlenu' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 602, + "column": 1, + "source_line": "#define stbds_hmlenu(t) ((t) ? stbds_header((t)-1)->length-1 : 0)" + }, + "unit_kind": "macro", + "unit_name": "stbds_hmlenu" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_hmgetp_null' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 603, + "column": 1, + "source_line": "#define stbds_hmgetp_null(t,k) (stbds_hmgeti(t,k) == -1 ? NULL : &(t)[stbds_temp((t)-1)])" + }, + "unit_kind": "macro", + "unit_name": "stbds_hmgetp_null" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_shput' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 605, + "column": 1, + "source_line": "#define stbds_shput(t, k, v) \\" + }, + "unit_kind": "macro", + "unit_name": "stbds_shput" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_shputi' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 609, + "column": 1, + "source_line": "#define stbds_shputi(t, k, v) \\" + }, + "unit_kind": "macro", + "unit_name": "stbds_shputi" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_shputs' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 613, + "column": 1, + "source_line": "#define stbds_shputs(t, s) \\" + }, + "unit_kind": "macro", + "unit_name": "stbds_shputs" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_pshput' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 618, + "column": 1, + "source_line": "#define stbds_pshput(t, p) \\" + }, + "unit_kind": "macro", + "unit_name": "stbds_pshput" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_shgeti' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 622, + "column": 1, + "source_line": "#define stbds_shgeti(t,k) \\" + }, + "unit_kind": "macro", + "unit_name": "stbds_shgeti" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_pshgeti' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 626, + "column": 1, + "source_line": "#define stbds_pshgeti(t,k) \\" + }, + "unit_kind": "macro", + "unit_name": "stbds_pshgeti" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_shgetp' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 630, + "column": 1, + "source_line": "#define stbds_shgetp(t, k) \\" + }, + "unit_kind": "macro", + "unit_name": "stbds_shgetp" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_pshget' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 633, + "column": 1, + "source_line": "#define stbds_pshget(t, k) \\" + }, + "unit_kind": "macro", + "unit_name": "stbds_pshget" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_shdel' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 636, + "column": 1, + "source_line": "#define stbds_shdel(t,k) \\" + }, + "unit_kind": "macro", + "unit_name": "stbds_shdel" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_pshdel' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 638, + "column": 1, + "source_line": "#define stbds_pshdel(t,k) \\" + }, + "unit_kind": "macro", + "unit_name": "stbds_pshdel" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_sh_new_arena' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 641, + "column": 1, + "source_line": "#define stbds_sh_new_arena(t) \\" + }, + "unit_kind": "macro", + "unit_name": "stbds_sh_new_arena" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_sh_new_strdup' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 643, + "column": 1, + "source_line": "#define stbds_sh_new_strdup(t) \\" + }, + "unit_kind": "macro", + "unit_name": "stbds_sh_new_strdup" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_shdefault' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 646, + "column": 1, + "source_line": "#define stbds_shdefault(t, v) stbds_hmdefault(t,v)" + }, + "unit_kind": "macro", + "unit_name": "stbds_shdefault" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_shdefaults' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 647, + "column": 1, + "source_line": "#define stbds_shdefaults(t, s) stbds_hmdefaults(t,s)" + }, + "unit_kind": "macro", + "unit_name": "stbds_shdefaults" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_shgets' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 652, + "column": 1, + "source_line": "#define stbds_shgets(t, k) (*stbds_shgetp(t,k))" + }, + "unit_kind": "macro", + "unit_name": "stbds_shgets" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_shget' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 653, + "column": 1, + "source_line": "#define stbds_shget(t, k) (stbds_shgetp(t,k)->value)" + }, + "unit_kind": "macro", + "unit_name": "stbds_shget" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_shgetp_null' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 654, + "column": 1, + "source_line": "#define stbds_shgetp_null(t,k) (stbds_shgeti(t,k) == -1 ? NULL : &(t)[stbds_temp((t)-1)])" + }, + "unit_kind": "macro", + "unit_name": "stbds_shgetp_null" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_shmode_func_wrapper' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 721, + "column": 1, + "source_line": "#define stbds_shmode_func_wrapper(t,e,m) stbds_shmode_func(e,m)" + }, + "unit_kind": "macro", + "unit_name": "stbds_shmode_func_wrapper" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBDS_ASSERT' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 738, + "column": 1, + "source_line": "#define STBDS_ASSERT(x) ((void) 0)" + }, + "unit_kind": "macro", + "unit_name": "STBDS_ASSERT" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBDS_STATS' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 742, + "column": 1, + "source_line": "#define STBDS_STATS(x) x" + }, + "unit_kind": "macro", + "unit_name": "STBDS_STATS" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBDS_STATS' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 752, + "column": 1, + "source_line": "#define STBDS_STATS(x)" + }, + "unit_kind": "macro", + "unit_name": "STBDS_STATS" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBDS_ALIGN_FWD' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 819, + "column": 1, + "source_line": "#define STBDS_ALIGN_FWD(n,a) (((n) + (a) - 1) & ~((a)-1))" + }, + "unit_kind": "macro", + "unit_name": "STBDS_ALIGN_FWD" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBDS_INDEX_IN_USE' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 844, + "column": 1, + "source_line": "#define STBDS_INDEX_IN_USE(x) ((x) >= 0)" + }, + "unit_kind": "macro", + "unit_name": "STBDS_INDEX_IN_USE" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_load_32_or_64' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 856, + "column": 1, + "source_line": "#define stbds_load_32_or_64(var, temp, v32, v64_hi, v64_lo) \\" + }, + "unit_kind": "macro", + "unit_name": "stbds_load_32_or_64" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBDS_ROTATE_LEFT' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 1013, + "column": 1, + "source_line": "#define STBDS_ROTATE_LEFT(val, n) (((val) << (n)) | ((val) >> (STBDS_SIZE_T_BITS - (n))))" + }, + "unit_kind": "macro", + "unit_name": "STBDS_ROTATE_LEFT" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBDS_ROTATE_RIGHT' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 1014, + "column": 1, + "source_line": "#define STBDS_ROTATE_RIGHT(val, n) (((val) >> (n)) | ((val) << (STBDS_SIZE_T_BITS - (n))))" + }, + "unit_kind": "macro", + "unit_name": "STBDS_ROTATE_RIGHT" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBDS_SIPROUND' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 1073, + "column": 3, + "source_line": " #define STBDS_SIPROUND() \\" + }, + "unit_kind": "macro", + "unit_name": "STBDS_SIPROUND" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBDS_HASH_TO_ARR' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 1211, + "column": 1, + "source_line": "#define STBDS_HASH_TO_ARR(x,elemsize) ((char*) (x) - (elemsize))" + }, + "unit_kind": "macro", + "unit_name": "STBDS_HASH_TO_ARR" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBDS_ARR_TO_HASH' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 1212, + "column": 1, + "source_line": "#define STBDS_ARR_TO_HASH(x,elemsize) ((char*) (x) + (elemsize))" + }, + "unit_kind": "macro", + "unit_name": "STBDS_ARR_TO_HASH" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_hash_table' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 1214, + "column": 1, + "source_line": "#define stbds_hash_table(a) ((stbds_hash_index *) stbds_header(a)->hash_table)" + }, + "unit_kind": "macro", + "unit_name": "stbds_hash_table" + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '\"C\"'.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 471, + "column": 1, + "source_line": "extern \"C\" {" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: ' static T * stbds_arrgrowf_wrapper(T *a, size_t elemsize, size_t addlen, size_t min_cap)'.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 693, + "column": 1, + "source_line": "template static T * stbds_arrgrowf_wrapper(T *a, size_t elemsize, size_t addlen, size_t min_cap) {" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: ' static T * stbds_hmget_key_wrapper(T *a, size_t elemsize, void *key, size_t keysize, int mode)'.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 696, + "column": 1, + "source_line": "template static T * stbds_hmget_key_wrapper(T *a, size_t elemsize, void *key, size_t keysize, int mode) {" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: ' static T * stbds_hmget_key_ts_wrapper(T *a, size_t elemsize, void *key, size_t keysize, ptrdiff_t *temp, int mode)'.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 699, + "column": 1, + "source_line": "template static T * stbds_hmget_key_ts_wrapper(T *a, size_t elemsize, void *key, size_t keysize, ptrdiff_t *temp, int mode) {" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: ' static T * stbds_hmput_default_wrapper(T *a, size_t elemsize)'.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 702, + "column": 1, + "source_line": "template static T * stbds_hmput_default_wrapper(T *a, size_t elemsize) {" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: ' static T * stbds_hmput_key_wrapper(T *a, size_t elemsize, void *key, size_t keysize, int mode)'.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 705, + "column": 1, + "source_line": "template static T * stbds_hmput_key_wrapper(T *a, size_t elemsize, void *key, size_t keysize, int mode) {" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: ' static T * stbds_hmdel_key_wrapper(T *a, size_t elemsize, void *key, size_t keysize, size_t keyoffset, int mode)'.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 708, + "column": 1, + "source_line": "template static T * stbds_hmdel_key_wrapper(T *a, size_t elemsize, void *key, size_t keysize, size_t keyoffset, int mode){" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'stbds_shmode_func_wrapper'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 711, + "column": 1, + "source_line": "template static T * stbds_shmode_func_wrapper(T *, size_t elemsize, int mode) {" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbds_shmode_func_wrapper" + } + ] + } + }, + "functions": { + "stbds_arrgrowf": { + "name": "stbds_arrgrowf", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "elemsize", + "type": { + "reference": "size_t" + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "addlen", + "type": { + "reference": "size_t" + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "min_cap", + "type": { + "reference": "size_t" + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 762, + "column": 1, + "source_line": "void *stbds_arrgrowf(void *a, size_t elemsize, size_t addlen, size_t min_cap)" + }, + "start": { + "filename": "stb/stb_ds.h", + "line": 762, + "column": 1, + "source_line": "void *stbds_arrgrowf(void *a, size_t elemsize, size_t addlen, size_t min_cap)" + }, + "end": { + "filename": "stb/stb_ds.h", + "line": 798, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbds_arrfreef": { + "name": "stbds_arrfreef", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 800, + "column": 1, + "source_line": "void stbds_arrfreef(void *a)" + }, + "start": { + "filename": "stb/stb_ds.h", + "line": 800, + "column": 1, + "source_line": "void stbds_arrfreef(void *a)" + }, + "end": { + "filename": "stb/stb_ds.h", + "line": 803, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbds_rand_seed": { + "name": "stbds_rand_seed", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "seed", + "type": { + "reference": "size_t" + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 851, + "column": 1, + "source_line": "void stbds_rand_seed(size_t seed)" + }, + "start": { + "filename": "stb/stb_ds.h", + "line": 851, + "column": 1, + "source_line": "void stbds_rand_seed(size_t seed)" + }, + "end": { + "filename": "stb/stb_ds.h", + "line": 854, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbds_probe_position": { + "name": "stbds_probe_position", + "result_type": { + "reference": "size_t" + }, + "parameters": [ + { + "name": "hash", + "type": { + "reference": "size_t" + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "slot_count", + "type": { + "reference": "size_t" + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "slot_log2", + "type": { + "reference": "size_t" + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 863, + "column": 1, + "source_line": "static size_t stbds_probe_position(size_t hash, size_t slot_count, size_t slot_log2)" + }, + "start": { + "filename": "stb/stb_ds.h", + "line": 863, + "column": 1, + "source_line": "static size_t stbds_probe_position(size_t hash, size_t slot_count, size_t slot_log2)" + }, + "end": { + "filename": "stb/stb_ds.h", + "line": 872, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbds_log2": { + "name": "stbds_log2", + "result_type": { + "reference": "size_t" + }, + "parameters": [ + { + "name": "slot_count", + "type": { + "reference": "size_t" + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 874, + "column": 1, + "source_line": "static size_t stbds_log2(size_t slot_count)" + }, + "start": { + "filename": "stb/stb_ds.h", + "line": 874, + "column": 1, + "source_line": "static size_t stbds_log2(size_t slot_count)" + }, + "end": { + "filename": "stb/stb_ds.h", + "line": 882, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbds_make_hash_index": { + "name": "stbds_make_hash_index", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbds_hash_index", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbds_hash_index" + } + ] + }, + "parameters": [ + { + "name": "slot_count", + "type": { + "reference": "size_t" + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ot", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbds_hash_index *ot", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbds_hash_index" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbds_hash_index *ot", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbds_hash_index" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 884, + "column": 1, + "source_line": "static stbds_hash_index *stbds_make_hash_index(size_t slot_count, stbds_hash_index *ot)" + }, + "start": { + "filename": "stb/stb_ds.h", + "line": 884, + "column": 1, + "source_line": "static stbds_hash_index *stbds_make_hash_index(size_t slot_count, stbds_hash_index *ot)" + }, + "end": { + "filename": "stb/stb_ds.h", + "line": 1011, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbds_hash_string": { + "name": "stbds_hash_string", + "result_type": { + "reference": "size_t" + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "seed", + "type": { + "reference": "size_t" + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1016, + "column": 1, + "source_line": "size_t stbds_hash_string(char *str, size_t seed)" + }, + "start": { + "filename": "stb/stb_ds.h", + "line": 1016, + "column": 1, + "source_line": "size_t stbds_hash_string(char *str, size_t seed)" + }, + "end": { + "filename": "stb/stb_ds.h", + "line": 1031, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbds_siphash_bytes": { + "name": "stbds_siphash_bytes", + "result_type": { + "reference": "size_t" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "reference": "size_t" + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "seed", + "type": { + "reference": "size_t" + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1051, + "column": 1, + "source_line": "static size_t stbds_siphash_bytes(void *p, size_t len, size_t seed)" + }, + "start": { + "filename": "stb/stb_ds.h", + "line": 1051, + "column": 1, + "source_line": "static size_t stbds_siphash_bytes(void *p, size_t len, size_t seed)" + }, + "end": { + "filename": "stb/stb_ds.h", + "line": 1114, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbds_hash_bytes": { + "name": "stbds_hash_bytes", + "result_type": { + "reference": "size_t" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "reference": "size_t" + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "seed", + "type": { + "reference": "size_t" + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1116, + "column": 1, + "source_line": "size_t stbds_hash_bytes(void *p, size_t len, size_t seed)" + }, + "start": { + "filename": "stb/stb_ds.h", + "line": 1116, + "column": 1, + "source_line": "size_t stbds_hash_bytes(void *p, size_t len, size_t seed)" + }, + "end": { + "filename": "stb/stb_ds.h", + "line": 1197, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbds_is_key_equal": { + "name": "stbds_is_key_equal", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "elemsize", + "type": { + "reference": "size_t" + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "key", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *key", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *key", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "keysize", + "type": { + "reference": "size_t" + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "keyoffset", + "type": { + "reference": "size_t" + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mode", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mode" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mode" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "i", + "type": { + "reference": "size_t" + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1203, + "column": 1, + "source_line": "static int stbds_is_key_equal(void *a, size_t elemsize, void *key, size_t keysize, size_t keyoffset, int mode, size_t i)" + }, + "start": { + "filename": "stb/stb_ds.h", + "line": 1203, + "column": 1, + "source_line": "static int stbds_is_key_equal(void *a, size_t elemsize, void *key, size_t keysize, size_t keyoffset, int mode, size_t i)" + }, + "end": { + "filename": "stb/stb_ds.h", + "line": 1209, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbds_hmfree_func": { + "name": "stbds_hmfree_func", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "elemsize", + "type": { + "reference": "size_t" + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1216, + "column": 1, + "source_line": "void stbds_hmfree_func(void *a, size_t elemsize)" + }, + "start": { + "filename": "stb/stb_ds.h", + "line": 1216, + "column": 1, + "source_line": "void stbds_hmfree_func(void *a, size_t elemsize)" + }, + "end": { + "filename": "stb/stb_ds.h", + "line": 1230, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbds_hm_find_slot": { + "name": "stbds_hm_find_slot", + "result_type": { + "reference": "ptrdiff_t" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "elemsize", + "type": { + "reference": "size_t" + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "key", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *key", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *key", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "keysize", + "type": { + "reference": "size_t" + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "keyoffset", + "type": { + "reference": "size_t" + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mode", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mode" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mode" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1232, + "column": 1, + "source_line": "static ptrdiff_t stbds_hm_find_slot(void *a, size_t elemsize, void *key, size_t keysize, size_t keyoffset, int mode)" + }, + "start": { + "filename": "stb/stb_ds.h", + "line": 1232, + "column": 1, + "source_line": "static ptrdiff_t stbds_hm_find_slot(void *a, size_t elemsize, void *key, size_t keysize, size_t keyoffset, int mode)" + }, + "end": { + "filename": "stb/stb_ds.h", + "line": 1279, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbds_hmget_key_ts": { + "name": "stbds_hmget_key_ts", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "elemsize", + "type": { + "reference": "size_t" + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "key", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *key", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *key", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "keysize", + "type": { + "reference": "size_t" + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "temp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "ptrdiff_t *temp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "ptrdiff_t" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "ptrdiff_t *temp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "ptrdiff_t" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mode", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mode" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mode" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1281, + "column": 1, + "source_line": "void * stbds_hmget_key_ts(void *a, size_t elemsize, void *key, size_t keysize, ptrdiff_t *temp, int mode)" + }, + "start": { + "filename": "stb/stb_ds.h", + "line": 1281, + "column": 1, + "source_line": "void * stbds_hmget_key_ts(void *a, size_t elemsize, void *key, size_t keysize, ptrdiff_t *temp, int mode)" + }, + "end": { + "filename": "stb/stb_ds.h", + "line": 1310, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbds_hmget_key": { + "name": "stbds_hmget_key", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "elemsize", + "type": { + "reference": "size_t" + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "key", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *key", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *key", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "keysize", + "type": { + "reference": "size_t" + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mode", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mode" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mode" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1312, + "column": 1, + "source_line": "void * stbds_hmget_key(void *a, size_t elemsize, void *key, size_t keysize, int mode)" + }, + "start": { + "filename": "stb/stb_ds.h", + "line": 1312, + "column": 1, + "source_line": "void * stbds_hmget_key(void *a, size_t elemsize, void *key, size_t keysize, int mode)" + }, + "end": { + "filename": "stb/stb_ds.h", + "line": 1318, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbds_hmput_default": { + "name": "stbds_hmput_default", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "elemsize", + "type": { + "reference": "size_t" + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1320, + "column": 1, + "source_line": "void * stbds_hmput_default(void *a, size_t elemsize)" + }, + "start": { + "filename": "stb/stb_ds.h", + "line": 1320, + "column": 1, + "source_line": "void * stbds_hmput_default(void *a, size_t elemsize)" + }, + "end": { + "filename": "stb/stb_ds.h", + "line": 1333, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbds_strdup": { + "name": "stbds_strdup", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1540, + "column": 1, + "source_line": "static char *stbds_strdup(char *str)" + }, + "start": { + "filename": "stb/stb_ds.h", + "line": 1540, + "column": 1, + "source_line": "static char *stbds_strdup(char *str)" + }, + "end": { + "filename": "stb/stb_ds.h", + "line": 1548, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_ds.h", + "line": 1335, + "column": 1, + "source_line": "static char *stbds_strdup(char *str);" + } + ] + }, + "stbds_hmput_key": { + "name": "stbds_hmput_key", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "elemsize", + "type": { + "reference": "size_t" + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "key", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *key", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *key", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "keysize", + "type": { + "reference": "size_t" + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mode", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mode" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mode" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1337, + "column": 1, + "source_line": "void *stbds_hmput_key(void *a, size_t elemsize, void *key, size_t keysize, int mode)" + }, + "start": { + "filename": "stb/stb_ds.h", + "line": 1337, + "column": 1, + "source_line": "void *stbds_hmput_key(void *a, size_t elemsize, void *key, size_t keysize, int mode)" + }, + "end": { + "filename": "stb/stb_ds.h", + "line": 1459, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbds_shmode_func": { + "name": "stbds_shmode_func", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "parameters": [ + { + "name": "elemsize", + "type": { + "reference": "size_t" + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mode", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mode" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mode" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1461, + "column": 1, + "source_line": "void * stbds_shmode_func(size_t elemsize, int mode)" + }, + "start": { + "filename": "stb/stb_ds.h", + "line": 1461, + "column": 1, + "source_line": "void * stbds_shmode_func(size_t elemsize, int mode)" + }, + "end": { + "filename": "stb/stb_ds.h", + "line": 1470, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbds_hmdel_key": { + "name": "stbds_hmdel_key", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "elemsize", + "type": { + "reference": "size_t" + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "key", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *key", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *key", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "keysize", + "type": { + "reference": "size_t" + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "keyoffset", + "type": { + "reference": "size_t" + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mode", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mode" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mode" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1472, + "column": 1, + "source_line": "void * stbds_hmdel_key(void *a, size_t elemsize, void *key, size_t keysize, size_t keyoffset, int mode)" + }, + "start": { + "filename": "stb/stb_ds.h", + "line": 1472, + "column": 1, + "source_line": "void * stbds_hmdel_key(void *a, size_t elemsize, void *key, size_t keysize, size_t keyoffset, int mode)" + }, + "end": { + "filename": "stb/stb_ds.h", + "line": 1538, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbds_stralloc": { + "name": "stbds_stralloc", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbds_string_arena *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbds_string_arena" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbds_string_arena *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbds_string_arena" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1557, + "column": 1, + "source_line": "char *stbds_stralloc(stbds_string_arena *a, char *str)" + }, + "start": { + "filename": "stb/stb_ds.h", + "line": 1557, + "column": 1, + "source_line": "char *stbds_stralloc(stbds_string_arena *a, char *str)" + }, + "end": { + "filename": "stb/stb_ds.h", + "line": 1603, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbds_strreset": { + "name": "stbds_strreset", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbds_string_arena *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbds_string_arena" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbds_string_arena *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbds_string_arena" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1605, + "column": 1, + "source_line": "void stbds_strreset(stbds_string_arena *a)" + }, + "start": { + "filename": "stb/stb_ds.h", + "line": 1605, + "column": 1, + "source_line": "void stbds_strreset(stbds_string_arena *a)" + }, + "end": { + "filename": "stb/stb_ds.h", + "line": 1615, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "strkey": { + "name": "strkey", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "parameters": [ + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1638, + "column": 1, + "source_line": "char *strkey(int n)" + }, + "start": { + "filename": "stb/stb_ds.h", + "line": 1638, + "column": 1, + "source_line": "char *strkey(int n)" + }, + "end": { + "filename": "stb/stb_ds.h", + "line": 1646, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbds_unit_tests": { + "name": "stbds_unit_tests", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1648, + "column": 1, + "source_line": "void stbds_unit_tests(void)" + }, + "start": { + "filename": "stb/stb_ds.h", + "line": 1648, + "column": 1, + "source_line": "void stbds_unit_tests(void)" + }, + "end": { + "filename": "stb/stb_ds.h", + "line": 1851, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + } + }, + "structs": { + "stbds_string_block": { + "reference": "struct stbds_string_block" + }, + "stbds_string_arena": { + "reference": "struct stbds_string_arena" + } + }, + "unions": {}, + "enums": {}, + "typedefs": { + "stbds_array_header": { + "reference": "stbds_array_header" + }, + "stbds_string_block": { + "reference": "stbds_string_block" + }, + "stbds_hash_bucket": { + "reference": "stbds_hash_bucket" + }, + "stbds_hash_index": { + "reference": "stbds_hash_index" + }, + "STBDS_SIPHASH_2_4_can_only_be_used_in_64_bit_builds": { + "reference": "STBDS_SIPHASH_2_4_can_only_be_used_in_64_bit_builds" + }, + "stbds_struct": { + "reference": "stbds_struct" + }, + "stbds_struct2": { + "reference": "stbds_struct2" + } + }, + "variables": { + "stbds_array_grow": { + "name": "stbds_array_grow", + "type": { + "reference": "size_t" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 743, + "column": 1, + "source_line": "size_t stbds_array_grow;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + "stbds_hash_grow": { + "name": "stbds_hash_grow", + "type": { + "reference": "size_t" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 744, + "column": 1, + "source_line": "size_t stbds_hash_grow;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + "stbds_hash_shrink": { + "name": "stbds_hash_shrink", + "type": { + "reference": "size_t" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 745, + "column": 1, + "source_line": "size_t stbds_hash_shrink;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + "stbds_hash_rebuild": { + "name": "stbds_hash_rebuild", + "type": { + "reference": "size_t" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 746, + "column": 1, + "source_line": "size_t stbds_hash_rebuild;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + "stbds_hash_probes": { + "name": "stbds_hash_probes", + "type": { + "reference": "size_t" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 747, + "column": 1, + "source_line": "size_t stbds_hash_probes;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + "stbds_hash_alloc": { + "name": "stbds_hash_alloc", + "type": { + "reference": "size_t" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 748, + "column": 1, + "source_line": "size_t stbds_hash_alloc;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + "stbds_rehash_probes": { + "name": "stbds_rehash_probes", + "type": { + "reference": "size_t" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 749, + "column": 1, + "source_line": "size_t stbds_rehash_probes;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + "stbds_rehash_items": { + "name": "stbds_rehash_items", + "type": { + "reference": "size_t" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 750, + "column": 1, + "source_line": "size_t stbds_rehash_items;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + "stbds_hash_seed": { + "name": "stbds_hash_seed", + "type": { + "reference": "size_t" + }, + "storage": [ + "static" + ], + "initializer": { + "source_text": "0x31415926" + }, + "bit_width": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 849, + "column": 1, + "source_line": "static size_t stbds_hash_seed=0x31415926;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + "buffer": { + "name": "buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "static char buffer[256]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "256", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "storage": [ + "static" + ], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1637, + "column": 1, + "source_line": "static char buffer[256];" + }, + "callback_policy": null, + "declaration_locations": [] + } + }, + "macros": { + "_CRT_SECURE_NO_WARNINGS": { + "name": "_CRT_SECURE_NO_WARNINGS", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 388, + "column": 1, + "source_line": "#define _CRT_SECURE_NO_WARNINGS" + } + }, + "INCLUDE_STB_DS_H": { + "name": "INCLUDE_STB_DS_H", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 392, + "column": 1, + "source_line": "#define INCLUDE_STB_DS_H" + } + }, + "arrlen": { + "name": "arrlen", + "value": "stbds_arrlen", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 398, + "column": 1, + "source_line": "#define arrlen stbds_arrlen" + } + }, + "arrlenu": { + "name": "arrlenu", + "value": "stbds_arrlenu", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 399, + "column": 1, + "source_line": "#define arrlenu stbds_arrlenu" + } + }, + "arrput": { + "name": "arrput", + "value": "stbds_arrput", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 400, + "column": 1, + "source_line": "#define arrput stbds_arrput" + } + }, + "arrpush": { + "name": "arrpush", + "value": "stbds_arrput", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 401, + "column": 1, + "source_line": "#define arrpush stbds_arrput" + } + }, + "arrpop": { + "name": "arrpop", + "value": "stbds_arrpop", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 402, + "column": 1, + "source_line": "#define arrpop stbds_arrpop" + } + }, + "arrfree": { + "name": "arrfree", + "value": "stbds_arrfree", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 403, + "column": 1, + "source_line": "#define arrfree stbds_arrfree" + } + }, + "arraddn": { + "name": "arraddn", + "value": "stbds_arraddn", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 404, + "column": 1, + "source_line": "#define arraddn stbds_arraddn // deprecated, use one of the following instead:" + } + }, + "arraddnptr": { + "name": "arraddnptr", + "value": "stbds_arraddnptr", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 405, + "column": 1, + "source_line": "#define arraddnptr stbds_arraddnptr" + } + }, + "arraddnindex": { + "name": "arraddnindex", + "value": "stbds_arraddnindex", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 406, + "column": 1, + "source_line": "#define arraddnindex stbds_arraddnindex" + } + }, + "arrsetlen": { + "name": "arrsetlen", + "value": "stbds_arrsetlen", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 407, + "column": 1, + "source_line": "#define arrsetlen stbds_arrsetlen" + } + }, + "arrlast": { + "name": "arrlast", + "value": "stbds_arrlast", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 408, + "column": 1, + "source_line": "#define arrlast stbds_arrlast" + } + }, + "arrins": { + "name": "arrins", + "value": "stbds_arrins", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 409, + "column": 1, + "source_line": "#define arrins stbds_arrins" + } + }, + "arrinsn": { + "name": "arrinsn", + "value": "stbds_arrinsn", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 410, + "column": 1, + "source_line": "#define arrinsn stbds_arrinsn" + } + }, + "arrdel": { + "name": "arrdel", + "value": "stbds_arrdel", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 411, + "column": 1, + "source_line": "#define arrdel stbds_arrdel" + } + }, + "arrdeln": { + "name": "arrdeln", + "value": "stbds_arrdeln", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 412, + "column": 1, + "source_line": "#define arrdeln stbds_arrdeln" + } + }, + "arrdelswap": { + "name": "arrdelswap", + "value": "stbds_arrdelswap", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 413, + "column": 1, + "source_line": "#define arrdelswap stbds_arrdelswap" + } + }, + "arrcap": { + "name": "arrcap", + "value": "stbds_arrcap", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 414, + "column": 1, + "source_line": "#define arrcap stbds_arrcap" + } + }, + "arrsetcap": { + "name": "arrsetcap", + "value": "stbds_arrsetcap", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 415, + "column": 1, + "source_line": "#define arrsetcap stbds_arrsetcap" + } + }, + "hmput": { + "name": "hmput", + "value": "stbds_hmput", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 417, + "column": 1, + "source_line": "#define hmput stbds_hmput" + } + }, + "hmputs": { + "name": "hmputs", + "value": "stbds_hmputs", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 418, + "column": 1, + "source_line": "#define hmputs stbds_hmputs" + } + }, + "hmget": { + "name": "hmget", + "value": "stbds_hmget", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 419, + "column": 1, + "source_line": "#define hmget stbds_hmget" + } + }, + "hmget_ts": { + "name": "hmget_ts", + "value": "stbds_hmget_ts", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 420, + "column": 1, + "source_line": "#define hmget_ts stbds_hmget_ts" + } + }, + "hmgets": { + "name": "hmgets", + "value": "stbds_hmgets", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 421, + "column": 1, + "source_line": "#define hmgets stbds_hmgets" + } + }, + "hmgetp": { + "name": "hmgetp", + "value": "stbds_hmgetp", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 422, + "column": 1, + "source_line": "#define hmgetp stbds_hmgetp" + } + }, + "hmgetp_ts": { + "name": "hmgetp_ts", + "value": "stbds_hmgetp_ts", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 423, + "column": 1, + "source_line": "#define hmgetp_ts stbds_hmgetp_ts" + } + }, + "hmgetp_null": { + "name": "hmgetp_null", + "value": "stbds_hmgetp_null", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 424, + "column": 1, + "source_line": "#define hmgetp_null stbds_hmgetp_null" + } + }, + "hmgeti": { + "name": "hmgeti", + "value": "stbds_hmgeti", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 425, + "column": 1, + "source_line": "#define hmgeti stbds_hmgeti" + } + }, + "hmgeti_ts": { + "name": "hmgeti_ts", + "value": "stbds_hmgeti_ts", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 426, + "column": 1, + "source_line": "#define hmgeti_ts stbds_hmgeti_ts" + } + }, + "hmdel": { + "name": "hmdel", + "value": "stbds_hmdel", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 427, + "column": 1, + "source_line": "#define hmdel stbds_hmdel" + } + }, + "hmlen": { + "name": "hmlen", + "value": "stbds_hmlen", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 428, + "column": 1, + "source_line": "#define hmlen stbds_hmlen" + } + }, + "hmlenu": { + "name": "hmlenu", + "value": "stbds_hmlenu", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 429, + "column": 1, + "source_line": "#define hmlenu stbds_hmlenu" + } + }, + "hmfree": { + "name": "hmfree", + "value": "stbds_hmfree", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 430, + "column": 1, + "source_line": "#define hmfree stbds_hmfree" + } + }, + "hmdefault": { + "name": "hmdefault", + "value": "stbds_hmdefault", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 431, + "column": 1, + "source_line": "#define hmdefault stbds_hmdefault" + } + }, + "hmdefaults": { + "name": "hmdefaults", + "value": "stbds_hmdefaults", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 432, + "column": 1, + "source_line": "#define hmdefaults stbds_hmdefaults" + } + }, + "shput": { + "name": "shput", + "value": "stbds_shput", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 434, + "column": 1, + "source_line": "#define shput stbds_shput" + } + }, + "shputi": { + "name": "shputi", + "value": "stbds_shputi", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 435, + "column": 1, + "source_line": "#define shputi stbds_shputi" + } + }, + "shputs": { + "name": "shputs", + "value": "stbds_shputs", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 436, + "column": 1, + "source_line": "#define shputs stbds_shputs" + } + }, + "shget": { + "name": "shget", + "value": "stbds_shget", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 437, + "column": 1, + "source_line": "#define shget stbds_shget" + } + }, + "shgeti": { + "name": "shgeti", + "value": "stbds_shgeti", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 438, + "column": 1, + "source_line": "#define shgeti stbds_shgeti" + } + }, + "shgets": { + "name": "shgets", + "value": "stbds_shgets", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 439, + "column": 1, + "source_line": "#define shgets stbds_shgets" + } + }, + "shgetp": { + "name": "shgetp", + "value": "stbds_shgetp", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 440, + "column": 1, + "source_line": "#define shgetp stbds_shgetp" + } + }, + "shgetp_null": { + "name": "shgetp_null", + "value": "stbds_shgetp_null", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 441, + "column": 1, + "source_line": "#define shgetp_null stbds_shgetp_null" + } + }, + "shdel": { + "name": "shdel", + "value": "stbds_shdel", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 442, + "column": 1, + "source_line": "#define shdel stbds_shdel" + } + }, + "shlen": { + "name": "shlen", + "value": "stbds_shlen", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 443, + "column": 1, + "source_line": "#define shlen stbds_shlen" + } + }, + "shlenu": { + "name": "shlenu", + "value": "stbds_shlenu", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 444, + "column": 1, + "source_line": "#define shlenu stbds_shlenu" + } + }, + "shfree": { + "name": "shfree", + "value": "stbds_shfree", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 445, + "column": 1, + "source_line": "#define shfree stbds_shfree" + } + }, + "shdefault": { + "name": "shdefault", + "value": "stbds_shdefault", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 446, + "column": 1, + "source_line": "#define shdefault stbds_shdefault" + } + }, + "shdefaults": { + "name": "shdefaults", + "value": "stbds_shdefaults", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 447, + "column": 1, + "source_line": "#define shdefaults stbds_shdefaults" + } + }, + "sh_new_arena": { + "name": "sh_new_arena", + "value": "stbds_sh_new_arena", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 448, + "column": 1, + "source_line": "#define sh_new_arena stbds_sh_new_arena" + } + }, + "sh_new_strdup": { + "name": "sh_new_strdup", + "value": "stbds_sh_new_strdup", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 449, + "column": 1, + "source_line": "#define sh_new_strdup stbds_sh_new_strdup" + } + }, + "stralloc": { + "name": "stralloc", + "value": "stbds_stralloc", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 451, + "column": 1, + "source_line": "#define stralloc stbds_stralloc" + } + }, + "strreset": { + "name": "strreset", + "value": "stbds_strreset", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 452, + "column": 1, + "source_line": "#define strreset stbds_strreset" + } + }, + "STBDS_REALLOC": { + "name": "STBDS_REALLOC", + "value": "realloc(p,s)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 460, + "column": 1, + "source_line": "#define STBDS_REALLOC(c,p,s) realloc(p,s)" + } + }, + "STBDS_FREE": { + "name": "STBDS_FREE", + "value": "free(p)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 461, + "column": 1, + "source_line": "#define STBDS_FREE(c,p) free(p)" + } + }, + "STBDS_NOTUSED": { + "name": "STBDS_NOTUSED", + "value": "(void)sizeof(v)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 467, + "column": 1, + "source_line": "#define STBDS_NOTUSED(v) (void)sizeof(v)" + } + }, + "STBDS_HAS_TYPEOF": { + "name": "STBDS_HAS_TYPEOF", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 509, + "column": 1, + "source_line": "#define STBDS_HAS_TYPEOF" + } + }, + "STBDS_HAS_LITERAL_ARRAY": { + "name": "STBDS_HAS_LITERAL_ARRAY", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 517, + "column": 1, + "source_line": "#define STBDS_HAS_LITERAL_ARRAY" + } + }, + "STBDS_ADDRESSOF": { + "name": "STBDS_ADDRESSOF", + "value": "&(value)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 529, + "column": 1, + "source_line": "#define STBDS_ADDRESSOF(typevar, value) &(value)" + } + }, + "STBDS_OFFSETOF": { + "name": "STBDS_OFFSETOF", + "value": "((char *) &(var)->field - (char *) (var))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 532, + "column": 1, + "source_line": "#define STBDS_OFFSETOF(var,field) ((char *) &(var)->field - (char *) (var))" + } + }, + "stbds_header": { + "name": "stbds_header", + "value": "((stbds_array_header *) (t) - 1)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 534, + "column": 1, + "source_line": "#define stbds_header(t) ((stbds_array_header *) (t) - 1)" + } + }, + "stbds_temp": { + "name": "stbds_temp", + "value": "stbds_header(t)->temp", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 535, + "column": 1, + "source_line": "#define stbds_temp(t) stbds_header(t)->temp" + } + }, + "stbds_temp_key": { + "name": "stbds_temp_key", + "value": "(*(char **) stbds_header(t)->hash_table)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 536, + "column": 1, + "source_line": "#define stbds_temp_key(t) (*(char **) stbds_header(t)->hash_table)" + } + }, + "stbds_arrsetcap": { + "name": "stbds_arrsetcap", + "value": "(stbds_arrgrow(a,0,n))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 538, + "column": 1, + "source_line": "#define stbds_arrsetcap(a,n) (stbds_arrgrow(a,0,n))" + } + }, + "stbds_arrsetlen": { + "name": "stbds_arrsetlen", + "value": "((stbds_arrcap(a) < (size_t) (n) ? stbds_arrsetcap((a),(size_t)(n)),0 : 0), (a) ? stbds_header(a)->length = (size_t) (n) : 0)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 539, + "column": 1, + "source_line": "#define stbds_arrsetlen(a,n) ((stbds_arrcap(a) < (size_t) (n) ? stbds_arrsetcap((a),(size_t)(n)),0 : 0), (a) ? stbds_header(a)->length = (size_t) (n) : 0)" + } + }, + "stbds_arrcap": { + "name": "stbds_arrcap", + "value": "((a) ? stbds_header(a)->capacity : 0)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 540, + "column": 1, + "source_line": "#define stbds_arrcap(a) ((a) ? stbds_header(a)->capacity : 0)" + } + }, + "stbds_arrlen": { + "name": "stbds_arrlen", + "value": "((a) ? (ptrdiff_t) stbds_header(a)->length : 0)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 541, + "column": 1, + "source_line": "#define stbds_arrlen(a) ((a) ? (ptrdiff_t) stbds_header(a)->length : 0)" + } + }, + "stbds_arrlenu": { + "name": "stbds_arrlenu", + "value": "((a) ? stbds_header(a)->length : 0)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 542, + "column": 1, + "source_line": "#define stbds_arrlenu(a) ((a) ? stbds_header(a)->length : 0)" + } + }, + "stbds_arrput": { + "name": "stbds_arrput", + "value": "(stbds_arrmaybegrow(a,1), (a)[stbds_header(a)->length++] = (v))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 543, + "column": 1, + "source_line": "#define stbds_arrput(a,v) (stbds_arrmaybegrow(a,1), (a)[stbds_header(a)->length++] = (v))" + } + }, + "stbds_arrpush": { + "name": "stbds_arrpush", + "value": "stbds_arrput", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 544, + "column": 1, + "source_line": "#define stbds_arrpush stbds_arrput // synonym" + } + }, + "stbds_arrpop": { + "name": "stbds_arrpop", + "value": "(stbds_header(a)->length--, (a)[stbds_header(a)->length])", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 545, + "column": 1, + "source_line": "#define stbds_arrpop(a) (stbds_header(a)->length--, (a)[stbds_header(a)->length])" + } + }, + "stbds_arraddn": { + "name": "stbds_arraddn", + "value": "((void)(stbds_arraddnindex(a, n)))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 546, + "column": 1, + "source_line": "#define stbds_arraddn(a,n) ((void)(stbds_arraddnindex(a, n))) // deprecated, use one of the following instead:" + } + }, + "stbds_arraddnptr": { + "name": "stbds_arraddnptr", + "value": "(stbds_arrmaybegrow(a,n), (n) ? (stbds_header(a)->length += (n), &(a)[stbds_header(a)->length-(n)]) : (a))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 547, + "column": 1, + "source_line": "#define stbds_arraddnptr(a,n) (stbds_arrmaybegrow(a,n), (n) ? (stbds_header(a)->length += (n), &(a)[stbds_header(a)->length-(n)]) : (a))" + } + }, + "stbds_arraddnoff": { + "name": "stbds_arraddnoff", + "value": "stbds_arraddnindex", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 549, + "column": 1, + "source_line": "#define stbds_arraddnoff stbds_arraddnindex" + } + }, + "stbds_arrlast": { + "name": "stbds_arrlast", + "value": "((a)[stbds_header(a)->length-1])", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 550, + "column": 1, + "source_line": "#define stbds_arrlast(a) ((a)[stbds_header(a)->length-1])" + } + }, + "stbds_arrfree": { + "name": "stbds_arrfree", + "value": "((void) ((a) ? STBDS_FREE(NULL,stbds_header(a)) : (void)0), (a)=NULL)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 551, + "column": 1, + "source_line": "#define stbds_arrfree(a) ((void) ((a) ? STBDS_FREE(NULL,stbds_header(a)) : (void)0), (a)=NULL)" + } + }, + "stbds_arrdel": { + "name": "stbds_arrdel", + "value": "stbds_arrdeln(a,i,1)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 552, + "column": 1, + "source_line": "#define stbds_arrdel(a,i) stbds_arrdeln(a,i,1)" + } + }, + "stbds_arrdeln": { + "name": "stbds_arrdeln", + "value": "(memmove(&(a)[i], &(a)[(i)+(n)], sizeof *(a) * (stbds_header(a)->length-(n)-(i))), stbds_header(a)->length -= (n))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 553, + "column": 1, + "source_line": "#define stbds_arrdeln(a,i,n) (memmove(&(a)[i], &(a)[(i)+(n)], sizeof *(a) * (stbds_header(a)->length-(n)-(i))), stbds_header(a)->length -= (n))" + } + }, + "stbds_arrdelswap": { + "name": "stbds_arrdelswap", + "value": "((a)[i] = stbds_arrlast(a), stbds_header(a)->length -= 1)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 554, + "column": 1, + "source_line": "#define stbds_arrdelswap(a,i) ((a)[i] = stbds_arrlast(a), stbds_header(a)->length -= 1)" + } + }, + "stbds_arrinsn": { + "name": "stbds_arrinsn", + "value": "(stbds_arraddn((a),(n)), memmove(&(a)[(i)+(n)], &(a)[i], sizeof *(a) * (stbds_header(a)->length-(n)-(i))))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 555, + "column": 1, + "source_line": "#define stbds_arrinsn(a,i,n) (stbds_arraddn((a),(n)), memmove(&(a)[(i)+(n)], &(a)[i], sizeof *(a) * (stbds_header(a)->length-(n)-(i))))" + } + }, + "stbds_arrins": { + "name": "stbds_arrins", + "value": "(stbds_arrinsn((a),(i),1), (a)[i]=(v))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 556, + "column": 1, + "source_line": "#define stbds_arrins(a,i,v) (stbds_arrinsn((a),(i),1), (a)[i]=(v))" + } + }, + "stbds_arrmaybegrow": { + "name": "stbds_arrmaybegrow", + "value": "((!(a) || stbds_header(a)->length + (n) > stbds_header(a)->capacity) ? (stbds_arrgrow(a,n,0),0) : 0)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 558, + "column": 1, + "source_line": "#define stbds_arrmaybegrow(a,n) ((!(a) || stbds_header(a)->length + (n) > stbds_header(a)->capacity) \\" + } + }, + "stbds_arrgrow": { + "name": "stbds_arrgrow", + "value": "((a) = stbds_arrgrowf_wrapper((a), sizeof *(a), (b), (c)))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 561, + "column": 1, + "source_line": "#define stbds_arrgrow(a,b,c) ((a) = stbds_arrgrowf_wrapper((a), sizeof *(a), (b), (c)))" + } + }, + "stbds_hmput": { + "name": "stbds_hmput", + "value": "((t) = stbds_hmput_key_wrapper((t), sizeof *(t), (void*) STBDS_ADDRESSOF((t)->key, (k)), sizeof (t)->key, 0), (t)[stbds_temp((t)-1)].key = (k), (t)[stbds_temp((t)-1)].value = (v))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 563, + "column": 1, + "source_line": "#define stbds_hmput(t, k, v) \\" + } + }, + "stbds_hmputs": { + "name": "stbds_hmputs", + "value": "((t) = stbds_hmput_key_wrapper((t), sizeof *(t), &(s).key, sizeof (s).key, STBDS_HM_BINARY), (t)[stbds_temp((t)-1)] = (s))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 568, + "column": 1, + "source_line": "#define stbds_hmputs(t, s) \\" + } + }, + "stbds_hmgeti": { + "name": "stbds_hmgeti", + "value": "((t) = stbds_hmget_key_wrapper((t), sizeof *(t), (void*) STBDS_ADDRESSOF((t)->key, (k)), sizeof (t)->key, STBDS_HM_BINARY), stbds_temp((t)-1))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 572, + "column": 1, + "source_line": "#define stbds_hmgeti(t,k) \\" + } + }, + "stbds_hmgeti_ts": { + "name": "stbds_hmgeti_ts", + "value": "((t) = stbds_hmget_key_ts_wrapper((t), sizeof *(t), (void*) STBDS_ADDRESSOF((t)->key, (k)), sizeof (t)->key, &(temp), STBDS_HM_BINARY), (temp))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 576, + "column": 1, + "source_line": "#define stbds_hmgeti_ts(t,k,temp) \\" + } + }, + "stbds_hmgetp": { + "name": "stbds_hmgetp", + "value": "((void) stbds_hmgeti(t,k), &(t)[stbds_temp((t)-1)])", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 580, + "column": 1, + "source_line": "#define stbds_hmgetp(t, k) \\" + } + }, + "stbds_hmgetp_ts": { + "name": "stbds_hmgetp_ts", + "value": "((void) stbds_hmgeti_ts(t,k,temp), &(t)[temp])", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 583, + "column": 1, + "source_line": "#define stbds_hmgetp_ts(t, k, temp) \\" + } + }, + "stbds_hmdel": { + "name": "stbds_hmdel", + "value": "(((t) = stbds_hmdel_key_wrapper((t),sizeof *(t), (void*) STBDS_ADDRESSOF((t)->key, (k)), sizeof (t)->key, STBDS_OFFSETOF((t),key), STBDS_HM_BINARY)),(t)?stbds_temp((t)-1):0)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 586, + "column": 1, + "source_line": "#define stbds_hmdel(t,k) \\" + } + }, + "stbds_hmdefault": { + "name": "stbds_hmdefault", + "value": "((t) = stbds_hmput_default_wrapper((t), sizeof *(t)), (t)[-1].value = (v))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 589, + "column": 1, + "source_line": "#define stbds_hmdefault(t, v) \\" + } + }, + "stbds_hmdefaults": { + "name": "stbds_hmdefaults", + "value": "((t) = stbds_hmput_default_wrapper((t), sizeof *(t)), (t)[-1] = (s))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 592, + "column": 1, + "source_line": "#define stbds_hmdefaults(t, s) \\" + } + }, + "stbds_hmfree": { + "name": "stbds_hmfree", + "value": "((void) ((p) != NULL ? stbds_hmfree_func((p)-1,sizeof*(p)),0 : 0),(p)=NULL)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 595, + "column": 1, + "source_line": "#define stbds_hmfree(p) \\" + } + }, + "stbds_hmgets": { + "name": "stbds_hmgets", + "value": "(*stbds_hmgetp(t,k))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 598, + "column": 1, + "source_line": "#define stbds_hmgets(t, k) (*stbds_hmgetp(t,k))" + } + }, + "stbds_hmget": { + "name": "stbds_hmget", + "value": "(stbds_hmgetp(t,k)->value)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 599, + "column": 1, + "source_line": "#define stbds_hmget(t, k) (stbds_hmgetp(t,k)->value)" + } + }, + "stbds_hmget_ts": { + "name": "stbds_hmget_ts", + "value": "(stbds_hmgetp_ts(t,k,temp)->value)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 600, + "column": 1, + "source_line": "#define stbds_hmget_ts(t, k, temp) (stbds_hmgetp_ts(t,k,temp)->value)" + } + }, + "stbds_hmlen": { + "name": "stbds_hmlen", + "value": "((t) ? (ptrdiff_t) stbds_header((t)-1)->length-1 : 0)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 601, + "column": 1, + "source_line": "#define stbds_hmlen(t) ((t) ? (ptrdiff_t) stbds_header((t)-1)->length-1 : 0)" + } + }, + "stbds_hmlenu": { + "name": "stbds_hmlenu", + "value": "((t) ? stbds_header((t)-1)->length-1 : 0)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 602, + "column": 1, + "source_line": "#define stbds_hmlenu(t) ((t) ? stbds_header((t)-1)->length-1 : 0)" + } + }, + "stbds_hmgetp_null": { + "name": "stbds_hmgetp_null", + "value": "(stbds_hmgeti(t,k) == -1 ? NULL : &(t)[stbds_temp((t)-1)])", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 603, + "column": 1, + "source_line": "#define stbds_hmgetp_null(t,k) (stbds_hmgeti(t,k) == -1 ? NULL : &(t)[stbds_temp((t)-1)])" + } + }, + "stbds_shput": { + "name": "stbds_shput", + "value": "((t) = stbds_hmput_key_wrapper((t), sizeof *(t), (void*) (k), sizeof (t)->key, STBDS_HM_STRING), (t)[stbds_temp((t)-1)].value = (v))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 605, + "column": 1, + "source_line": "#define stbds_shput(t, k, v) \\" + } + }, + "stbds_shputi": { + "name": "stbds_shputi", + "value": "((t) = stbds_hmput_key_wrapper((t), sizeof *(t), (void*) (k), sizeof (t)->key, STBDS_HM_STRING), (t)[stbds_temp((t)-1)].value = (v), stbds_temp((t)-1))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 609, + "column": 1, + "source_line": "#define stbds_shputi(t, k, v) \\" + } + }, + "stbds_shputs": { + "name": "stbds_shputs", + "value": "((t) = stbds_hmput_key_wrapper((t), sizeof *(t), (void*) (s).key, sizeof (s).key, STBDS_HM_STRING), (t)[stbds_temp((t)-1)] = (s), (t)[stbds_temp((t)-1)].key = stbds_temp_key((t)-1))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 613, + "column": 1, + "source_line": "#define stbds_shputs(t, s) \\" + } + }, + "stbds_pshput": { + "name": "stbds_pshput", + "value": "((t) = stbds_hmput_key_wrapper((t), sizeof *(t), (void*) (p)->key, sizeof (p)->key, STBDS_HM_PTR_TO_STRING), (t)[stbds_temp((t)-1)] = (p))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 618, + "column": 1, + "source_line": "#define stbds_pshput(t, p) \\" + } + }, + "stbds_shgeti": { + "name": "stbds_shgeti", + "value": "((t) = stbds_hmget_key_wrapper((t), sizeof *(t), (void*) (k), sizeof (t)->key, STBDS_HM_STRING), stbds_temp((t)-1))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 622, + "column": 1, + "source_line": "#define stbds_shgeti(t,k) \\" + } + }, + "stbds_pshgeti": { + "name": "stbds_pshgeti", + "value": "((t) = stbds_hmget_key_wrapper((t), sizeof *(t), (void*) (k), sizeof (*(t))->key, STBDS_HM_PTR_TO_STRING), stbds_temp((t)-1))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 626, + "column": 1, + "source_line": "#define stbds_pshgeti(t,k) \\" + } + }, + "stbds_shgetp": { + "name": "stbds_shgetp", + "value": "((void) stbds_shgeti(t,k), &(t)[stbds_temp((t)-1)])", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 630, + "column": 1, + "source_line": "#define stbds_shgetp(t, k) \\" + } + }, + "stbds_pshget": { + "name": "stbds_pshget", + "value": "((void) stbds_pshgeti(t,k), (t)[stbds_temp((t)-1)])", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 633, + "column": 1, + "source_line": "#define stbds_pshget(t, k) \\" + } + }, + "stbds_shdel": { + "name": "stbds_shdel", + "value": "(((t) = stbds_hmdel_key_wrapper((t),sizeof *(t), (void*) (k), sizeof (t)->key, STBDS_OFFSETOF((t),key), STBDS_HM_STRING)),(t)?stbds_temp((t)-1):0)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 636, + "column": 1, + "source_line": "#define stbds_shdel(t,k) \\" + } + }, + "stbds_pshdel": { + "name": "stbds_pshdel", + "value": "(((t) = stbds_hmdel_key_wrapper((t),sizeof *(t), (void*) (k), sizeof (*(t))->key, STBDS_OFFSETOF(*(t),key), STBDS_HM_PTR_TO_STRING)),(t)?stbds_temp((t)-1):0)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 638, + "column": 1, + "source_line": "#define stbds_pshdel(t,k) \\" + } + }, + "stbds_sh_new_arena": { + "name": "stbds_sh_new_arena", + "value": "((t) = stbds_shmode_func_wrapper(t, sizeof *(t), STBDS_SH_ARENA))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 641, + "column": 1, + "source_line": "#define stbds_sh_new_arena(t) \\" + } + }, + "stbds_sh_new_strdup": { + "name": "stbds_sh_new_strdup", + "value": "((t) = stbds_shmode_func_wrapper(t, sizeof *(t), STBDS_SH_STRDUP))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 643, + "column": 1, + "source_line": "#define stbds_sh_new_strdup(t) \\" + } + }, + "stbds_shdefault": { + "name": "stbds_shdefault", + "value": "stbds_hmdefault(t,v)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 646, + "column": 1, + "source_line": "#define stbds_shdefault(t, v) stbds_hmdefault(t,v)" + } + }, + "stbds_shdefaults": { + "name": "stbds_shdefaults", + "value": "stbds_hmdefaults(t,s)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 647, + "column": 1, + "source_line": "#define stbds_shdefaults(t, s) stbds_hmdefaults(t,s)" + } + }, + "stbds_shfree": { + "name": "stbds_shfree", + "value": "stbds_hmfree", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 649, + "column": 1, + "source_line": "#define stbds_shfree stbds_hmfree" + } + }, + "stbds_shlenu": { + "name": "stbds_shlenu", + "value": "stbds_hmlenu", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 650, + "column": 1, + "source_line": "#define stbds_shlenu stbds_hmlenu" + } + }, + "stbds_shgets": { + "name": "stbds_shgets", + "value": "(*stbds_shgetp(t,k))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 652, + "column": 1, + "source_line": "#define stbds_shgets(t, k) (*stbds_shgetp(t,k))" + } + }, + "stbds_shget": { + "name": "stbds_shget", + "value": "(stbds_shgetp(t,k)->value)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 653, + "column": 1, + "source_line": "#define stbds_shget(t, k) (stbds_shgetp(t,k)->value)" + } + }, + "stbds_shgetp_null": { + "name": "stbds_shgetp_null", + "value": "(stbds_shgeti(t,k) == -1 ? NULL : &(t)[stbds_temp((t)-1)])", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 654, + "column": 1, + "source_line": "#define stbds_shgetp_null(t,k) (stbds_shgeti(t,k) == -1 ? NULL : &(t)[stbds_temp((t)-1)])" + } + }, + "stbds_shlen": { + "name": "stbds_shlen", + "value": "stbds_hmlen", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 655, + "column": 1, + "source_line": "#define stbds_shlen stbds_hmlen" + } + }, + "STBDS_HM_BINARY": { + "name": "STBDS_HM_BINARY", + "value": "0", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 679, + "column": 1, + "source_line": "#define STBDS_HM_BINARY 0" + } + }, + "STBDS_HM_STRING": { + "name": "STBDS_HM_STRING", + "value": "1", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 680, + "column": 1, + "source_line": "#define STBDS_HM_STRING 1" + } + }, + "stbds_arrgrowf_wrapper": { + "name": "stbds_arrgrowf_wrapper", + "value": "stbds_arrgrowf", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 715, + "column": 1, + "source_line": "#define stbds_arrgrowf_wrapper stbds_arrgrowf" + } + }, + "stbds_hmget_key_wrapper": { + "name": "stbds_hmget_key_wrapper", + "value": "stbds_hmget_key", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 716, + "column": 1, + "source_line": "#define stbds_hmget_key_wrapper stbds_hmget_key" + } + }, + "stbds_hmget_key_ts_wrapper": { + "name": "stbds_hmget_key_ts_wrapper", + "value": "stbds_hmget_key_ts", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 717, + "column": 1, + "source_line": "#define stbds_hmget_key_ts_wrapper stbds_hmget_key_ts" + } + }, + "stbds_hmput_default_wrapper": { + "name": "stbds_hmput_default_wrapper", + "value": "stbds_hmput_default", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 718, + "column": 1, + "source_line": "#define stbds_hmput_default_wrapper stbds_hmput_default" + } + }, + "stbds_hmput_key_wrapper": { + "name": "stbds_hmput_key_wrapper", + "value": "stbds_hmput_key", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 719, + "column": 1, + "source_line": "#define stbds_hmput_key_wrapper stbds_hmput_key" + } + }, + "stbds_hmdel_key_wrapper": { + "name": "stbds_hmdel_key_wrapper", + "value": "stbds_hmdel_key", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 720, + "column": 1, + "source_line": "#define stbds_hmdel_key_wrapper stbds_hmdel_key" + } + }, + "stbds_shmode_func_wrapper": { + "name": "stbds_shmode_func_wrapper", + "value": "stbds_shmode_func(e,m)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 721, + "column": 1, + "source_line": "#define stbds_shmode_func_wrapper(t,e,m) stbds_shmode_func(e,m)" + } + }, + "STBDS_ASSERT_WAS_UNDEFINED": { + "name": "STBDS_ASSERT_WAS_UNDEFINED", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 737, + "column": 1, + "source_line": "#define STBDS_ASSERT_WAS_UNDEFINED" + } + }, + "STBDS_ASSERT": { + "name": "STBDS_ASSERT", + "value": "assert", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1630, + "column": 1, + "source_line": "#define STBDS_ASSERT assert" + } + }, + "STBDS_STATS": { + "name": "STBDS_STATS", + "value": null, + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 752, + "column": 1, + "source_line": "#define STBDS_STATS(x)" + } + }, + "STBDS_BUCKET_LENGTH": { + "name": "STBDS_BUCKET_LENGTH", + "value": "8", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 812, + "column": 1, + "source_line": "#define STBDS_BUCKET_LENGTH 8" + } + }, + "STBDS_BUCKET_SHIFT": { + "name": "STBDS_BUCKET_SHIFT", + "value": "(STBDS_BUCKET_LENGTH == 8 ? 3 : 2)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 815, + "column": 1, + "source_line": "#define STBDS_BUCKET_SHIFT (STBDS_BUCKET_LENGTH == 8 ? 3 : 2)" + } + }, + "STBDS_BUCKET_MASK": { + "name": "STBDS_BUCKET_MASK", + "value": "(STBDS_BUCKET_LENGTH-1)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 816, + "column": 1, + "source_line": "#define STBDS_BUCKET_MASK (STBDS_BUCKET_LENGTH-1)" + } + }, + "STBDS_CACHE_LINE_SIZE": { + "name": "STBDS_CACHE_LINE_SIZE", + "value": "64", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 817, + "column": 1, + "source_line": "#define STBDS_CACHE_LINE_SIZE 64" + } + }, + "STBDS_ALIGN_FWD": { + "name": "STBDS_ALIGN_FWD", + "value": "(((n) + (a) - 1) & ~((a)-1))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 819, + "column": 1, + "source_line": "#define STBDS_ALIGN_FWD(n,a) (((n) + (a) - 1) & ~((a)-1))" + } + }, + "STBDS_INDEX_EMPTY": { + "name": "STBDS_INDEX_EMPTY", + "value": "-1", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 842, + "column": 1, + "source_line": "#define STBDS_INDEX_EMPTY -1" + } + }, + "STBDS_INDEX_DELETED": { + "name": "STBDS_INDEX_DELETED", + "value": "-2", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 843, + "column": 1, + "source_line": "#define STBDS_INDEX_DELETED -2" + } + }, + "STBDS_INDEX_IN_USE": { + "name": "STBDS_INDEX_IN_USE", + "value": "((x) >= 0)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 844, + "column": 1, + "source_line": "#define STBDS_INDEX_IN_USE(x) ((x) >= 0)" + } + }, + "STBDS_HASH_EMPTY": { + "name": "STBDS_HASH_EMPTY", + "value": "0", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 846, + "column": 1, + "source_line": "#define STBDS_HASH_EMPTY 0" + } + }, + "STBDS_HASH_DELETED": { + "name": "STBDS_HASH_DELETED", + "value": "1", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 847, + "column": 1, + "source_line": "#define STBDS_HASH_DELETED 1" + } + }, + "stbds_load_32_or_64": { + "name": "stbds_load_32_or_64", + "value": "temp = v64_lo ^ v32, temp <<= 16, temp <<= 16, temp >>= 16, temp >>= 16, var = v64_hi, var <<= 16, var <<= 16, var ^= temp ^ v32", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 856, + "column": 1, + "source_line": "#define stbds_load_32_or_64(var, temp, v32, v64_hi, v64_lo) \\" + } + }, + "STBDS_SIZE_T_BITS": { + "name": "STBDS_SIZE_T_BITS", + "value": "((sizeof (size_t)) * 8)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 861, + "column": 1, + "source_line": "#define STBDS_SIZE_T_BITS ((sizeof (size_t)) * 8)" + } + }, + "STBDS_ROTATE_LEFT": { + "name": "STBDS_ROTATE_LEFT", + "value": "(((val) << (n)) | ((val) >> (STBDS_SIZE_T_BITS - (n))))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1013, + "column": 1, + "source_line": "#define STBDS_ROTATE_LEFT(val, n) (((val) << (n)) | ((val) >> (STBDS_SIZE_T_BITS - (n))))" + } + }, + "STBDS_ROTATE_RIGHT": { + "name": "STBDS_ROTATE_RIGHT", + "value": "(((val) >> (n)) | ((val) << (STBDS_SIZE_T_BITS - (n))))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1014, + "column": 1, + "source_line": "#define STBDS_ROTATE_RIGHT(val, n) (((val) >> (n)) | ((val) << (STBDS_SIZE_T_BITS - (n))))" + } + }, + "STBDS_SIPHASH_C_ROUNDS": { + "name": "STBDS_SIPHASH_C_ROUNDS", + "value": "1", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1040, + "column": 1, + "source_line": "#define STBDS_SIPHASH_C_ROUNDS 1" + } + }, + "STBDS_SIPHASH_D_ROUNDS": { + "name": "STBDS_SIPHASH_D_ROUNDS", + "value": "1", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1043, + "column": 1, + "source_line": "#define STBDS_SIPHASH_D_ROUNDS 1" + } + }, + "STBDS_SIPROUND": { + "name": "STBDS_SIPROUND", + "value": "do { v0 += v1; v1 = STBDS_ROTATE_LEFT(v1, 13); v1 ^= v0; v0 = STBDS_ROTATE_LEFT(v0,STBDS_SIZE_T_BITS/2); v2 += v3; v3 = STBDS_ROTATE_LEFT(v3, 16); v3 ^= v2; v2 += v1; v1 = STBDS_ROTATE_LEFT(v1, 17); v1 ^= v2; v2 = STBDS_ROTATE_LEFT(v2,STBDS_SIZE_T_BITS/2); v0 += v3; v3 = STBDS_ROTATE_LEFT(v3, 21); v3 ^= v0; } while (0)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1073, + "column": 3, + "source_line": " #define STBDS_SIPROUND() \\" + } + }, + "STBDS_HASH_TO_ARR": { + "name": "STBDS_HASH_TO_ARR", + "value": "((char*) (x) - (elemsize))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1211, + "column": 1, + "source_line": "#define STBDS_HASH_TO_ARR(x,elemsize) ((char*) (x) - (elemsize))" + } + }, + "STBDS_ARR_TO_HASH": { + "name": "STBDS_ARR_TO_HASH", + "value": "((char*) (x) + (elemsize))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1212, + "column": 1, + "source_line": "#define STBDS_ARR_TO_HASH(x,elemsize) ((char*) (x) + (elemsize))" + } + }, + "stbds_hash_table": { + "name": "stbds_hash_table", + "value": "((stbds_hash_index *) stbds_header(a)->hash_table)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1214, + "column": 1, + "source_line": "#define stbds_hash_table(a) ((stbds_hash_index *) stbds_header(a)->hash_table)" + } + }, + "STBDS_STRING_ARENA_BLOCKSIZE_MIN": { + "name": "STBDS_STRING_ARENA_BLOCKSIZE_MIN", + "value": "512u", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1551, + "column": 1, + "source_line": "#define STBDS_STRING_ARENA_BLOCKSIZE_MIN 512u" + } + }, + "STBDS_STRING_ARENA_BLOCKSIZE_MAX": { + "name": "STBDS_STRING_ARENA_BLOCKSIZE_MAX", + "value": "(1u<<20)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1554, + "column": 1, + "source_line": "#define STBDS_STRING_ARENA_BLOCKSIZE_MAX (1u<<20)" + } + } + }, + "includes": { + "stb/stb_ds.h:stddef.h": { + "target": "stddef.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 394, + "column": 1, + "source_line": "#include " + } + }, + "stb/stb_ds.h:string.h": { + "target": "string.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 734, + "column": 1, + "source_line": "#include " + } + }, + "stb/stb_ds.h:stdlib.h": { + "target": "stdlib.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 459, + "column": 1, + "source_line": "#include " + } + }, + "stb/stb_ds.h:assert.h": { + "target": "assert.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1631, + "column": 1, + "source_line": "#include " + } + }, + "stb/stb_ds.h:stdio.h": { + "target": "stdio.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 1625, + "column": 1, + "source_line": "#include " + } + } + }, + "functions_by_file": { + "stb/stb_ds.h": [ + "stbds_arrgrowf", + "stbds_arrfreef", + "stbds_rand_seed", + "stbds_probe_position", + "stbds_log2", + "stbds_make_hash_index", + "stbds_hash_string", + "stbds_siphash_bytes", + "stbds_hash_bytes", + "stbds_is_key_equal", + "stbds_hmfree_func", + "stbds_hm_find_slot", + "stbds_hmget_key_ts", + "stbds_hmget_key", + "stbds_hmput_default", + "stbds_strdup", + "stbds_hmput_key", + "stbds_shmode_func", + "stbds_hmdel_key", + "stbds_stralloc", + "stbds_strreset", + "strkey", + "stbds_unit_tests" + ] + }, + "enum_constants": { + "STBDS_SH_NONE": { + "name": "STBDS_SH_NONE", + "value": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 682, + "column": 1, + "source_line": "enum" + } + }, + "STBDS_SH_DEFAULT": { + "name": "STBDS_SH_DEFAULT", + "value": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 682, + "column": 1, + "source_line": "enum" + } + }, + "STBDS_SH_STRDUP": { + "name": "STBDS_SH_STRDUP", + "value": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 682, + "column": 1, + "source_line": "enum" + } + }, + "STBDS_SH_ARENA": { + "name": "STBDS_SH_ARENA", + "value": null, + "source_location": { + "filename": "stb/stb_ds.h", + "line": 682, + "column": 1, + "source_line": "enum" + } + } + }, + "include_graph": { + "stb/stb_ds.h": [] + }, + "system_includes": { + "stb/stb_ds.h": [ + "assert.h", + "stddef.h", + "stdio.h", + "stdlib.h", + "string.h" + ] + }, + "unresolved_includes": { + "stb/stb_ds.h": [] + }, + "header_source_pairs": { + "stb/stb_ds.h": [] + }, + "diagnostics": [ + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBDS_REALLOC' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 460, + "column": 1, + "source_line": "#define STBDS_REALLOC(c,p,s) realloc(p,s)" + }, + "unit_kind": "macro", + "unit_name": "STBDS_REALLOC" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBDS_FREE' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 461, + "column": 1, + "source_line": "#define STBDS_FREE(c,p) free(p)" + }, + "unit_kind": "macro", + "unit_name": "STBDS_FREE" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBDS_NOTUSED' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 465, + "column": 1, + "source_line": "#define STBDS_NOTUSED(v) (void)(v)" + }, + "unit_kind": "macro", + "unit_name": "STBDS_NOTUSED" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBDS_NOTUSED' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 467, + "column": 1, + "source_line": "#define STBDS_NOTUSED(v) (void)sizeof(v)" + }, + "unit_kind": "macro", + "unit_name": "STBDS_NOTUSED" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBDS_ADDRESSOF' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 524, + "column": 3, + "source_line": " #define STBDS_ADDRESSOF(typevar, value) ((__typeof__(typevar)[1]){value}) // literal array decays to pointer to value" + }, + "unit_kind": "macro", + "unit_name": "STBDS_ADDRESSOF" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBDS_ADDRESSOF' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 526, + "column": 3, + "source_line": " #define STBDS_ADDRESSOF(typevar, value) ((typeof(typevar)[1]){value}) // literal array decays to pointer to value" + }, + "unit_kind": "macro", + "unit_name": "STBDS_ADDRESSOF" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBDS_ADDRESSOF' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 529, + "column": 1, + "source_line": "#define STBDS_ADDRESSOF(typevar, value) &(value)" + }, + "unit_kind": "macro", + "unit_name": "STBDS_ADDRESSOF" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBDS_OFFSETOF' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 532, + "column": 1, + "source_line": "#define STBDS_OFFSETOF(var,field) ((char *) &(var)->field - (char *) (var))" + }, + "unit_kind": "macro", + "unit_name": "STBDS_OFFSETOF" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_header' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 534, + "column": 1, + "source_line": "#define stbds_header(t) ((stbds_array_header *) (t) - 1)" + }, + "unit_kind": "macro", + "unit_name": "stbds_header" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_temp' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 535, + "column": 1, + "source_line": "#define stbds_temp(t) stbds_header(t)->temp" + }, + "unit_kind": "macro", + "unit_name": "stbds_temp" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_temp_key' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 536, + "column": 1, + "source_line": "#define stbds_temp_key(t) (*(char **) stbds_header(t)->hash_table)" + }, + "unit_kind": "macro", + "unit_name": "stbds_temp_key" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_arrsetcap' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 538, + "column": 1, + "source_line": "#define stbds_arrsetcap(a,n) (stbds_arrgrow(a,0,n))" + }, + "unit_kind": "macro", + "unit_name": "stbds_arrsetcap" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_arrsetlen' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 539, + "column": 1, + "source_line": "#define stbds_arrsetlen(a,n) ((stbds_arrcap(a) < (size_t) (n) ? stbds_arrsetcap((a),(size_t)(n)),0 : 0), (a) ? stbds_header(a)->length = (size_t) (n) : 0)" + }, + "unit_kind": "macro", + "unit_name": "stbds_arrsetlen" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_arrcap' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 540, + "column": 1, + "source_line": "#define stbds_arrcap(a) ((a) ? stbds_header(a)->capacity : 0)" + }, + "unit_kind": "macro", + "unit_name": "stbds_arrcap" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_arrlen' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 541, + "column": 1, + "source_line": "#define stbds_arrlen(a) ((a) ? (ptrdiff_t) stbds_header(a)->length : 0)" + }, + "unit_kind": "macro", + "unit_name": "stbds_arrlen" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_arrlenu' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 542, + "column": 1, + "source_line": "#define stbds_arrlenu(a) ((a) ? stbds_header(a)->length : 0)" + }, + "unit_kind": "macro", + "unit_name": "stbds_arrlenu" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_arrput' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 543, + "column": 1, + "source_line": "#define stbds_arrput(a,v) (stbds_arrmaybegrow(a,1), (a)[stbds_header(a)->length++] = (v))" + }, + "unit_kind": "macro", + "unit_name": "stbds_arrput" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_arrpop' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 545, + "column": 1, + "source_line": "#define stbds_arrpop(a) (stbds_header(a)->length--, (a)[stbds_header(a)->length])" + }, + "unit_kind": "macro", + "unit_name": "stbds_arrpop" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_arraddn' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 546, + "column": 1, + "source_line": "#define stbds_arraddn(a,n) ((void)(stbds_arraddnindex(a, n))) // deprecated, use one of the following instead:" + }, + "unit_kind": "macro", + "unit_name": "stbds_arraddn" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_arraddnptr' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 547, + "column": 1, + "source_line": "#define stbds_arraddnptr(a,n) (stbds_arrmaybegrow(a,n), (n) ? (stbds_header(a)->length += (n), &(a)[stbds_header(a)->length-(n)]) : (a))" + }, + "unit_kind": "macro", + "unit_name": "stbds_arraddnptr" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_arrlast' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 550, + "column": 1, + "source_line": "#define stbds_arrlast(a) ((a)[stbds_header(a)->length-1])" + }, + "unit_kind": "macro", + "unit_name": "stbds_arrlast" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_arrfree' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 551, + "column": 1, + "source_line": "#define stbds_arrfree(a) ((void) ((a) ? STBDS_FREE(NULL,stbds_header(a)) : (void)0), (a)=NULL)" + }, + "unit_kind": "macro", + "unit_name": "stbds_arrfree" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_arrdel' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 552, + "column": 1, + "source_line": "#define stbds_arrdel(a,i) stbds_arrdeln(a,i,1)" + }, + "unit_kind": "macro", + "unit_name": "stbds_arrdel" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_arrdeln' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 553, + "column": 1, + "source_line": "#define stbds_arrdeln(a,i,n) (memmove(&(a)[i], &(a)[(i)+(n)], sizeof *(a) * (stbds_header(a)->length-(n)-(i))), stbds_header(a)->length -= (n))" + }, + "unit_kind": "macro", + "unit_name": "stbds_arrdeln" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_arrdelswap' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 554, + "column": 1, + "source_line": "#define stbds_arrdelswap(a,i) ((a)[i] = stbds_arrlast(a), stbds_header(a)->length -= 1)" + }, + "unit_kind": "macro", + "unit_name": "stbds_arrdelswap" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_arrinsn' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 555, + "column": 1, + "source_line": "#define stbds_arrinsn(a,i,n) (stbds_arraddn((a),(n)), memmove(&(a)[(i)+(n)], &(a)[i], sizeof *(a) * (stbds_header(a)->length-(n)-(i))))" + }, + "unit_kind": "macro", + "unit_name": "stbds_arrinsn" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_arrins' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 556, + "column": 1, + "source_line": "#define stbds_arrins(a,i,v) (stbds_arrinsn((a),(i),1), (a)[i]=(v))" + }, + "unit_kind": "macro", + "unit_name": "stbds_arrins" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_arrmaybegrow' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 558, + "column": 1, + "source_line": "#define stbds_arrmaybegrow(a,n) ((!(a) || stbds_header(a)->length + (n) > stbds_header(a)->capacity) \\" + }, + "unit_kind": "macro", + "unit_name": "stbds_arrmaybegrow" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_arrgrow' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 561, + "column": 1, + "source_line": "#define stbds_arrgrow(a,b,c) ((a) = stbds_arrgrowf_wrapper((a), sizeof *(a), (b), (c)))" + }, + "unit_kind": "macro", + "unit_name": "stbds_arrgrow" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_hmput' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 563, + "column": 1, + "source_line": "#define stbds_hmput(t, k, v) \\" + }, + "unit_kind": "macro", + "unit_name": "stbds_hmput" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_hmputs' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 568, + "column": 1, + "source_line": "#define stbds_hmputs(t, s) \\" + }, + "unit_kind": "macro", + "unit_name": "stbds_hmputs" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_hmgeti' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 572, + "column": 1, + "source_line": "#define stbds_hmgeti(t,k) \\" + }, + "unit_kind": "macro", + "unit_name": "stbds_hmgeti" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_hmgeti_ts' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 576, + "column": 1, + "source_line": "#define stbds_hmgeti_ts(t,k,temp) \\" + }, + "unit_kind": "macro", + "unit_name": "stbds_hmgeti_ts" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_hmgetp' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 580, + "column": 1, + "source_line": "#define stbds_hmgetp(t, k) \\" + }, + "unit_kind": "macro", + "unit_name": "stbds_hmgetp" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_hmgetp_ts' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 583, + "column": 1, + "source_line": "#define stbds_hmgetp_ts(t, k, temp) \\" + }, + "unit_kind": "macro", + "unit_name": "stbds_hmgetp_ts" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_hmdel' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 586, + "column": 1, + "source_line": "#define stbds_hmdel(t,k) \\" + }, + "unit_kind": "macro", + "unit_name": "stbds_hmdel" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_hmdefault' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 589, + "column": 1, + "source_line": "#define stbds_hmdefault(t, v) \\" + }, + "unit_kind": "macro", + "unit_name": "stbds_hmdefault" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_hmdefaults' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 592, + "column": 1, + "source_line": "#define stbds_hmdefaults(t, s) \\" + }, + "unit_kind": "macro", + "unit_name": "stbds_hmdefaults" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_hmfree' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 595, + "column": 1, + "source_line": "#define stbds_hmfree(p) \\" + }, + "unit_kind": "macro", + "unit_name": "stbds_hmfree" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_hmgets' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 598, + "column": 1, + "source_line": "#define stbds_hmgets(t, k) (*stbds_hmgetp(t,k))" + }, + "unit_kind": "macro", + "unit_name": "stbds_hmgets" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_hmget' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 599, + "column": 1, + "source_line": "#define stbds_hmget(t, k) (stbds_hmgetp(t,k)->value)" + }, + "unit_kind": "macro", + "unit_name": "stbds_hmget" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_hmget_ts' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 600, + "column": 1, + "source_line": "#define stbds_hmget_ts(t, k, temp) (stbds_hmgetp_ts(t,k,temp)->value)" + }, + "unit_kind": "macro", + "unit_name": "stbds_hmget_ts" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_hmlen' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 601, + "column": 1, + "source_line": "#define stbds_hmlen(t) ((t) ? (ptrdiff_t) stbds_header((t)-1)->length-1 : 0)" + }, + "unit_kind": "macro", + "unit_name": "stbds_hmlen" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_hmlenu' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 602, + "column": 1, + "source_line": "#define stbds_hmlenu(t) ((t) ? stbds_header((t)-1)->length-1 : 0)" + }, + "unit_kind": "macro", + "unit_name": "stbds_hmlenu" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_hmgetp_null' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 603, + "column": 1, + "source_line": "#define stbds_hmgetp_null(t,k) (stbds_hmgeti(t,k) == -1 ? NULL : &(t)[stbds_temp((t)-1)])" + }, + "unit_kind": "macro", + "unit_name": "stbds_hmgetp_null" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_shput' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 605, + "column": 1, + "source_line": "#define stbds_shput(t, k, v) \\" + }, + "unit_kind": "macro", + "unit_name": "stbds_shput" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_shputi' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 609, + "column": 1, + "source_line": "#define stbds_shputi(t, k, v) \\" + }, + "unit_kind": "macro", + "unit_name": "stbds_shputi" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_shputs' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 613, + "column": 1, + "source_line": "#define stbds_shputs(t, s) \\" + }, + "unit_kind": "macro", + "unit_name": "stbds_shputs" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_pshput' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 618, + "column": 1, + "source_line": "#define stbds_pshput(t, p) \\" + }, + "unit_kind": "macro", + "unit_name": "stbds_pshput" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_shgeti' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 622, + "column": 1, + "source_line": "#define stbds_shgeti(t,k) \\" + }, + "unit_kind": "macro", + "unit_name": "stbds_shgeti" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_pshgeti' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 626, + "column": 1, + "source_line": "#define stbds_pshgeti(t,k) \\" + }, + "unit_kind": "macro", + "unit_name": "stbds_pshgeti" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_shgetp' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 630, + "column": 1, + "source_line": "#define stbds_shgetp(t, k) \\" + }, + "unit_kind": "macro", + "unit_name": "stbds_shgetp" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_pshget' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 633, + "column": 1, + "source_line": "#define stbds_pshget(t, k) \\" + }, + "unit_kind": "macro", + "unit_name": "stbds_pshget" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_shdel' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 636, + "column": 1, + "source_line": "#define stbds_shdel(t,k) \\" + }, + "unit_kind": "macro", + "unit_name": "stbds_shdel" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_pshdel' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 638, + "column": 1, + "source_line": "#define stbds_pshdel(t,k) \\" + }, + "unit_kind": "macro", + "unit_name": "stbds_pshdel" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_sh_new_arena' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 641, + "column": 1, + "source_line": "#define stbds_sh_new_arena(t) \\" + }, + "unit_kind": "macro", + "unit_name": "stbds_sh_new_arena" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_sh_new_strdup' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 643, + "column": 1, + "source_line": "#define stbds_sh_new_strdup(t) \\" + }, + "unit_kind": "macro", + "unit_name": "stbds_sh_new_strdup" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_shdefault' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 646, + "column": 1, + "source_line": "#define stbds_shdefault(t, v) stbds_hmdefault(t,v)" + }, + "unit_kind": "macro", + "unit_name": "stbds_shdefault" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_shdefaults' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 647, + "column": 1, + "source_line": "#define stbds_shdefaults(t, s) stbds_hmdefaults(t,s)" + }, + "unit_kind": "macro", + "unit_name": "stbds_shdefaults" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_shgets' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 652, + "column": 1, + "source_line": "#define stbds_shgets(t, k) (*stbds_shgetp(t,k))" + }, + "unit_kind": "macro", + "unit_name": "stbds_shgets" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_shget' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 653, + "column": 1, + "source_line": "#define stbds_shget(t, k) (stbds_shgetp(t,k)->value)" + }, + "unit_kind": "macro", + "unit_name": "stbds_shget" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_shgetp_null' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 654, + "column": 1, + "source_line": "#define stbds_shgetp_null(t,k) (stbds_shgeti(t,k) == -1 ? NULL : &(t)[stbds_temp((t)-1)])" + }, + "unit_kind": "macro", + "unit_name": "stbds_shgetp_null" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_shmode_func_wrapper' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 721, + "column": 1, + "source_line": "#define stbds_shmode_func_wrapper(t,e,m) stbds_shmode_func(e,m)" + }, + "unit_kind": "macro", + "unit_name": "stbds_shmode_func_wrapper" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBDS_ASSERT' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 738, + "column": 1, + "source_line": "#define STBDS_ASSERT(x) ((void) 0)" + }, + "unit_kind": "macro", + "unit_name": "STBDS_ASSERT" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBDS_STATS' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 742, + "column": 1, + "source_line": "#define STBDS_STATS(x) x" + }, + "unit_kind": "macro", + "unit_name": "STBDS_STATS" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBDS_STATS' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 752, + "column": 1, + "source_line": "#define STBDS_STATS(x)" + }, + "unit_kind": "macro", + "unit_name": "STBDS_STATS" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBDS_ALIGN_FWD' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 819, + "column": 1, + "source_line": "#define STBDS_ALIGN_FWD(n,a) (((n) + (a) - 1) & ~((a)-1))" + }, + "unit_kind": "macro", + "unit_name": "STBDS_ALIGN_FWD" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBDS_INDEX_IN_USE' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 844, + "column": 1, + "source_line": "#define STBDS_INDEX_IN_USE(x) ((x) >= 0)" + }, + "unit_kind": "macro", + "unit_name": "STBDS_INDEX_IN_USE" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_load_32_or_64' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 856, + "column": 1, + "source_line": "#define stbds_load_32_or_64(var, temp, v32, v64_hi, v64_lo) \\" + }, + "unit_kind": "macro", + "unit_name": "stbds_load_32_or_64" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBDS_ROTATE_LEFT' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 1013, + "column": 1, + "source_line": "#define STBDS_ROTATE_LEFT(val, n) (((val) << (n)) | ((val) >> (STBDS_SIZE_T_BITS - (n))))" + }, + "unit_kind": "macro", + "unit_name": "STBDS_ROTATE_LEFT" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBDS_ROTATE_RIGHT' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 1014, + "column": 1, + "source_line": "#define STBDS_ROTATE_RIGHT(val, n) (((val) >> (n)) | ((val) << (STBDS_SIZE_T_BITS - (n))))" + }, + "unit_kind": "macro", + "unit_name": "STBDS_ROTATE_RIGHT" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBDS_SIPROUND' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 1073, + "column": 3, + "source_line": " #define STBDS_SIPROUND() \\" + }, + "unit_kind": "macro", + "unit_name": "STBDS_SIPROUND" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBDS_HASH_TO_ARR' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 1211, + "column": 1, + "source_line": "#define STBDS_HASH_TO_ARR(x,elemsize) ((char*) (x) - (elemsize))" + }, + "unit_kind": "macro", + "unit_name": "STBDS_HASH_TO_ARR" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBDS_ARR_TO_HASH' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 1212, + "column": 1, + "source_line": "#define STBDS_ARR_TO_HASH(x,elemsize) ((char*) (x) + (elemsize))" + }, + "unit_kind": "macro", + "unit_name": "STBDS_ARR_TO_HASH" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbds_hash_table' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 1214, + "column": 1, + "source_line": "#define stbds_hash_table(a) ((stbds_hash_index *) stbds_header(a)->hash_table)" + }, + "unit_kind": "macro", + "unit_name": "stbds_hash_table" + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '\"C\"'.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 471, + "column": 1, + "source_line": "extern \"C\" {" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: ' static T * stbds_arrgrowf_wrapper(T *a, size_t elemsize, size_t addlen, size_t min_cap)'.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 693, + "column": 1, + "source_line": "template static T * stbds_arrgrowf_wrapper(T *a, size_t elemsize, size_t addlen, size_t min_cap) {" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: ' static T * stbds_hmget_key_wrapper(T *a, size_t elemsize, void *key, size_t keysize, int mode)'.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 696, + "column": 1, + "source_line": "template static T * stbds_hmget_key_wrapper(T *a, size_t elemsize, void *key, size_t keysize, int mode) {" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: ' static T * stbds_hmget_key_ts_wrapper(T *a, size_t elemsize, void *key, size_t keysize, ptrdiff_t *temp, int mode)'.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 699, + "column": 1, + "source_line": "template static T * stbds_hmget_key_ts_wrapper(T *a, size_t elemsize, void *key, size_t keysize, ptrdiff_t *temp, int mode) {" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: ' static T * stbds_hmput_default_wrapper(T *a, size_t elemsize)'.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 702, + "column": 1, + "source_line": "template static T * stbds_hmput_default_wrapper(T *a, size_t elemsize) {" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: ' static T * stbds_hmput_key_wrapper(T *a, size_t elemsize, void *key, size_t keysize, int mode)'.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 705, + "column": 1, + "source_line": "template static T * stbds_hmput_key_wrapper(T *a, size_t elemsize, void *key, size_t keysize, int mode) {" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: ' static T * stbds_hmdel_key_wrapper(T *a, size_t elemsize, void *key, size_t keysize, size_t keyoffset, int mode)'.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 708, + "column": 1, + "source_line": "template static T * stbds_hmdel_key_wrapper(T *a, size_t elemsize, void *key, size_t keysize, size_t keyoffset, int mode){" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'stbds_shmode_func_wrapper'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_ds.h", + "line": 711, + "column": 1, + "source_line": "template static T * stbds_shmode_func_wrapper(T *, size_t elemsize, int mode) {" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbds_shmode_func_wrapper" + } + ] +} diff --git a/tests/parser/c/fixtures/stb/stb_dxt.json b/tests/parser/c/fixtures/stb/stb_dxt.json new file mode 100644 index 000000000..abdfef9dc --- /dev/null +++ b/tests/parser/c/fixtures/stb/stb_dxt.json @@ -0,0 +1,4213 @@ +{ + "files": { + "stb/stb_dxt.h": { + "filename": "stb/stb_dxt.h", + "language": "c", + "parser_status": "partial", + "preprocessing": "raw", + "functions": [ + { + "name": "stb__Mul8Bit", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 164, + "column": 1, + "source_line": "static int stb__Mul8Bit(int a, int b)" + }, + "start": { + "filename": "stb/stb_dxt.h", + "line": 164, + "column": 1, + "source_line": "static int stb__Mul8Bit(int a, int b)" + }, + "end": { + "filename": "stb/stb_dxt.h", + "line": 168, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb__From16Bit", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "out", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *out", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *out", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "v", + "type": { + "model": "CUnsignedShort", + "qualifiers": [], + "source_text": "unsigned short v" + }, + "declared_type": { + "model": "CUnsignedShort", + "qualifiers": [], + "source_text": "unsigned short v" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 170, + "column": 1, + "source_line": "static void stb__From16Bit(unsigned char *out, unsigned short v)" + }, + "start": { + "filename": "stb/stb_dxt.h", + "line": 170, + "column": 1, + "source_line": "static void stb__From16Bit(unsigned char *out, unsigned short v)" + }, + "end": { + "filename": "stb/stb_dxt.h", + "line": 181, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb__As16Bit", + "result_type": { + "model": "CUnsignedShort", + "qualifiers": [], + "source_text": "unsigned short" + }, + "parameters": [ + { + "name": "r", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int r" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int r" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "g", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int g" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int g" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 183, + "column": 1, + "source_line": "static unsigned short stb__As16Bit(int r, int g, int b)" + }, + "start": { + "filename": "stb/stb_dxt.h", + "line": 183, + "column": 1, + "source_line": "static unsigned short stb__As16Bit(int r, int g, int b)" + }, + "end": { + "filename": "stb/stb_dxt.h", + "line": 186, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb__Lerp13", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 189, + "column": 1, + "source_line": "static int stb__Lerp13(int a, int b)" + }, + "start": { + "filename": "stb/stb_dxt.h", + "line": 189, + "column": 1, + "source_line": "static int stb__Lerp13(int a, int b)" + }, + "end": { + "filename": "stb/stb_dxt.h", + "line": 199, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb__Lerp13RGB", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "out", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *out", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *out", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p1", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *p1", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *p1", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p2", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *p2", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *p2", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 202, + "column": 1, + "source_line": "static void stb__Lerp13RGB(unsigned char *out, unsigned char *p1, unsigned char *p2)" + }, + "start": { + "filename": "stb/stb_dxt.h", + "line": 202, + "column": 1, + "source_line": "static void stb__Lerp13RGB(unsigned char *out, unsigned char *p1, unsigned char *p2)" + }, + "end": { + "filename": "stb/stb_dxt.h", + "line": 207, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb__EvalColors", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "color", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *color", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *color", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c0", + "type": { + "model": "CUnsignedShort", + "qualifiers": [], + "source_text": "unsigned short c0" + }, + "declared_type": { + "model": "CUnsignedShort", + "qualifiers": [], + "source_text": "unsigned short c0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c1", + "type": { + "model": "CUnsignedShort", + "qualifiers": [], + "source_text": "unsigned short c1" + }, + "declared_type": { + "model": "CUnsignedShort", + "qualifiers": [], + "source_text": "unsigned short c1" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 211, + "column": 1, + "source_line": "static void stb__EvalColors(unsigned char *color,unsigned short c0,unsigned short c1)" + }, + "start": { + "filename": "stb/stb_dxt.h", + "line": 211, + "column": 1, + "source_line": "static void stb__EvalColors(unsigned char *color,unsigned short c0,unsigned short c1)" + }, + "end": { + "filename": "stb/stb_dxt.h", + "line": 217, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb__MatchColorsBlock", + "result_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int" + }, + "parameters": [ + { + "name": "block", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *block", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *block", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "color", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *color", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *color", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 220, + "column": 1, + "source_line": "static unsigned int stb__MatchColorsBlock(unsigned char *block, unsigned char *color)" + }, + "start": { + "filename": "stb/stb_dxt.h", + "line": 220, + "column": 1, + "source_line": "static unsigned int stb__MatchColorsBlock(unsigned char *block, unsigned char *color)" + }, + "end": { + "filename": "stb/stb_dxt.h", + "line": 260, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb__OptimizeColorsBlock", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "block", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *block", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *block", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "pmax16", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned short *pmax16", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedShort", + "qualifiers": [], + "source_text": "unsigned short" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned short *pmax16", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedShort", + "qualifiers": [], + "source_text": "unsigned short" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "pmin16", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned short *pmin16", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedShort", + "qualifiers": [], + "source_text": "unsigned short" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned short *pmin16", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedShort", + "qualifiers": [], + "source_text": "unsigned short" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 263, + "column": 1, + "source_line": "static void stb__OptimizeColorsBlock(unsigned char *block, unsigned short *pmax16, unsigned short *pmin16)" + }, + "start": { + "filename": "stb/stb_dxt.h", + "line": 263, + "column": 1, + "source_line": "static void stb__OptimizeColorsBlock(unsigned char *block, unsigned short *pmax16, unsigned short *pmin16)" + }, + "end": { + "filename": "stb/stb_dxt.h", + "line": 367, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb__Quantize5", + "result_type": { + "model": "CUnsignedShort", + "qualifiers": [], + "source_text": "unsigned short" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 381, + "column": 1, + "source_line": "static unsigned short stb__Quantize5(float x)" + }, + "start": { + "filename": "stb/stb_dxt.h", + "line": 381, + "column": 1, + "source_line": "static unsigned short stb__Quantize5(float x)" + }, + "end": { + "filename": "stb/stb_dxt.h", + "line": 388, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb__Quantize6", + "result_type": { + "model": "CUnsignedShort", + "qualifiers": [], + "source_text": "unsigned short" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 390, + "column": 1, + "source_line": "static unsigned short stb__Quantize6(float x)" + }, + "start": { + "filename": "stb/stb_dxt.h", + "line": 390, + "column": 1, + "source_line": "static unsigned short stb__Quantize6(float x)" + }, + "end": { + "filename": "stb/stb_dxt.h", + "line": 397, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb__RefineBlock", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "block", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *block", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *block", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "pmax16", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned short *pmax16", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedShort", + "qualifiers": [], + "source_text": "unsigned short" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned short *pmax16", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedShort", + "qualifiers": [], + "source_text": "unsigned short" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "pmin16", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned short *pmin16", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedShort", + "qualifiers": [], + "source_text": "unsigned short" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned short *pmin16", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedShort", + "qualifiers": [], + "source_text": "unsigned short" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mask", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int mask" + }, + "declared_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int mask" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 402, + "column": 1, + "source_line": "static int stb__RefineBlock(unsigned char *block, unsigned short *pmax16, unsigned short *pmin16, unsigned int mask)" + }, + "start": { + "filename": "stb/stb_dxt.h", + "line": 402, + "column": 1, + "source_line": "static int stb__RefineBlock(unsigned char *block, unsigned short *pmax16, unsigned short *pmin16, unsigned int mask)" + }, + "end": { + "filename": "stb/stb_dxt.h", + "line": 476, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb__CompressColorBlock", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "dest", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *dest", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *dest", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "block", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *block", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *block", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mode", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mode" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mode" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 479, + "column": 1, + "source_line": "static void stb__CompressColorBlock(unsigned char *dest, unsigned char *block, int mode)" + }, + "start": { + "filename": "stb/stb_dxt.h", + "line": 479, + "column": 1, + "source_line": "static void stb__CompressColorBlock(unsigned char *dest, unsigned char *block, int mode)" + }, + "end": { + "filename": "stb/stb_dxt.h", + "line": 544, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb__CompressAlphaBlock", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "dest", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *dest", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *dest", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "src", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *src", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *src", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "stride", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int stride" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int stride" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 547, + "column": 1, + "source_line": "static void stb__CompressAlphaBlock(unsigned char *dest,unsigned char *src, int stride)" + }, + "start": { + "filename": "stb/stb_dxt.h", + "line": 547, + "column": 1, + "source_line": "static void stb__CompressAlphaBlock(unsigned char *dest,unsigned char *src, int stride)" + }, + "end": { + "filename": "stb/stb_dxt.h", + "line": 597, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_compress_dxt_block", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "dest", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *dest", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *dest", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "src", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const unsigned char *src", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [ + "const" + ], + "source_text": "const unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const unsigned char *src", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [ + "const" + ], + "source_text": "const unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "alpha", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int alpha" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int alpha" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mode", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mode" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mode" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 599, + "column": 1, + "source_line": "void stb_compress_dxt_block(unsigned char *dest, const unsigned char *src, int alpha, int mode)" + }, + "start": { + "filename": "stb/stb_dxt.h", + "line": 599, + "column": 1, + "source_line": "void stb_compress_dxt_block(unsigned char *dest, const unsigned char *src, int alpha, int mode)" + }, + "end": { + "filename": "stb/stb_dxt.h", + "line": 615, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_compress_bc4_block", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "dest", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *dest", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *dest", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "src", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const unsigned char *src", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [ + "const" + ], + "source_text": "const unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const unsigned char *src", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [ + "const" + ], + "source_text": "const unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 617, + "column": 1, + "source_line": "void stb_compress_bc4_block(unsigned char *dest, const unsigned char *src)" + }, + "start": { + "filename": "stb/stb_dxt.h", + "line": 617, + "column": 1, + "source_line": "void stb_compress_bc4_block(unsigned char *dest, const unsigned char *src)" + }, + "end": { + "filename": "stb/stb_dxt.h", + "line": 620, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_compress_bc5_block", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "dest", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *dest", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *dest", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "src", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const unsigned char *src", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [ + "const" + ], + "source_text": "const unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const unsigned char *src", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [ + "const" + ], + "source_text": "const unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 622, + "column": 1, + "source_line": "void stb_compress_bc5_block(unsigned char *dest, const unsigned char *src)" + }, + "start": { + "filename": "stb/stb_dxt.h", + "line": 622, + "column": 1, + "source_line": "void stb_compress_bc5_block(unsigned char *dest, const unsigned char *src)" + }, + "end": { + "filename": "stb/stb_dxt.h", + "line": 626, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "main", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "unspecified", + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 634, + "column": 1, + "source_line": "int main()" + }, + "start": { + "filename": "stb/stb_dxt.h", + "line": 634, + "column": 1, + "source_line": "int main()" + }, + "end": { + "filename": "stb/stb_dxt.h", + "line": 676, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + } + ], + "structs": [], + "unions": [], + "enums": [], + "typedefs": [], + "variables": [], + "macros": [ + { + "name": "STB_INCLUDE_STB_DXT_H", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 41, + "column": 1, + "source_line": "#define STB_INCLUDE_STB_DXT_H" + } + }, + { + "name": "STBDDEF", + "value": "static", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 48, + "column": 1, + "source_line": "#define STBDDEF static" + } + }, + { + "name": "STBDDEF", + "value": "extern", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 50, + "column": 1, + "source_line": "#define STBDDEF extern" + } + }, + { + "name": "STB_DXT_NORMAL", + "value": "0", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 54, + "column": 1, + "source_line": "#define STB_DXT_NORMAL 0" + } + }, + { + "name": "STB_DXT_DITHER", + "value": "1", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 55, + "column": 1, + "source_line": "#define STB_DXT_DITHER 1 // use dithering. was always dubious, now deprecated. does nothing!" + } + }, + { + "name": "STB_DXT_HIGHQUAL", + "value": "2", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 56, + "column": 1, + "source_line": "#define STB_DXT_HIGHQUAL 2 // high quality mode, does two refinement steps instead of 1. ~30-40% slower." + } + }, + { + "name": "STB_COMPRESS_DXT_BLOCK", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 62, + "column": 1, + "source_line": "#define STB_COMPRESS_DXT_BLOCK" + } + }, + { + "name": "STBD_FABS", + "value": "fabs(x)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 92, + "column": 1, + "source_line": "#define STBD_FABS(x) fabs(x)" + } + } + ], + "includes": [ + { + "target": "stdlib.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 85, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "math.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 88, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "stdio.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 632, + "column": 1, + "source_line": "#include " + } + } + ], + "raw_directives": [ + { + "directive": "ifndef", + "argument": "STB_INCLUDE_STB_DXT_H", + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 40, + "column": 1, + "source_line": "#ifndef STB_INCLUDE_STB_DXT_H" + } + }, + { + "directive": "ifdef", + "argument": "__cplusplus", + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 43, + "column": 1, + "source_line": "#ifdef __cplusplus" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 45, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STB_DXT_STATIC", + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 47, + "column": 1, + "source_line": "#ifdef STB_DXT_STATIC" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 49, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 51, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "__cplusplus", + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 64, + "column": 1, + "source_line": "#ifdef __cplusplus" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 66, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 67, + "column": 1, + "source_line": "#endif // STB_INCLUDE_STB_DXT_H" + } + }, + { + "directive": "ifdef", + "argument": "STB_DXT_IMPLEMENTATION", + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 69, + "column": 1, + "source_line": "#ifdef STB_DXT_IMPLEMENTATION" + } + }, + { + "directive": "if", + "argument": "!defined(STBD_FABS)", + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 87, + "column": 1, + "source_line": "#if !defined(STBD_FABS)" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 89, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBD_FABS", + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 91, + "column": 1, + "source_line": "#ifndef STBD_FABS" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 93, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STB_DXT_USE_ROUNDING_BIAS", + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 191, + "column": 1, + "source_line": "#ifdef STB_DXT_USE_ROUNDING_BIAS" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 194, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 198, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 627, + "column": 1, + "source_line": "#endif // STB_DXT_IMPLEMENTATION" + } + }, + { + "directive": "ifdef", + "argument": "STB_DXT_GENERATE_TABLES", + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 631, + "column": 1, + "source_line": "#ifdef STB_DXT_GENERATE_TABLES" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 677, + "column": 1, + "source_line": "#endif" + } + } + ], + "macro_dependencies": [], + "diagnostics": [ + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBD_FABS' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_dxt.h", + "line": 92, + "column": 1, + "source_line": "#define STBD_FABS(x) fabs(x)" + }, + "unit_kind": "macro", + "unit_name": "STBD_FABS" + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '\"C\"'.", + "severity": "warning", + "location": { + "filename": "stb/stb_dxt.h", + "line": 44, + "column": 1, + "source_line": "extern \"C\" {" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_dxt.h", + "line": 95, + "column": 1, + "source_line": "static const unsigned char stb__OMatch5[256][2] = {" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_dxt.h", + "line": 129, + "column": 1, + "source_line": "static const unsigned char stb__OMatch6[256][2] = {" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_dxt.h", + "line": 369, + "column": 1, + "source_line": "static const float stb__midpoints5[32] = {" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_dxt.h", + "line": 374, + "column": 1, + "source_line": "static const float stb__midpoints6[64] = {" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + } + ] + } + }, + "functions": { + "stb__Mul8Bit": { + "name": "stb__Mul8Bit", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 164, + "column": 1, + "source_line": "static int stb__Mul8Bit(int a, int b)" + }, + "start": { + "filename": "stb/stb_dxt.h", + "line": 164, + "column": 1, + "source_line": "static int stb__Mul8Bit(int a, int b)" + }, + "end": { + "filename": "stb/stb_dxt.h", + "line": 168, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb__From16Bit": { + "name": "stb__From16Bit", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "out", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *out", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *out", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "v", + "type": { + "model": "CUnsignedShort", + "qualifiers": [], + "source_text": "unsigned short v" + }, + "declared_type": { + "model": "CUnsignedShort", + "qualifiers": [], + "source_text": "unsigned short v" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 170, + "column": 1, + "source_line": "static void stb__From16Bit(unsigned char *out, unsigned short v)" + }, + "start": { + "filename": "stb/stb_dxt.h", + "line": 170, + "column": 1, + "source_line": "static void stb__From16Bit(unsigned char *out, unsigned short v)" + }, + "end": { + "filename": "stb/stb_dxt.h", + "line": 181, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb__As16Bit": { + "name": "stb__As16Bit", + "result_type": { + "model": "CUnsignedShort", + "qualifiers": [], + "source_text": "unsigned short" + }, + "parameters": [ + { + "name": "r", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int r" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int r" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "g", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int g" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int g" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 183, + "column": 1, + "source_line": "static unsigned short stb__As16Bit(int r, int g, int b)" + }, + "start": { + "filename": "stb/stb_dxt.h", + "line": 183, + "column": 1, + "source_line": "static unsigned short stb__As16Bit(int r, int g, int b)" + }, + "end": { + "filename": "stb/stb_dxt.h", + "line": 186, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb__Lerp13": { + "name": "stb__Lerp13", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 189, + "column": 1, + "source_line": "static int stb__Lerp13(int a, int b)" + }, + "start": { + "filename": "stb/stb_dxt.h", + "line": 189, + "column": 1, + "source_line": "static int stb__Lerp13(int a, int b)" + }, + "end": { + "filename": "stb/stb_dxt.h", + "line": 199, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb__Lerp13RGB": { + "name": "stb__Lerp13RGB", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "out", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *out", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *out", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p1", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *p1", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *p1", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p2", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *p2", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *p2", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 202, + "column": 1, + "source_line": "static void stb__Lerp13RGB(unsigned char *out, unsigned char *p1, unsigned char *p2)" + }, + "start": { + "filename": "stb/stb_dxt.h", + "line": 202, + "column": 1, + "source_line": "static void stb__Lerp13RGB(unsigned char *out, unsigned char *p1, unsigned char *p2)" + }, + "end": { + "filename": "stb/stb_dxt.h", + "line": 207, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb__EvalColors": { + "name": "stb__EvalColors", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "color", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *color", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *color", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c0", + "type": { + "model": "CUnsignedShort", + "qualifiers": [], + "source_text": "unsigned short c0" + }, + "declared_type": { + "model": "CUnsignedShort", + "qualifiers": [], + "source_text": "unsigned short c0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c1", + "type": { + "model": "CUnsignedShort", + "qualifiers": [], + "source_text": "unsigned short c1" + }, + "declared_type": { + "model": "CUnsignedShort", + "qualifiers": [], + "source_text": "unsigned short c1" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 211, + "column": 1, + "source_line": "static void stb__EvalColors(unsigned char *color,unsigned short c0,unsigned short c1)" + }, + "start": { + "filename": "stb/stb_dxt.h", + "line": 211, + "column": 1, + "source_line": "static void stb__EvalColors(unsigned char *color,unsigned short c0,unsigned short c1)" + }, + "end": { + "filename": "stb/stb_dxt.h", + "line": 217, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb__MatchColorsBlock": { + "name": "stb__MatchColorsBlock", + "result_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int" + }, + "parameters": [ + { + "name": "block", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *block", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *block", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "color", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *color", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *color", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 220, + "column": 1, + "source_line": "static unsigned int stb__MatchColorsBlock(unsigned char *block, unsigned char *color)" + }, + "start": { + "filename": "stb/stb_dxt.h", + "line": 220, + "column": 1, + "source_line": "static unsigned int stb__MatchColorsBlock(unsigned char *block, unsigned char *color)" + }, + "end": { + "filename": "stb/stb_dxt.h", + "line": 260, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb__OptimizeColorsBlock": { + "name": "stb__OptimizeColorsBlock", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "block", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *block", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *block", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "pmax16", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned short *pmax16", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedShort", + "qualifiers": [], + "source_text": "unsigned short" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned short *pmax16", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedShort", + "qualifiers": [], + "source_text": "unsigned short" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "pmin16", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned short *pmin16", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedShort", + "qualifiers": [], + "source_text": "unsigned short" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned short *pmin16", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedShort", + "qualifiers": [], + "source_text": "unsigned short" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 263, + "column": 1, + "source_line": "static void stb__OptimizeColorsBlock(unsigned char *block, unsigned short *pmax16, unsigned short *pmin16)" + }, + "start": { + "filename": "stb/stb_dxt.h", + "line": 263, + "column": 1, + "source_line": "static void stb__OptimizeColorsBlock(unsigned char *block, unsigned short *pmax16, unsigned short *pmin16)" + }, + "end": { + "filename": "stb/stb_dxt.h", + "line": 367, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb__Quantize5": { + "name": "stb__Quantize5", + "result_type": { + "model": "CUnsignedShort", + "qualifiers": [], + "source_text": "unsigned short" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 381, + "column": 1, + "source_line": "static unsigned short stb__Quantize5(float x)" + }, + "start": { + "filename": "stb/stb_dxt.h", + "line": 381, + "column": 1, + "source_line": "static unsigned short stb__Quantize5(float x)" + }, + "end": { + "filename": "stb/stb_dxt.h", + "line": 388, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb__Quantize6": { + "name": "stb__Quantize6", + "result_type": { + "model": "CUnsignedShort", + "qualifiers": [], + "source_text": "unsigned short" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 390, + "column": 1, + "source_line": "static unsigned short stb__Quantize6(float x)" + }, + "start": { + "filename": "stb/stb_dxt.h", + "line": 390, + "column": 1, + "source_line": "static unsigned short stb__Quantize6(float x)" + }, + "end": { + "filename": "stb/stb_dxt.h", + "line": 397, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb__RefineBlock": { + "name": "stb__RefineBlock", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "block", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *block", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *block", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "pmax16", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned short *pmax16", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedShort", + "qualifiers": [], + "source_text": "unsigned short" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned short *pmax16", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedShort", + "qualifiers": [], + "source_text": "unsigned short" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "pmin16", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned short *pmin16", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedShort", + "qualifiers": [], + "source_text": "unsigned short" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned short *pmin16", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedShort", + "qualifiers": [], + "source_text": "unsigned short" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mask", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int mask" + }, + "declared_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int mask" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 402, + "column": 1, + "source_line": "static int stb__RefineBlock(unsigned char *block, unsigned short *pmax16, unsigned short *pmin16, unsigned int mask)" + }, + "start": { + "filename": "stb/stb_dxt.h", + "line": 402, + "column": 1, + "source_line": "static int stb__RefineBlock(unsigned char *block, unsigned short *pmax16, unsigned short *pmin16, unsigned int mask)" + }, + "end": { + "filename": "stb/stb_dxt.h", + "line": 476, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb__CompressColorBlock": { + "name": "stb__CompressColorBlock", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "dest", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *dest", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *dest", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "block", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *block", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *block", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mode", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mode" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mode" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 479, + "column": 1, + "source_line": "static void stb__CompressColorBlock(unsigned char *dest, unsigned char *block, int mode)" + }, + "start": { + "filename": "stb/stb_dxt.h", + "line": 479, + "column": 1, + "source_line": "static void stb__CompressColorBlock(unsigned char *dest, unsigned char *block, int mode)" + }, + "end": { + "filename": "stb/stb_dxt.h", + "line": 544, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb__CompressAlphaBlock": { + "name": "stb__CompressAlphaBlock", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "dest", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *dest", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *dest", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "src", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *src", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *src", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "stride", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int stride" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int stride" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 547, + "column": 1, + "source_line": "static void stb__CompressAlphaBlock(unsigned char *dest,unsigned char *src, int stride)" + }, + "start": { + "filename": "stb/stb_dxt.h", + "line": 547, + "column": 1, + "source_line": "static void stb__CompressAlphaBlock(unsigned char *dest,unsigned char *src, int stride)" + }, + "end": { + "filename": "stb/stb_dxt.h", + "line": 597, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_compress_dxt_block": { + "name": "stb_compress_dxt_block", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "dest", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *dest", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *dest", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "src", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const unsigned char *src", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [ + "const" + ], + "source_text": "const unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const unsigned char *src", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [ + "const" + ], + "source_text": "const unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "alpha", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int alpha" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int alpha" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mode", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mode" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mode" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 599, + "column": 1, + "source_line": "void stb_compress_dxt_block(unsigned char *dest, const unsigned char *src, int alpha, int mode)" + }, + "start": { + "filename": "stb/stb_dxt.h", + "line": 599, + "column": 1, + "source_line": "void stb_compress_dxt_block(unsigned char *dest, const unsigned char *src, int alpha, int mode)" + }, + "end": { + "filename": "stb/stb_dxt.h", + "line": 615, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_compress_bc4_block": { + "name": "stb_compress_bc4_block", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "dest", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *dest", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *dest", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "src", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const unsigned char *src", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [ + "const" + ], + "source_text": "const unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const unsigned char *src", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [ + "const" + ], + "source_text": "const unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 617, + "column": 1, + "source_line": "void stb_compress_bc4_block(unsigned char *dest, const unsigned char *src)" + }, + "start": { + "filename": "stb/stb_dxt.h", + "line": 617, + "column": 1, + "source_line": "void stb_compress_bc4_block(unsigned char *dest, const unsigned char *src)" + }, + "end": { + "filename": "stb/stb_dxt.h", + "line": 620, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_compress_bc5_block": { + "name": "stb_compress_bc5_block", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "dest", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *dest", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *dest", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "src", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const unsigned char *src", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [ + "const" + ], + "source_text": "const unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const unsigned char *src", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [ + "const" + ], + "source_text": "const unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 622, + "column": 1, + "source_line": "void stb_compress_bc5_block(unsigned char *dest, const unsigned char *src)" + }, + "start": { + "filename": "stb/stb_dxt.h", + "line": 622, + "column": 1, + "source_line": "void stb_compress_bc5_block(unsigned char *dest, const unsigned char *src)" + }, + "end": { + "filename": "stb/stb_dxt.h", + "line": 626, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "main": { + "name": "main", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "unspecified", + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 634, + "column": 1, + "source_line": "int main()" + }, + "start": { + "filename": "stb/stb_dxt.h", + "line": 634, + "column": 1, + "source_line": "int main()" + }, + "end": { + "filename": "stb/stb_dxt.h", + "line": 676, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + } + }, + "structs": {}, + "unions": {}, + "enums": {}, + "typedefs": {}, + "variables": {}, + "macros": { + "STB_INCLUDE_STB_DXT_H": { + "name": "STB_INCLUDE_STB_DXT_H", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 41, + "column": 1, + "source_line": "#define STB_INCLUDE_STB_DXT_H" + } + }, + "STBDDEF": { + "name": "STBDDEF", + "value": "extern", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 50, + "column": 1, + "source_line": "#define STBDDEF extern" + } + }, + "STB_DXT_NORMAL": { + "name": "STB_DXT_NORMAL", + "value": "0", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 54, + "column": 1, + "source_line": "#define STB_DXT_NORMAL 0" + } + }, + "STB_DXT_DITHER": { + "name": "STB_DXT_DITHER", + "value": "1", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 55, + "column": 1, + "source_line": "#define STB_DXT_DITHER 1 // use dithering. was always dubious, now deprecated. does nothing!" + } + }, + "STB_DXT_HIGHQUAL": { + "name": "STB_DXT_HIGHQUAL", + "value": "2", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 56, + "column": 1, + "source_line": "#define STB_DXT_HIGHQUAL 2 // high quality mode, does two refinement steps instead of 1. ~30-40% slower." + } + }, + "STB_COMPRESS_DXT_BLOCK": { + "name": "STB_COMPRESS_DXT_BLOCK", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 62, + "column": 1, + "source_line": "#define STB_COMPRESS_DXT_BLOCK" + } + }, + "STBD_FABS": { + "name": "STBD_FABS", + "value": "fabs(x)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 92, + "column": 1, + "source_line": "#define STBD_FABS(x) fabs(x)" + } + } + }, + "includes": { + "stb/stb_dxt.h:stdlib.h": { + "target": "stdlib.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 85, + "column": 1, + "source_line": "#include " + } + }, + "stb/stb_dxt.h:math.h": { + "target": "math.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 88, + "column": 1, + "source_line": "#include " + } + }, + "stb/stb_dxt.h:stdio.h": { + "target": "stdio.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_dxt.h", + "line": 632, + "column": 1, + "source_line": "#include " + } + } + }, + "functions_by_file": { + "stb/stb_dxt.h": [ + "stb__Mul8Bit", + "stb__From16Bit", + "stb__As16Bit", + "stb__Lerp13", + "stb__Lerp13RGB", + "stb__EvalColors", + "stb__MatchColorsBlock", + "stb__OptimizeColorsBlock", + "stb__Quantize5", + "stb__Quantize6", + "stb__RefineBlock", + "stb__CompressColorBlock", + "stb__CompressAlphaBlock", + "stb_compress_dxt_block", + "stb_compress_bc4_block", + "stb_compress_bc5_block", + "main" + ] + }, + "enum_constants": {}, + "include_graph": { + "stb/stb_dxt.h": [] + }, + "system_includes": { + "stb/stb_dxt.h": [ + "math.h", + "stdio.h", + "stdlib.h" + ] + }, + "unresolved_includes": { + "stb/stb_dxt.h": [] + }, + "header_source_pairs": { + "stb/stb_dxt.h": [] + }, + "diagnostics": [ + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBD_FABS' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_dxt.h", + "line": 92, + "column": 1, + "source_line": "#define STBD_FABS(x) fabs(x)" + }, + "unit_kind": "macro", + "unit_name": "STBD_FABS" + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '\"C\"'.", + "severity": "warning", + "location": { + "filename": "stb/stb_dxt.h", + "line": 44, + "column": 1, + "source_line": "extern \"C\" {" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_dxt.h", + "line": 95, + "column": 1, + "source_line": "static const unsigned char stb__OMatch5[256][2] = {" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_dxt.h", + "line": 129, + "column": 1, + "source_line": "static const unsigned char stb__OMatch6[256][2] = {" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_dxt.h", + "line": 369, + "column": 1, + "source_line": "static const float stb__midpoints5[32] = {" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_dxt.h", + "line": 374, + "column": 1, + "source_line": "static const float stb__midpoints6[64] = {" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + } + ] +} diff --git a/tests/parser/c/fixtures/stb/stb_easy_font.json b/tests/parser/c/fixtures/stb/stb_easy_font.json new file mode 100644 index 000000000..470444508 --- /dev/null +++ b/tests/parser/c/fixtures/stb/stb_easy_font.json @@ -0,0 +1,2029 @@ +{ + "files": { + "stb/stb_easy_font.h": { + "filename": "stb/stb_easy_font.h", + "language": "c", + "parser_status": "partial", + "preprocessing": "raw", + "functions": [ + { + "name": "print_string", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "text", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *text", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *text", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "r", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float r" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float r" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "g", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float g" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float g" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float b" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float b" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_easy_font.h", + "line": 91, + "column": 1, + "source_line": "void print_string(float x, float y, char *text, float r, float g, float b)" + }, + "start": { + "filename": "stb/stb_easy_font.h", + "line": 91, + "column": 1, + "source_line": "void print_string(float x, float y, char *text, float r, float g, float b)" + }, + "end": { + "filename": "stb/stb_easy_font.h", + "line": 103, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_easy_font_draw_segs", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "segs", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *segs", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *segs", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "num_segs", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_segs" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_segs" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "vertical", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int vertical" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int vertical" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stb_easy_font_color", + "name": "stb_easy_font_color", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "c", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char c[4]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "4", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_easy_font.h", + "line": 170, + "column": 4, + "source_line": " unsigned char c[4];" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_easy_font.h:168:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_easy_font.h", + "line": 168, + "column": 1, + "source_line": "typedef struct" + } + }, + "source_location": { + "filename": "stb/stb_easy_font.h", + "line": 168, + "column": 1, + "source_line": "typedef struct" + }, + "declaration_locations": [] + }, + "declared_type": { + "reference": "stb_easy_font_color" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "vbuf", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *vbuf", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *vbuf", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "vbuf_size", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int vbuf_size" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int vbuf_size" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "offset", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int offset" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int offset" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_easy_font.h", + "line": 173, + "column": 1, + "source_line": "static int stb_easy_font_draw_segs(float x, float y, unsigned char *segs, int num_segs, int vertical, stb_easy_font_color c, char *vbuf, int vbuf_size, int offset)" + }, + "start": { + "filename": "stb/stb_easy_font.h", + "line": 173, + "column": 1, + "source_line": "static int stb_easy_font_draw_segs(float x, float y, unsigned char *segs, int num_segs, int vertical, stb_easy_font_color c, char *vbuf, int vbuf_size, int offset)" + }, + "end": { + "filename": "stb/stb_easy_font.h", + "line": 191, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_easy_font_spacing", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "spacing", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float spacing" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float spacing" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_easy_font.h", + "line": 194, + "column": 1, + "source_line": "static void stb_easy_font_spacing(float spacing)" + }, + "start": { + "filename": "stb/stb_easy_font.h", + "line": 194, + "column": 1, + "source_line": "static void stb_easy_font_spacing(float spacing)" + }, + "end": { + "filename": "stb/stb_easy_font.h", + "line": 197, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_easy_font_print", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "text", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *text", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *text", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "color", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char color[4]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char color[4]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "4", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "vertex_buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *vertex_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *vertex_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "vbuf_size", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int vbuf_size" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int vbuf_size" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_easy_font.h", + "line": 199, + "column": 1, + "source_line": "static int stb_easy_font_print(float x, float y, char *text, unsigned char color[4], void *vertex_buffer, int vbuf_size)" + }, + "start": { + "filename": "stb/stb_easy_font.h", + "line": 199, + "column": 1, + "source_line": "static int stb_easy_font_print(float x, float y, char *text, unsigned char color[4], void *vertex_buffer, int vbuf_size)" + }, + "end": { + "filename": "stb/stb_easy_font.h", + "line": 228, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_easy_font_width", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "text", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *text", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *text", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_easy_font.h", + "line": 230, + "column": 1, + "source_line": "static int stb_easy_font_width(char *text)" + }, + "start": { + "filename": "stb/stb_easy_font.h", + "line": 230, + "column": 1, + "source_line": "static int stb_easy_font_width(char *text)" + }, + "end": { + "filename": "stb/stb_easy_font.h", + "line": 246, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_easy_font_height", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "text", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *text", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *text", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_easy_font.h", + "line": 248, + "column": 1, + "source_line": "static int stb_easy_font_height(char *text)" + }, + "start": { + "filename": "stb/stb_easy_font.h", + "line": 248, + "column": 1, + "source_line": "static int stb_easy_font_height(char *text)" + }, + "end": { + "filename": "stb/stb_easy_font.h", + "line": 262, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + } + ], + "structs": [ + { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": "stb_easy_font_info_struct", + "members": [ + { + "name": "advance", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char advance" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_easy_font.h", + "line": 113, + "column": 5, + "source_line": " unsigned char advance;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "h_seg", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char h_seg" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_easy_font.h", + "line": 114, + "column": 5, + "source_line": " unsigned char h_seg;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "v_seg", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char v_seg" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_easy_font.h", + "line": 115, + "column": 5, + "source_line": " unsigned char v_seg;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": null, + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_easy_font.h", + "line": 112, + "column": 1, + "source_line": "static struct stb_easy_font_info_struct {" + } + }, + { + "reference": "struct@stb/stb_easy_font.h:168:1" + } + ], + "unions": [], + "enums": [], + "typedefs": [ + { + "reference": "stb_easy_font_color" + } + ], + "variables": [ + { + "name": "stb_easy_font_charinfo", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "static struct stb_easy_font_info_struct stb_easy_font_charinfo[96]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "96", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "reference": "struct stb_easy_font_info_struct" + } + ] + }, + "storage": [ + "static" + ], + "initializer": { + "source_text": "" + }, + "bit_width": null, + "source_location": { + "filename": "stb/stb_easy_font.h", + "line": 112, + "column": 1, + "source_line": "static struct stb_easy_font_info_struct {" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "stb_easy_font_spacing_val", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "static float stb_easy_font_spacing_val" + }, + "storage": [ + "static" + ], + "initializer": { + "source_text": "0" + }, + "bit_width": null, + "source_location": { + "filename": "stb/stb_easy_font.h", + "line": 193, + "column": 1, + "source_line": "static float stb_easy_font_spacing_val = 0;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "macros": [ + { + "name": "INCLUDE_STB_EASY_FONT_H", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_easy_font.h", + "line": 107, + "column": 1, + "source_line": "#define INCLUDE_STB_EASY_FONT_H" + } + } + ], + "includes": [ + { + "target": "stdlib.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_easy_font.h", + "line": 109, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "math.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_easy_font.h", + "line": 110, + "column": 1, + "source_line": "#include " + } + } + ], + "raw_directives": [ + { + "directive": "if", + "argument": "0", + "source_location": { + "filename": "stb/stb_easy_font.h", + "line": 85, + "column": 1, + "source_line": "#if 0" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_easy_font.h", + "line": 104, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "INCLUDE_STB_EASY_FONT_H", + "source_location": { + "filename": "stb/stb_easy_font.h", + "line": 106, + "column": 1, + "source_line": "#ifndef INCLUDE_STB_EASY_FONT_H" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_easy_font.h", + "line": 263, + "column": 1, + "source_line": "#endif" + } + } + ], + "macro_dependencies": [], + "diagnostics": [ + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_easy_font.h", + "line": 143, + "column": 1, + "source_line": "static unsigned char stb_easy_font_hseg[214] = {" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_easy_font.h", + "line": 155, + "column": 1, + "source_line": "static unsigned char stb_easy_font_vseg[253] = {" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + } + ] + } + }, + "functions": { + "print_string": { + "name": "print_string", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "text", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *text", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *text", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "r", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float r" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float r" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "g", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float g" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float g" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float b" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float b" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_easy_font.h", + "line": 91, + "column": 1, + "source_line": "void print_string(float x, float y, char *text, float r, float g, float b)" + }, + "start": { + "filename": "stb/stb_easy_font.h", + "line": 91, + "column": 1, + "source_line": "void print_string(float x, float y, char *text, float r, float g, float b)" + }, + "end": { + "filename": "stb/stb_easy_font.h", + "line": 103, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_easy_font_draw_segs": { + "name": "stb_easy_font_draw_segs", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "segs", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *segs", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *segs", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "num_segs", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_segs" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_segs" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "vertical", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int vertical" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int vertical" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c", + "type": { + "reference": "stb_easy_font_color" + }, + "declared_type": { + "reference": "stb_easy_font_color" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "vbuf", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *vbuf", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *vbuf", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "vbuf_size", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int vbuf_size" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int vbuf_size" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "offset", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int offset" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int offset" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_easy_font.h", + "line": 173, + "column": 1, + "source_line": "static int stb_easy_font_draw_segs(float x, float y, unsigned char *segs, int num_segs, int vertical, stb_easy_font_color c, char *vbuf, int vbuf_size, int offset)" + }, + "start": { + "filename": "stb/stb_easy_font.h", + "line": 173, + "column": 1, + "source_line": "static int stb_easy_font_draw_segs(float x, float y, unsigned char *segs, int num_segs, int vertical, stb_easy_font_color c, char *vbuf, int vbuf_size, int offset)" + }, + "end": { + "filename": "stb/stb_easy_font.h", + "line": 191, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_easy_font_spacing": { + "name": "stb_easy_font_spacing", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "spacing", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float spacing" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float spacing" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_easy_font.h", + "line": 194, + "column": 1, + "source_line": "static void stb_easy_font_spacing(float spacing)" + }, + "start": { + "filename": "stb/stb_easy_font.h", + "line": 194, + "column": 1, + "source_line": "static void stb_easy_font_spacing(float spacing)" + }, + "end": { + "filename": "stb/stb_easy_font.h", + "line": 197, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_easy_font_print": { + "name": "stb_easy_font_print", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "text", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *text", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *text", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "color", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char color[4]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char color[4]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "4", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "vertex_buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *vertex_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *vertex_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "vbuf_size", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int vbuf_size" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int vbuf_size" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_easy_font.h", + "line": 199, + "column": 1, + "source_line": "static int stb_easy_font_print(float x, float y, char *text, unsigned char color[4], void *vertex_buffer, int vbuf_size)" + }, + "start": { + "filename": "stb/stb_easy_font.h", + "line": 199, + "column": 1, + "source_line": "static int stb_easy_font_print(float x, float y, char *text, unsigned char color[4], void *vertex_buffer, int vbuf_size)" + }, + "end": { + "filename": "stb/stb_easy_font.h", + "line": 228, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_easy_font_width": { + "name": "stb_easy_font_width", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "text", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *text", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *text", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_easy_font.h", + "line": 230, + "column": 1, + "source_line": "static int stb_easy_font_width(char *text)" + }, + "start": { + "filename": "stb/stb_easy_font.h", + "line": 230, + "column": 1, + "source_line": "static int stb_easy_font_width(char *text)" + }, + "end": { + "filename": "stb/stb_easy_font.h", + "line": 246, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_easy_font_height": { + "name": "stb_easy_font_height", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "text", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *text", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *text", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_easy_font.h", + "line": 248, + "column": 1, + "source_line": "static int stb_easy_font_height(char *text)" + }, + "start": { + "filename": "stb/stb_easy_font.h", + "line": 248, + "column": 1, + "source_line": "static int stb_easy_font_height(char *text)" + }, + "end": { + "filename": "stb/stb_easy_font.h", + "line": 262, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + } + }, + "structs": { + "stb_easy_font_info_struct": { + "reference": "struct stb_easy_font_info_struct" + } + }, + "unions": {}, + "enums": {}, + "typedefs": { + "stb_easy_font_color": { + "reference": "stb_easy_font_color" + } + }, + "variables": { + "stb_easy_font_charinfo": { + "name": "stb_easy_font_charinfo", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "static struct stb_easy_font_info_struct stb_easy_font_charinfo[96]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "96", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "reference": "struct stb_easy_font_info_struct" + } + ] + }, + "storage": [ + "static" + ], + "initializer": { + "source_text": "" + }, + "bit_width": null, + "source_location": { + "filename": "stb/stb_easy_font.h", + "line": 112, + "column": 1, + "source_line": "static struct stb_easy_font_info_struct {" + }, + "callback_policy": null, + "declaration_locations": [] + }, + "stb_easy_font_spacing_val": { + "name": "stb_easy_font_spacing_val", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "static float stb_easy_font_spacing_val" + }, + "storage": [ + "static" + ], + "initializer": { + "source_text": "0" + }, + "bit_width": null, + "source_location": { + "filename": "stb/stb_easy_font.h", + "line": 193, + "column": 1, + "source_line": "static float stb_easy_font_spacing_val = 0;" + }, + "callback_policy": null, + "declaration_locations": [] + } + }, + "macros": { + "INCLUDE_STB_EASY_FONT_H": { + "name": "INCLUDE_STB_EASY_FONT_H", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_easy_font.h", + "line": 107, + "column": 1, + "source_line": "#define INCLUDE_STB_EASY_FONT_H" + } + } + }, + "includes": { + "stb/stb_easy_font.h:stdlib.h": { + "target": "stdlib.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_easy_font.h", + "line": 109, + "column": 1, + "source_line": "#include " + } + }, + "stb/stb_easy_font.h:math.h": { + "target": "math.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_easy_font.h", + "line": 110, + "column": 1, + "source_line": "#include " + } + } + }, + "functions_by_file": { + "stb/stb_easy_font.h": [ + "print_string", + "stb_easy_font_draw_segs", + "stb_easy_font_spacing", + "stb_easy_font_print", + "stb_easy_font_width", + "stb_easy_font_height" + ] + }, + "enum_constants": {}, + "include_graph": { + "stb/stb_easy_font.h": [] + }, + "system_includes": { + "stb/stb_easy_font.h": [ + "math.h", + "stdlib.h" + ] + }, + "unresolved_includes": { + "stb/stb_easy_font.h": [] + }, + "header_source_pairs": { + "stb/stb_easy_font.h": [] + }, + "diagnostics": [ + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_easy_font.h", + "line": 143, + "column": 1, + "source_line": "static unsigned char stb_easy_font_hseg[214] = {" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_easy_font.h", + "line": 155, + "column": 1, + "source_line": "static unsigned char stb_easy_font_vseg[253] = {" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + } + ] +} diff --git a/tests/parser/c/fixtures/stb/stb_herringbone_wang_tile.json b/tests/parser/c/fixtures/stb/stb_herringbone_wang_tile.json new file mode 100644 index 000000000..9c8c9ab1b --- /dev/null +++ b/tests/parser/c/fixtures/stb/stb_herringbone_wang_tile.json @@ -0,0 +1,10630 @@ +{ + "files": { + "stb/stb_herringbone_wang_tile.h": { + "filename": "stb/stb_herringbone_wang_tile.h", + "language": "c", + "parser_status": "partial", + "preprocessing": "raw", + "functions": [ + { + "name": "stbhw__process_h_row", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbhw__process *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbhw__process", + "name": "stbhw__process", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": "stbhw__process", + "members": [ + { + "name": "ts", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbhw_tileset *ts", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbhw_tileset", + "name": "stbhw_tileset", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": "stbhw_tileset", + "members": [ + { + "name": "is_corner", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int is_corner" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 212, + "column": 4, + "source_line": " int is_corner;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "num_color", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int num_color[6]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "6", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 213, + "column": 4, + "source_line": " int num_color[6]; // number of colors for each of 6 edge types or 4 corner types" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "short_side_len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int short_side_len" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 214, + "column": 4, + "source_line": " int short_side_len;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "h_tiles", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbhw_tile **h_tiles", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbhw_tile", + "name": "stbhw_tile", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "a", + "type": { + "model": "CSignedChar", + "qualifiers": [], + "source_text": "signed char a" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 201, + "column": 4, + "source_line": " signed char a,b,c,d,e,f;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "b", + "type": { + "model": "CSignedChar", + "qualifiers": [], + "source_text": "signed char b" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 201, + "column": 4, + "source_line": " signed char a,b,c,d,e,f;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "c", + "type": { + "model": "CSignedChar", + "qualifiers": [], + "source_text": "signed char c" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 201, + "column": 4, + "source_line": " signed char a,b,c,d,e,f;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "d", + "type": { + "model": "CSignedChar", + "qualifiers": [], + "source_text": "signed char d" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 201, + "column": 4, + "source_line": " signed char a,b,c,d,e,f;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "e", + "type": { + "model": "CSignedChar", + "qualifiers": [], + "source_text": "signed char e" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 201, + "column": 4, + "source_line": " signed char a,b,c,d,e,f;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "f", + "type": { + "model": "CSignedChar", + "qualifiers": [], + "source_text": "signed char f" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 201, + "column": 4, + "source_line": " signed char a,b,c,d,e,f;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "pixels", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char pixels[1]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "1", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 207, + "column": 4, + "source_line": " unsigned char pixels[1];" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_herringbone_wang_tile.h:198:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 198, + "column": 1, + "source_line": "typedef struct" + } + }, + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 198, + "column": 1, + "source_line": "typedef struct" + }, + "declaration_locations": [] + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 215, + "column": 4, + "source_line": " stbhw_tile **h_tiles;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "v_tiles", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbhw_tile **v_tiles", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbhw_tile" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 216, + "column": 4, + "source_line": " stbhw_tile **v_tiles;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "num_h_tiles", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_h_tiles" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 217, + "column": 4, + "source_line": " int num_h_tiles, max_h_tiles;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "max_h_tiles", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int max_h_tiles" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 217, + "column": 4, + "source_line": " int num_h_tiles, max_h_tiles;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "num_v_tiles", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_v_tiles" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 218, + "column": 4, + "source_line": " int num_v_tiles, max_v_tiles;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "max_v_tiles", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int max_v_tiles" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 218, + "column": 4, + "source_line": " int num_v_tiles, max_v_tiles;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": null, + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 210, + "column": 1, + "source_line": "struct stbhw_tileset" + } + }, + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 167, + "column": 1, + "source_line": "typedef struct stbhw_tileset stbhw_tileset;" + }, + "declaration_locations": [] + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 374, + "column": 4, + "source_line": " stbhw_tileset *ts;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "c", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbhw_config *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbhw_config", + "name": "stbhw_config", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "is_corner", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int is_corner" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 226, + "column": 4, + "source_line": " int is_corner; // using corner colors or edge colors?" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "short_side_len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int short_side_len" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 227, + "column": 4, + "source_line": " int short_side_len; // rectangles is 2n x n, n = short_side_len" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "num_color", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int num_color[6]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "6", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 228, + "column": 4, + "source_line": " int num_color[6]; // see below diagram for meaning of the index to this;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "num_vary_x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_vary_x" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 231, + "column": 4, + "source_line": " int num_vary_x; // additional number of variations along x axis in the template" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "num_vary_y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_vary_y" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 232, + "column": 4, + "source_line": " int num_vary_y; // additional number of variations along y axis in the template" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "corner_type_color_template", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int corner_type_color_template[4][4]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "4", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "4", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 233, + "column": 4, + "source_line": " int corner_type_color_template[4][4];" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_herringbone_wang_tile.h:224:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 224, + "column": 1, + "source_line": "typedef struct" + } + }, + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 224, + "column": 1, + "source_line": "typedef struct" + }, + "declaration_locations": [] + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 375, + "column": 4, + "source_line": " stbhw_config *c;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "process_h_rect", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbhw__process_rect *process_h_rect", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbhw__process_rect", + "name": "stbhw__process_rect", + "type": { + "model": "CFunctionType", + "qualifiers": [], + "source_text": "typedef void stbhw__process_rect(struct stbhw__process *p, int xpos, int ypos,\n int a, int b, int c, int d, int e, int f)", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameter_types": [ + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "struct stbhw__process *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "struct stbhw__process" + } + ] + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int xpos" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int ypos" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int c" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int d" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int e" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int f" + } + ], + "is_variadic": false, + "prototype_style": "prototype" + }, + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 369, + "column": 1, + "source_line": "typedef void stbhw__process_rect(struct stbhw__process *p, int xpos, int ypos," + }, + "declaration_locations": [] + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 376, + "column": 4, + "source_line": " stbhw__process_rect *process_h_rect;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "process_v_rect", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbhw__process_rect *process_v_rect", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbhw__process_rect" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 377, + "column": 4, + "source_line": " stbhw__process_rect *process_v_rect;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 378, + "column": 4, + "source_line": " unsigned char *data;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "stride", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int stride" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 379, + "column": 4, + "source_line": " int stride,w,h;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "w", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 379, + "column": 4, + "source_line": " int stride,w,h;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "h", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 379, + "column": 4, + "source_line": " int stride,w,h;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": null, + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 372, + "column": 1, + "source_line": "typedef struct stbhw__process" + } + }, + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 372, + "column": 1, + "source_line": "typedef struct stbhw__process" + }, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbhw__process *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbhw__process" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "xpos", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int xpos" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int xpos" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ypos", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ypos" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ypos" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "a0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "a1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "d0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int d0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int d0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "d1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int d1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int d1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "e0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int e0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int e0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "e1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int e1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int e1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "f0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int f0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int f0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "f1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int f1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int f1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "variants", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int variants" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int variants" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 382, + "column": 1, + "source_line": "static void stbhw__process_h_row(stbhw__process *p," + }, + "start": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 382, + "column": 1, + "source_line": "static void stbhw__process_h_row(stbhw__process *p," + }, + "end": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 404, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbhw__process_v_row", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbhw__process *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbhw__process" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbhw__process *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbhw__process" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "xpos", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int xpos" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int xpos" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ypos", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ypos" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ypos" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "a0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "a1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "d0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int d0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int d0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "d1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int d1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int d1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "e0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int e0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int e0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "e1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int e1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int e1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "f0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int f0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int f0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "f1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int f1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int f1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "variants", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int variants" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int variants" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 406, + "column": 1, + "source_line": "static void stbhw__process_v_row(stbhw__process *p," + }, + "start": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 406, + "column": 1, + "source_line": "static void stbhw__process_v_row(stbhw__process *p," + }, + "end": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 428, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbhw__get_template_info", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "c", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbhw_config *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbhw_config" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbhw_config *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbhw_config" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "w", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *w", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *w", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "h", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *h", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *h", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "h_count", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *h_count", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *h_count", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "v_count", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *v_count", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *v_count", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 430, + "column": 1, + "source_line": "static void stbhw__get_template_info(stbhw_config *c, int *w, int *h, int *h_count, int *v_count)" + }, + "start": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 430, + "column": 1, + "source_line": "static void stbhw__get_template_info(stbhw_config *c, int *w, int *h, int *h_count, int *v_count)" + }, + "end": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 476, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbhw__process_template", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbhw__process *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbhw__process" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbhw__process *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbhw__process" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 483, + "column": 1, + "source_line": "static int stbhw__process_template(stbhw__process *p)" + }, + "start": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 483, + "column": 1, + "source_line": "static int stbhw__process_template(stbhw__process *p)" + }, + "end": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 560, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbhw__draw_pixel", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "output", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *output", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *output", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "stride", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int stride" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int stride" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char c[3]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char c[3]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "3", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 568, + "column": 1, + "source_line": "static void stbhw__draw_pixel(unsigned char *output, int stride, int x, int y, unsigned char c[3])" + }, + "start": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 568, + "column": 1, + "source_line": "static void stbhw__draw_pixel(unsigned char *output, int stride, int x, int y, unsigned char c[3])" + }, + "end": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 571, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbhw__draw_h_tile", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "output", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *output", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *output", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "stride", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int stride" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int stride" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "xmax", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int xmax" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int xmax" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ymax", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ymax" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ymax" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "h", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbhw_tile *h", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbhw_tile" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbhw_tile *h", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbhw_tile" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "sz", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int sz" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int sz" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 573, + "column": 1, + "source_line": "static void stbhw__draw_h_tile(unsigned char *output, int stride, int xmax, int ymax, int x, int y, stbhw_tile *h, int sz)" + }, + "start": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 573, + "column": 1, + "source_line": "static void stbhw__draw_h_tile(unsigned char *output, int stride, int xmax, int ymax, int x, int y, stbhw_tile *h, int sz)" + }, + "end": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 581, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbhw__draw_v_tile", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "output", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *output", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *output", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "stride", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int stride" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int stride" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "xmax", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int xmax" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int xmax" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ymax", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ymax" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ymax" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "h", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbhw_tile *h", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbhw_tile" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbhw_tile *h", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbhw_tile" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "sz", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int sz" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int sz" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 583, + "column": 1, + "source_line": "static void stbhw__draw_v_tile(unsigned char *output, int stride, int xmax, int ymax, int x, int y, stbhw_tile *h, int sz)" + }, + "start": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 583, + "column": 1, + "source_line": "static void stbhw__draw_v_tile(unsigned char *output, int stride, int xmax, int ymax, int x, int y, stbhw_tile *h, int sz)" + }, + "end": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 591, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbhw__choose_tile", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbhw_tile", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbhw_tile" + } + ] + }, + "parameters": [ + { + "name": "list", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbhw_tile **list", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbhw_tile" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbhw_tile **list", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbhw_tile" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "numlist", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int numlist" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int numlist" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "a", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "signed char *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CSignedChar", + "qualifiers": [], + "source_text": "signed char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "signed char *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CSignedChar", + "qualifiers": [], + "source_text": "signed char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "signed char *b", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CSignedChar", + "qualifiers": [], + "source_text": "signed char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "signed char *b", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CSignedChar", + "qualifiers": [], + "source_text": "signed char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "signed char *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CSignedChar", + "qualifiers": [], + "source_text": "signed char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "signed char *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CSignedChar", + "qualifiers": [], + "source_text": "signed char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "d", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "signed char *d", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CSignedChar", + "qualifiers": [], + "source_text": "signed char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "signed char *d", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CSignedChar", + "qualifiers": [], + "source_text": "signed char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "e", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "signed char *e", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CSignedChar", + "qualifiers": [], + "source_text": "signed char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "signed char *e", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CSignedChar", + "qualifiers": [], + "source_text": "signed char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "signed char *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CSignedChar", + "qualifiers": [], + "source_text": "signed char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "signed char *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CSignedChar", + "qualifiers": [], + "source_text": "signed char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "weighting", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int **weighting", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int **weighting", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 595, + "column": 1, + "source_line": "static stbhw_tile * stbhw__choose_tile(stbhw_tile **list, int numlist," + }, + "start": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 595, + "column": 1, + "source_line": "static stbhw_tile * stbhw__choose_tile(stbhw_tile **list, int numlist," + }, + "end": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 640, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbhw__match", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 642, + "column": 1, + "source_line": "static int stbhw__match(int x, int y)" + }, + "start": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 642, + "column": 1, + "source_line": "static int stbhw__match(int x, int y)" + }, + "end": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 645, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbhw__weighted", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "num_options", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_options" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_options" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "weights", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *weights", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *weights", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 647, + "column": 1, + "source_line": "static int stbhw__weighted(int num_options, int *weights)" + }, + "start": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 647, + "column": 1, + "source_line": "static int stbhw__weighted(int num_options, int *weights)" + }, + "end": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 662, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbhw__change_color", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "old_color", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int old_color" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int old_color" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "num_options", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_options" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_options" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "weights", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *weights", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *weights", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 664, + "column": 1, + "source_line": "static int stbhw__change_color(int old_color, int num_options, int *weights)" + }, + "start": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 664, + "column": 1, + "source_line": "static int stbhw__change_color(int old_color, int num_options, int *weights)" + }, + "end": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 687, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbhw__parse_h_rect", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbhw__process *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbhw__process" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbhw__process *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbhw__process" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "xpos", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int xpos" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int xpos" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ypos", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ypos" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ypos" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "a", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "d", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int d" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int d" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "e", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int e" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int e" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "f", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int f" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int f" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 841, + "column": 1, + "source_line": "static void stbhw__parse_h_rect(stbhw__process *p, int xpos, int ypos," + }, + "start": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 841, + "column": 1, + "source_line": "static void stbhw__parse_h_rect(stbhw__process *p, int xpos, int ypos," + }, + "end": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 855, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbhw__parse_v_rect", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbhw__process *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbhw__process" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbhw__process *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbhw__process" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "xpos", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int xpos" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int xpos" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ypos", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ypos" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ypos" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "a", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "d", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int d" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int d" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "e", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int e" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int e" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "f", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int f" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int f" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 857, + "column": 1, + "source_line": "static void stbhw__parse_v_rect(stbhw__process *p, int xpos, int ypos," + }, + "start": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 857, + "column": 1, + "source_line": "static void stbhw__parse_v_rect(stbhw__process *p, int xpos, int ypos," + }, + "end": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 871, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbhw__set_pixel", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "stride", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int stride" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int stride" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "xpos", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int xpos" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int xpos" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ypos", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ypos" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ypos" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "color", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char color[3]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char color[3]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "3", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 963, + "column": 1, + "source_line": "static void stbhw__set_pixel(unsigned char *data, int stride, int xpos, int ypos, unsigned char color[3])" + }, + "start": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 963, + "column": 1, + "source_line": "static void stbhw__set_pixel(unsigned char *data, int stride, int xpos, int ypos, unsigned char color[3])" + }, + "end": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 966, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbhw__stbhw__set_pixel_whiten", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "stride", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int stride" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int stride" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "xpos", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int xpos" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int xpos" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ypos", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ypos" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ypos" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "color", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char color[3]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char color[3]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "3", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 968, + "column": 1, + "source_line": "static void stbhw__stbhw__set_pixel_whiten(unsigned char *data, int stride, int xpos, int ypos, unsigned char color[3])" + }, + "start": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 968, + "column": 1, + "source_line": "static void stbhw__stbhw__set_pixel_whiten(unsigned char *data, int stride, int xpos, int ypos, unsigned char color[3])" + }, + "end": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 975, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbhw__draw_hline", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "stride", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int stride" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int stride" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "xpos", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int xpos" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int xpos" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ypos", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ypos" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ypos" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "color", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int color" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int color" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "slot", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int slot" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int slot" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 997, + "column": 1, + "source_line": "static void stbhw__draw_hline(unsigned char *data, int stride, int xpos, int ypos, int color, int len, int slot)" + }, + "start": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 997, + "column": 1, + "source_line": "static void stbhw__draw_hline(unsigned char *data, int stride, int xpos, int ypos, int color, int len, int slot)" + }, + "end": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 1012, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbhw__draw_vline", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "stride", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int stride" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int stride" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "xpos", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int xpos" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int xpos" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ypos", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ypos" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ypos" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "color", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int color" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int color" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "slot", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int slot" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int slot" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 1014, + "column": 1, + "source_line": "static void stbhw__draw_vline(unsigned char *data, int stride, int xpos, int ypos, int color, int len, int slot)" + }, + "start": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 1014, + "column": 1, + "source_line": "static void stbhw__draw_vline(unsigned char *data, int stride, int xpos, int ypos, int color, int len, int slot)" + }, + "end": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 1029, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbhw__draw_clipped_corner", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "stride", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int stride" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int stride" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "xpos", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int xpos" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int xpos" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ypos", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ypos" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ypos" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "w", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "h", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 1074, + "column": 1, + "source_line": "static void stbhw__draw_clipped_corner(unsigned char *data, int stride, int xpos, int ypos, int w, int h, int x, int y)" + }, + "start": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 1074, + "column": 1, + "source_line": "static void stbhw__draw_clipped_corner(unsigned char *data, int stride, int xpos, int ypos, int w, int h, int x, int y)" + }, + "end": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 1090, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbhw__edge_process_h_rect", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbhw__process *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbhw__process" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbhw__process *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbhw__process" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "xpos", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int xpos" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int xpos" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ypos", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ypos" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ypos" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "a", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "d", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int d" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int d" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "e", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int e" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int e" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "f", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int f" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int f" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 1092, + "column": 1, + "source_line": "static void stbhw__edge_process_h_rect(stbhw__process *p, int xpos, int ypos," + }, + "start": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 1092, + "column": 1, + "source_line": "static void stbhw__edge_process_h_rect(stbhw__process *p, int xpos, int ypos," + }, + "end": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 1102, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbhw__edge_process_v_rect", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbhw__process *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbhw__process" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbhw__process *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbhw__process" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "xpos", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int xpos" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int xpos" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ypos", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ypos" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ypos" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "a", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "d", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int d" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int d" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "e", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int e" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int e" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "f", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int f" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int f" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 1104, + "column": 1, + "source_line": "static void stbhw__edge_process_v_rect(stbhw__process *p, int xpos, int ypos," + }, + "start": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 1104, + "column": 1, + "source_line": "static void stbhw__edge_process_v_rect(stbhw__process *p, int xpos, int ypos," + }, + "end": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 1114, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbhw__corner_process_h_rect", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbhw__process *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbhw__process" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbhw__process *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbhw__process" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "xpos", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int xpos" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int xpos" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ypos", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ypos" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ypos" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "a", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "d", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int d" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int d" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "e", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int e" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int e" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "f", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int f" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int f" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 1116, + "column": 1, + "source_line": "static void stbhw__corner_process_h_rect(stbhw__process *p, int xpos, int ypos," + }, + "start": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 1116, + "column": 1, + "source_line": "static void stbhw__corner_process_h_rect(stbhw__process *p, int xpos, int ypos," + }, + "end": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 1142, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbhw__corner_process_v_rect", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbhw__process *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbhw__process" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbhw__process *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbhw__process" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "xpos", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int xpos" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int xpos" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ypos", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ypos" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ypos" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "a", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "d", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int d" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int d" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "e", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int e" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int e" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "f", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int f" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int f" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 1144, + "column": 1, + "source_line": "static void stbhw__corner_process_v_rect(stbhw__process *p, int xpos, int ypos," + }, + "start": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 1144, + "column": 1, + "source_line": "static void stbhw__corner_process_v_rect(stbhw__process *p, int xpos, int ypos," + }, + "end": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 1170, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + } + ], + "structs": [ + { + "reference": "struct@stb/stb_herringbone_wang_tile.h:198:1" + }, + { + "reference": "struct stbhw_tileset" + }, + { + "reference": "struct@stb/stb_herringbone_wang_tile.h:224:1" + }, + { + "reference": "struct stbhw__process" + } + ], + "unions": [], + "enums": [], + "typedefs": [ + { + "reference": "stbhw_tileset" + }, + { + "reference": "stbhw_tile" + }, + { + "reference": "stbhw_config" + }, + { + "reference": "stbhw__process_rect" + }, + { + "reference": "stbhw__process" + } + ], + "variables": [ + { + "name": "c_color", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "static signed char c_color[STB_HBWANG_MAX_Y+6][STB_HBWANG_MAX_X+6]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STB_HBWANG_MAX_Y+6", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STB_HBWANG_MAX_X+6", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CSignedChar", + "qualifiers": [], + "source_text": "signed char" + } + ] + }, + "storage": [ + "static" + ], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 345, + "column": 1, + "source_line": "static signed char c_color[STB_HBWANG_MAX_Y+6][STB_HBWANG_MAX_X+6];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "v_color", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "static signed char v_color[STB_HBWANG_MAX_Y+6][STB_HBWANG_MAX_X+5]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STB_HBWANG_MAX_Y+6", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STB_HBWANG_MAX_X+5", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CSignedChar", + "qualifiers": [], + "source_text": "signed char" + } + ] + }, + "storage": [ + "static" + ], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 346, + "column": 1, + "source_line": "static signed char v_color[STB_HBWANG_MAX_Y+6][STB_HBWANG_MAX_X+5];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "h_color", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "static signed char h_color[STB_HBWANG_MAX_Y+5][STB_HBWANG_MAX_X+6]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STB_HBWANG_MAX_Y+5", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STB_HBWANG_MAX_X+6", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CSignedChar", + "qualifiers": [], + "source_text": "signed char" + } + ] + }, + "storage": [ + "static" + ], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 347, + "column": 1, + "source_line": "static signed char h_color[STB_HBWANG_MAX_Y+5][STB_HBWANG_MAX_X+6];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "stbhw_error", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "static const char *stbhw_error", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "storage": [ + "static" + ], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 349, + "column": 1, + "source_line": "static const char *stbhw_error;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "macros": [ + { + "name": "INCLUDE_STB_HWANG_H", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 155, + "column": 1, + "source_line": "#define INCLUDE_STB_HWANG_H" + } + }, + { + "name": "STBHW_EXTERN", + "value": "static", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 158, + "column": 1, + "source_line": "#define STBHW_EXTERN static" + } + }, + { + "name": "STBHW_EXTERN", + "value": "extern \"C\"", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 161, + "column": 1, + "source_line": "#define STBHW_EXTERN extern \"C\"" + } + }, + { + "name": "STBHW_EXTERN", + "value": "extern", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 163, + "column": 1, + "source_line": "#define STBHW_EXTERN extern" + } + }, + { + "name": "STB_HBWANG_RAND", + "value": "(rand() >> 4)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 325, + "column": 1, + "source_line": "#define STB_HBWANG_RAND() (rand() >> 4)" + } + }, + { + "name": "STB_HBWANG_ASSERT", + "value": "assert(x)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 330, + "column": 1, + "source_line": "#define STB_HBWANG_ASSERT(x) assert(x)" + } + }, + { + "name": "STB_HBWANG_MAX_X", + "value": "100", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 335, + "column": 1, + "source_line": "#define STB_HBWANG_MAX_X 100" + } + }, + { + "name": "STB_HBWANG_MAX_Y", + "value": "100", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 339, + "column": 1, + "source_line": "#define STB_HBWANG_MAX_Y 100" + } + }, + { + "name": "stbhw__c2e", + "value": "stbhw__corner_colors_to_edge_color", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 1072, + "column": 1, + "source_line": "#define stbhw__c2e stbhw__corner_colors_to_edge_color" + } + } + ], + "includes": [ + { + "target": "string.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 320, + "column": 1, + "source_line": "#include // memcpy" + } + }, + { + "target": "stdlib.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 321, + "column": 1, + "source_line": "#include // malloc" + } + }, + { + "target": "stdlib.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 324, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "assert.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 329, + "column": 1, + "source_line": "#include " + } + } + ], + "raw_directives": [ + { + "directive": "ifndef", + "argument": "INCLUDE_STB_HWANG_H", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 154, + "column": 1, + "source_line": "#ifndef INCLUDE_STB_HWANG_H" + } + }, + { + "directive": "ifdef", + "argument": "STB_HBWANG_STATIC", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 157, + "column": 1, + "source_line": "#ifdef STB_HBWANG_STATIC" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 159, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "ifdef", + "argument": "__cplusplus", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 160, + "column": 1, + "source_line": "#ifdef __cplusplus" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 162, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 164, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 165, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 246, + "column": 1, + "source_line": "#endif//INCLUDE_STB_HWANG_H" + } + }, + { + "directive": "ifdef", + "argument": "STB_HERRINGBONE_WANG_TILE_IMPLEMENTATION", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 317, + "column": 1, + "source_line": "#ifdef STB_HERRINGBONE_WANG_TILE_IMPLEMENTATION" + } + }, + { + "directive": "ifndef", + "argument": "STB_HBWANG_RAND", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 323, + "column": 1, + "source_line": "#ifndef STB_HBWANG_RAND" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 326, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_HBWANG_ASSERT", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 328, + "column": 1, + "source_line": "#ifndef STB_HBWANG_ASSERT" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 331, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_HBWANG_MAX_X", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 334, + "column": 1, + "source_line": "#ifndef STB_HBWANG_MAX_X" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 336, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_HBWANG_MAX_Y", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 338, + "column": 1, + "source_line": "#ifndef STB_HBWANG_MAX_Y" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 340, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_HBWANG_NO_REPITITION_REDUCTION", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 716, + "column": 7, + "source_line": " #ifndef STB_HBWANG_NO_REPITITION_REDUCTION" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 738, + "column": 7, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 1221, + "column": 1, + "source_line": "#endif // STB_HBWANG_IMPLEMENTATION" + } + } + ], + "macro_dependencies": [ + { + "name": "STBHW_EXTERN", + "context": "declaration", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 170, + "column": 1, + "source_line": "STBHW_EXTERN const char *stbhw_get_last_error(void);" + }, + "source_text": "STBHW_EXTERN const char *stbhw_get_last_error(void)" + }, + { + "name": "STBHW_EXTERN", + "context": "declaration", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 176, + "column": 1, + "source_line": "STBHW_EXTERN int stbhw_build_tileset_from_image(stbhw_tileset *ts," + }, + "source_text": "STBHW_EXTERN int stbhw_build_tileset_from_image(stbhw_tileset *ts,\n unsigned char *pixels, int stride_in_bytes, int w, int h)" + }, + { + "name": "STBHW_EXTERN", + "context": "declaration", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 180, + "column": 1, + "source_line": "STBHW_EXTERN void stbhw_free_tileset(stbhw_tileset *ts);" + }, + "source_text": "STBHW_EXTERN void stbhw_free_tileset(stbhw_tileset *ts)" + }, + { + "name": "STBHW_EXTERN", + "context": "declaration", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 186, + "column": 1, + "source_line": "STBHW_EXTERN int stbhw_generate_image(stbhw_tileset *ts, int **weighting," + }, + "source_text": "STBHW_EXTERN int stbhw_generate_image(stbhw_tileset *ts, int **weighting,\n unsigned char *pixels, int stride_in_bytes, int w, int h)" + }, + { + "name": "STBHW_EXTERN", + "context": "declaration", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 241, + "column": 1, + "source_line": "STBHW_EXTERN void stbhw_get_template_size(stbhw_config *c, int *w, int *h);" + }, + "source_text": "STBHW_EXTERN void stbhw_get_template_size(stbhw_config *c, int *w, int *h)" + }, + { + "name": "STBHW_EXTERN", + "context": "declaration", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 244, + "column": 1, + "source_line": "STBHW_EXTERN int stbhw_make_template(stbhw_config *c, unsigned char *data, int w, int h, int stride_in_bytes);" + }, + "source_text": "STBHW_EXTERN int stbhw_make_template(stbhw_config *c, unsigned char *data, int w, int h, int stride_in_bytes)" + }, + { + "name": "STBHW_EXTERN", + "context": "declaration", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 350, + "column": 1, + "source_line": "STBHW_EXTERN const char *stbhw_get_last_error(void)" + }, + "source_text": "STBHW_EXTERN const char *stbhw_get_last_error(void)" + }, + { + "name": "STBHW_EXTERN", + "context": "declaration", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 478, + "column": 1, + "source_line": "STBHW_EXTERN void stbhw_get_template_size(stbhw_config *c, int *w, int *h)" + }, + "source_text": "STBHW_EXTERN void stbhw_get_template_size(stbhw_config *c, int *w, int *h)" + }, + { + "name": "STBHW_EXTERN", + "context": "declaration", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 693, + "column": 1, + "source_line": "STBHW_EXTERN int stbhw_generate_image(stbhw_tileset *ts, int **weighting, unsigned char *output, int stride, int w, int h)" + }, + "source_text": "STBHW_EXTERN int stbhw_generate_image(stbhw_tileset *ts, int **weighting, unsigned char *output, int stride, int w, int h)" + }, + { + "name": "STBHW_EXTERN", + "context": "declaration", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 873, + "column": 1, + "source_line": "STBHW_EXTERN int stbhw_build_tileset_from_image(stbhw_tileset *ts, unsigned char *data, int stride, int w, int h)" + }, + "source_text": "STBHW_EXTERN int stbhw_build_tileset_from_image(stbhw_tileset *ts, unsigned char *data, int stride, int w, int h)" + }, + { + "name": "STBHW_EXTERN", + "context": "declaration", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 939, + "column": 1, + "source_line": "STBHW_EXTERN void stbhw_free_tileset(stbhw_tileset *ts)" + }, + "source_text": "STBHW_EXTERN void stbhw_free_tileset(stbhw_tileset *ts)" + }, + { + "name": "STBHW_EXTERN", + "context": "declaration", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 1173, + "column": 1, + "source_line": "STBHW_EXTERN int stbhw_make_template(stbhw_config *c, unsigned char *data, int w, int h, int stride_in_bytes)" + }, + "source_text": "STBHW_EXTERN int stbhw_make_template(stbhw_config *c, unsigned char *data, int w, int h, int stride_in_bytes)" + } + ], + "diagnostics": [ + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STB_HBWANG_RAND' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 325, + "column": 1, + "source_line": "#define STB_HBWANG_RAND() (rand() >> 4)" + }, + "unit_kind": "macro", + "unit_name": "STB_HBWANG_RAND" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STB_HBWANG_ASSERT' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 330, + "column": 1, + "source_line": "#define STB_HBWANG_ASSERT(x) assert(x)" + }, + "unit_kind": "macro", + "unit_name": "STB_HBWANG_ASSERT" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBHW_EXTERN'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 170, + "column": 1, + "source_line": "STBHW_EXTERN const char *stbhw_get_last_error(void);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBHW_EXTERN" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBHW_EXTERN'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 176, + "column": 1, + "source_line": "STBHW_EXTERN int stbhw_build_tileset_from_image(stbhw_tileset *ts," + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBHW_EXTERN" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBHW_EXTERN'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 180, + "column": 1, + "source_line": "STBHW_EXTERN void stbhw_free_tileset(stbhw_tileset *ts);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBHW_EXTERN" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBHW_EXTERN'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 186, + "column": 1, + "source_line": "STBHW_EXTERN int stbhw_generate_image(stbhw_tileset *ts, int **weighting," + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBHW_EXTERN" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBHW_EXTERN'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 241, + "column": 1, + "source_line": "STBHW_EXTERN void stbhw_get_template_size(stbhw_config *c, int *w, int *h);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBHW_EXTERN" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBHW_EXTERN'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 244, + "column": 1, + "source_line": "STBHW_EXTERN int stbhw_make_template(stbhw_config *c, unsigned char *data, int w, int h, int stride_in_bytes);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBHW_EXTERN" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBHW_EXTERN'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 350, + "column": 1, + "source_line": "STBHW_EXTERN const char *stbhw_get_last_error(void)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBHW_EXTERN" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBHW_EXTERN'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 478, + "column": 1, + "source_line": "STBHW_EXTERN void stbhw_get_template_size(stbhw_config *c, int *w, int *h)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBHW_EXTERN" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBHW_EXTERN'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 693, + "column": 1, + "source_line": "STBHW_EXTERN int stbhw_generate_image(stbhw_tileset *ts, int **weighting, unsigned char *output, int stride, int w, int h)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBHW_EXTERN" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBHW_EXTERN'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 873, + "column": 1, + "source_line": "STBHW_EXTERN int stbhw_build_tileset_from_image(stbhw_tileset *ts, unsigned char *data, int stride, int w, int h)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBHW_EXTERN" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBHW_EXTERN'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 939, + "column": 1, + "source_line": "STBHW_EXTERN void stbhw_free_tileset(stbhw_tileset *ts)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBHW_EXTERN" + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 978, + "column": 1, + "source_line": "static unsigned char stbhw__black[3] = { 0,0,0 };" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 984, + "column": 1, + "source_line": "static unsigned char stbhw__color[7][8][3] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 1055, + "column": 1, + "source_line": "unsigned char stbhw__corner_colors[4][4][3] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 1063, + "column": 1, + "source_line": "int stbhw__corner_colors_to_edge_color[4][4] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBHW_EXTERN'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 1173, + "column": 1, + "source_line": "STBHW_EXTERN int stbhw_make_template(stbhw_config *c, unsigned char *data, int w, int h, int stride_in_bytes)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBHW_EXTERN" + } + ] + } + }, + "functions": { + "stbhw__process_h_row": { + "name": "stbhw__process_h_row", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbhw__process *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbhw__process" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbhw__process *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbhw__process" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "xpos", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int xpos" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int xpos" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ypos", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ypos" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ypos" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "a0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "a1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "d0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int d0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int d0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "d1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int d1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int d1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "e0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int e0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int e0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "e1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int e1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int e1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "f0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int f0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int f0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "f1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int f1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int f1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "variants", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int variants" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int variants" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 382, + "column": 1, + "source_line": "static void stbhw__process_h_row(stbhw__process *p," + }, + "start": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 382, + "column": 1, + "source_line": "static void stbhw__process_h_row(stbhw__process *p," + }, + "end": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 404, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbhw__process_v_row": { + "name": "stbhw__process_v_row", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbhw__process *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbhw__process" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbhw__process *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbhw__process" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "xpos", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int xpos" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int xpos" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ypos", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ypos" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ypos" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "a0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "a1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "d0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int d0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int d0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "d1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int d1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int d1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "e0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int e0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int e0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "e1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int e1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int e1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "f0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int f0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int f0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "f1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int f1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int f1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "variants", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int variants" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int variants" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 406, + "column": 1, + "source_line": "static void stbhw__process_v_row(stbhw__process *p," + }, + "start": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 406, + "column": 1, + "source_line": "static void stbhw__process_v_row(stbhw__process *p," + }, + "end": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 428, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbhw__get_template_info": { + "name": "stbhw__get_template_info", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "c", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbhw_config *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbhw_config" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbhw_config *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbhw_config" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "w", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *w", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *w", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "h", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *h", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *h", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "h_count", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *h_count", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *h_count", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "v_count", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *v_count", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *v_count", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 430, + "column": 1, + "source_line": "static void stbhw__get_template_info(stbhw_config *c, int *w, int *h, int *h_count, int *v_count)" + }, + "start": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 430, + "column": 1, + "source_line": "static void stbhw__get_template_info(stbhw_config *c, int *w, int *h, int *h_count, int *v_count)" + }, + "end": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 476, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbhw__process_template": { + "name": "stbhw__process_template", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbhw__process *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbhw__process" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbhw__process *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbhw__process" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 483, + "column": 1, + "source_line": "static int stbhw__process_template(stbhw__process *p)" + }, + "start": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 483, + "column": 1, + "source_line": "static int stbhw__process_template(stbhw__process *p)" + }, + "end": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 560, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbhw__draw_pixel": { + "name": "stbhw__draw_pixel", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "output", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *output", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *output", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "stride", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int stride" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int stride" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char c[3]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char c[3]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "3", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 568, + "column": 1, + "source_line": "static void stbhw__draw_pixel(unsigned char *output, int stride, int x, int y, unsigned char c[3])" + }, + "start": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 568, + "column": 1, + "source_line": "static void stbhw__draw_pixel(unsigned char *output, int stride, int x, int y, unsigned char c[3])" + }, + "end": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 571, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbhw__draw_h_tile": { + "name": "stbhw__draw_h_tile", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "output", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *output", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *output", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "stride", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int stride" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int stride" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "xmax", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int xmax" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int xmax" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ymax", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ymax" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ymax" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "h", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbhw_tile *h", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbhw_tile" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbhw_tile *h", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbhw_tile" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "sz", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int sz" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int sz" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 573, + "column": 1, + "source_line": "static void stbhw__draw_h_tile(unsigned char *output, int stride, int xmax, int ymax, int x, int y, stbhw_tile *h, int sz)" + }, + "start": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 573, + "column": 1, + "source_line": "static void stbhw__draw_h_tile(unsigned char *output, int stride, int xmax, int ymax, int x, int y, stbhw_tile *h, int sz)" + }, + "end": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 581, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbhw__draw_v_tile": { + "name": "stbhw__draw_v_tile", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "output", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *output", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *output", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "stride", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int stride" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int stride" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "xmax", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int xmax" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int xmax" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ymax", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ymax" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ymax" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "h", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbhw_tile *h", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbhw_tile" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbhw_tile *h", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbhw_tile" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "sz", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int sz" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int sz" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 583, + "column": 1, + "source_line": "static void stbhw__draw_v_tile(unsigned char *output, int stride, int xmax, int ymax, int x, int y, stbhw_tile *h, int sz)" + }, + "start": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 583, + "column": 1, + "source_line": "static void stbhw__draw_v_tile(unsigned char *output, int stride, int xmax, int ymax, int x, int y, stbhw_tile *h, int sz)" + }, + "end": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 591, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbhw__choose_tile": { + "name": "stbhw__choose_tile", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbhw_tile", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbhw_tile" + } + ] + }, + "parameters": [ + { + "name": "list", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbhw_tile **list", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbhw_tile" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbhw_tile **list", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbhw_tile" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "numlist", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int numlist" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int numlist" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "a", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "signed char *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CSignedChar", + "qualifiers": [], + "source_text": "signed char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "signed char *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CSignedChar", + "qualifiers": [], + "source_text": "signed char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "signed char *b", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CSignedChar", + "qualifiers": [], + "source_text": "signed char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "signed char *b", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CSignedChar", + "qualifiers": [], + "source_text": "signed char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "signed char *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CSignedChar", + "qualifiers": [], + "source_text": "signed char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "signed char *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CSignedChar", + "qualifiers": [], + "source_text": "signed char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "d", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "signed char *d", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CSignedChar", + "qualifiers": [], + "source_text": "signed char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "signed char *d", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CSignedChar", + "qualifiers": [], + "source_text": "signed char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "e", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "signed char *e", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CSignedChar", + "qualifiers": [], + "source_text": "signed char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "signed char *e", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CSignedChar", + "qualifiers": [], + "source_text": "signed char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "signed char *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CSignedChar", + "qualifiers": [], + "source_text": "signed char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "signed char *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CSignedChar", + "qualifiers": [], + "source_text": "signed char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "weighting", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int **weighting", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int **weighting", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 595, + "column": 1, + "source_line": "static stbhw_tile * stbhw__choose_tile(stbhw_tile **list, int numlist," + }, + "start": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 595, + "column": 1, + "source_line": "static stbhw_tile * stbhw__choose_tile(stbhw_tile **list, int numlist," + }, + "end": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 640, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbhw__match": { + "name": "stbhw__match", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 642, + "column": 1, + "source_line": "static int stbhw__match(int x, int y)" + }, + "start": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 642, + "column": 1, + "source_line": "static int stbhw__match(int x, int y)" + }, + "end": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 645, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbhw__weighted": { + "name": "stbhw__weighted", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "num_options", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_options" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_options" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "weights", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *weights", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *weights", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 647, + "column": 1, + "source_line": "static int stbhw__weighted(int num_options, int *weights)" + }, + "start": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 647, + "column": 1, + "source_line": "static int stbhw__weighted(int num_options, int *weights)" + }, + "end": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 662, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbhw__change_color": { + "name": "stbhw__change_color", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "old_color", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int old_color" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int old_color" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "num_options", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_options" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_options" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "weights", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *weights", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *weights", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 664, + "column": 1, + "source_line": "static int stbhw__change_color(int old_color, int num_options, int *weights)" + }, + "start": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 664, + "column": 1, + "source_line": "static int stbhw__change_color(int old_color, int num_options, int *weights)" + }, + "end": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 687, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbhw__parse_h_rect": { + "name": "stbhw__parse_h_rect", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbhw__process *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbhw__process" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbhw__process *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbhw__process" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "xpos", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int xpos" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int xpos" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ypos", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ypos" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ypos" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "a", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "d", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int d" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int d" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "e", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int e" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int e" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "f", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int f" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int f" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 841, + "column": 1, + "source_line": "static void stbhw__parse_h_rect(stbhw__process *p, int xpos, int ypos," + }, + "start": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 841, + "column": 1, + "source_line": "static void stbhw__parse_h_rect(stbhw__process *p, int xpos, int ypos," + }, + "end": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 855, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbhw__parse_v_rect": { + "name": "stbhw__parse_v_rect", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbhw__process *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbhw__process" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbhw__process *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbhw__process" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "xpos", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int xpos" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int xpos" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ypos", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ypos" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ypos" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "a", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "d", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int d" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int d" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "e", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int e" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int e" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "f", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int f" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int f" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 857, + "column": 1, + "source_line": "static void stbhw__parse_v_rect(stbhw__process *p, int xpos, int ypos," + }, + "start": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 857, + "column": 1, + "source_line": "static void stbhw__parse_v_rect(stbhw__process *p, int xpos, int ypos," + }, + "end": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 871, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbhw__set_pixel": { + "name": "stbhw__set_pixel", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "stride", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int stride" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int stride" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "xpos", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int xpos" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int xpos" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ypos", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ypos" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ypos" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "color", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char color[3]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char color[3]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "3", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 963, + "column": 1, + "source_line": "static void stbhw__set_pixel(unsigned char *data, int stride, int xpos, int ypos, unsigned char color[3])" + }, + "start": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 963, + "column": 1, + "source_line": "static void stbhw__set_pixel(unsigned char *data, int stride, int xpos, int ypos, unsigned char color[3])" + }, + "end": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 966, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbhw__stbhw__set_pixel_whiten": { + "name": "stbhw__stbhw__set_pixel_whiten", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "stride", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int stride" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int stride" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "xpos", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int xpos" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int xpos" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ypos", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ypos" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ypos" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "color", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char color[3]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char color[3]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "3", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 968, + "column": 1, + "source_line": "static void stbhw__stbhw__set_pixel_whiten(unsigned char *data, int stride, int xpos, int ypos, unsigned char color[3])" + }, + "start": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 968, + "column": 1, + "source_line": "static void stbhw__stbhw__set_pixel_whiten(unsigned char *data, int stride, int xpos, int ypos, unsigned char color[3])" + }, + "end": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 975, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbhw__draw_hline": { + "name": "stbhw__draw_hline", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "stride", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int stride" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int stride" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "xpos", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int xpos" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int xpos" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ypos", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ypos" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ypos" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "color", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int color" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int color" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "slot", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int slot" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int slot" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 997, + "column": 1, + "source_line": "static void stbhw__draw_hline(unsigned char *data, int stride, int xpos, int ypos, int color, int len, int slot)" + }, + "start": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 997, + "column": 1, + "source_line": "static void stbhw__draw_hline(unsigned char *data, int stride, int xpos, int ypos, int color, int len, int slot)" + }, + "end": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 1012, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbhw__draw_vline": { + "name": "stbhw__draw_vline", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "stride", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int stride" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int stride" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "xpos", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int xpos" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int xpos" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ypos", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ypos" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ypos" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "color", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int color" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int color" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "slot", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int slot" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int slot" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 1014, + "column": 1, + "source_line": "static void stbhw__draw_vline(unsigned char *data, int stride, int xpos, int ypos, int color, int len, int slot)" + }, + "start": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 1014, + "column": 1, + "source_line": "static void stbhw__draw_vline(unsigned char *data, int stride, int xpos, int ypos, int color, int len, int slot)" + }, + "end": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 1029, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbhw__draw_clipped_corner": { + "name": "stbhw__draw_clipped_corner", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "stride", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int stride" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int stride" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "xpos", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int xpos" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int xpos" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ypos", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ypos" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ypos" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "w", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "h", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 1074, + "column": 1, + "source_line": "static void stbhw__draw_clipped_corner(unsigned char *data, int stride, int xpos, int ypos, int w, int h, int x, int y)" + }, + "start": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 1074, + "column": 1, + "source_line": "static void stbhw__draw_clipped_corner(unsigned char *data, int stride, int xpos, int ypos, int w, int h, int x, int y)" + }, + "end": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 1090, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbhw__edge_process_h_rect": { + "name": "stbhw__edge_process_h_rect", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbhw__process *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbhw__process" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbhw__process *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbhw__process" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "xpos", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int xpos" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int xpos" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ypos", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ypos" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ypos" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "a", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "d", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int d" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int d" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "e", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int e" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int e" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "f", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int f" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int f" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 1092, + "column": 1, + "source_line": "static void stbhw__edge_process_h_rect(stbhw__process *p, int xpos, int ypos," + }, + "start": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 1092, + "column": 1, + "source_line": "static void stbhw__edge_process_h_rect(stbhw__process *p, int xpos, int ypos," + }, + "end": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 1102, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbhw__edge_process_v_rect": { + "name": "stbhw__edge_process_v_rect", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbhw__process *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbhw__process" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbhw__process *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbhw__process" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "xpos", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int xpos" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int xpos" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ypos", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ypos" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ypos" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "a", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "d", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int d" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int d" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "e", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int e" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int e" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "f", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int f" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int f" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 1104, + "column": 1, + "source_line": "static void stbhw__edge_process_v_rect(stbhw__process *p, int xpos, int ypos," + }, + "start": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 1104, + "column": 1, + "source_line": "static void stbhw__edge_process_v_rect(stbhw__process *p, int xpos, int ypos," + }, + "end": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 1114, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbhw__corner_process_h_rect": { + "name": "stbhw__corner_process_h_rect", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbhw__process *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbhw__process" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbhw__process *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbhw__process" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "xpos", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int xpos" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int xpos" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ypos", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ypos" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ypos" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "a", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "d", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int d" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int d" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "e", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int e" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int e" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "f", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int f" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int f" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 1116, + "column": 1, + "source_line": "static void stbhw__corner_process_h_rect(stbhw__process *p, int xpos, int ypos," + }, + "start": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 1116, + "column": 1, + "source_line": "static void stbhw__corner_process_h_rect(stbhw__process *p, int xpos, int ypos," + }, + "end": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 1142, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbhw__corner_process_v_rect": { + "name": "stbhw__corner_process_v_rect", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbhw__process *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbhw__process" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbhw__process *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbhw__process" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "xpos", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int xpos" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int xpos" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ypos", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ypos" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ypos" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "a", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "d", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int d" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int d" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "e", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int e" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int e" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "f", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int f" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int f" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 1144, + "column": 1, + "source_line": "static void stbhw__corner_process_v_rect(stbhw__process *p, int xpos, int ypos," + }, + "start": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 1144, + "column": 1, + "source_line": "static void stbhw__corner_process_v_rect(stbhw__process *p, int xpos, int ypos," + }, + "end": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 1170, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + } + }, + "structs": { + "stbhw_tileset": { + "reference": "struct stbhw_tileset" + }, + "stbhw__process": { + "reference": "struct stbhw__process" + } + }, + "unions": {}, + "enums": {}, + "typedefs": { + "stbhw_tileset": { + "reference": "stbhw_tileset" + }, + "stbhw_tile": { + "reference": "stbhw_tile" + }, + "stbhw_config": { + "reference": "stbhw_config" + }, + "stbhw__process_rect": { + "reference": "stbhw__process_rect" + }, + "stbhw__process": { + "reference": "stbhw__process" + } + }, + "variables": { + "c_color": { + "name": "c_color", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "static signed char c_color[STB_HBWANG_MAX_Y+6][STB_HBWANG_MAX_X+6]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STB_HBWANG_MAX_Y+6", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STB_HBWANG_MAX_X+6", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CSignedChar", + "qualifiers": [], + "source_text": "signed char" + } + ] + }, + "storage": [ + "static" + ], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 345, + "column": 1, + "source_line": "static signed char c_color[STB_HBWANG_MAX_Y+6][STB_HBWANG_MAX_X+6];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + "v_color": { + "name": "v_color", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "static signed char v_color[STB_HBWANG_MAX_Y+6][STB_HBWANG_MAX_X+5]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STB_HBWANG_MAX_Y+6", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STB_HBWANG_MAX_X+5", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CSignedChar", + "qualifiers": [], + "source_text": "signed char" + } + ] + }, + "storage": [ + "static" + ], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 346, + "column": 1, + "source_line": "static signed char v_color[STB_HBWANG_MAX_Y+6][STB_HBWANG_MAX_X+5];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + "h_color": { + "name": "h_color", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "static signed char h_color[STB_HBWANG_MAX_Y+5][STB_HBWANG_MAX_X+6]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STB_HBWANG_MAX_Y+5", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STB_HBWANG_MAX_X+6", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CSignedChar", + "qualifiers": [], + "source_text": "signed char" + } + ] + }, + "storage": [ + "static" + ], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 347, + "column": 1, + "source_line": "static signed char h_color[STB_HBWANG_MAX_Y+5][STB_HBWANG_MAX_X+6];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + "stbhw_error": { + "name": "stbhw_error", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "static const char *stbhw_error", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "storage": [ + "static" + ], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 349, + "column": 1, + "source_line": "static const char *stbhw_error;" + }, + "callback_policy": null, + "declaration_locations": [] + } + }, + "macros": { + "INCLUDE_STB_HWANG_H": { + "name": "INCLUDE_STB_HWANG_H", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 155, + "column": 1, + "source_line": "#define INCLUDE_STB_HWANG_H" + } + }, + "STBHW_EXTERN": { + "name": "STBHW_EXTERN", + "value": "extern", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 163, + "column": 1, + "source_line": "#define STBHW_EXTERN extern" + } + }, + "STB_HBWANG_RAND": { + "name": "STB_HBWANG_RAND", + "value": "(rand() >> 4)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 325, + "column": 1, + "source_line": "#define STB_HBWANG_RAND() (rand() >> 4)" + } + }, + "STB_HBWANG_ASSERT": { + "name": "STB_HBWANG_ASSERT", + "value": "assert(x)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 330, + "column": 1, + "source_line": "#define STB_HBWANG_ASSERT(x) assert(x)" + } + }, + "STB_HBWANG_MAX_X": { + "name": "STB_HBWANG_MAX_X", + "value": "100", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 335, + "column": 1, + "source_line": "#define STB_HBWANG_MAX_X 100" + } + }, + "STB_HBWANG_MAX_Y": { + "name": "STB_HBWANG_MAX_Y", + "value": "100", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 339, + "column": 1, + "source_line": "#define STB_HBWANG_MAX_Y 100" + } + }, + "stbhw__c2e": { + "name": "stbhw__c2e", + "value": "stbhw__corner_colors_to_edge_color", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 1072, + "column": 1, + "source_line": "#define stbhw__c2e stbhw__corner_colors_to_edge_color" + } + } + }, + "includes": { + "stb/stb_herringbone_wang_tile.h:string.h": { + "target": "string.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 320, + "column": 1, + "source_line": "#include // memcpy" + } + }, + "stb/stb_herringbone_wang_tile.h:stdlib.h": { + "target": "stdlib.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 324, + "column": 1, + "source_line": "#include " + } + }, + "stb/stb_herringbone_wang_tile.h:assert.h": { + "target": "assert.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 329, + "column": 1, + "source_line": "#include " + } + } + }, + "functions_by_file": { + "stb/stb_herringbone_wang_tile.h": [ + "stbhw__process_h_row", + "stbhw__process_v_row", + "stbhw__get_template_info", + "stbhw__process_template", + "stbhw__draw_pixel", + "stbhw__draw_h_tile", + "stbhw__draw_v_tile", + "stbhw__choose_tile", + "stbhw__match", + "stbhw__weighted", + "stbhw__change_color", + "stbhw__parse_h_rect", + "stbhw__parse_v_rect", + "stbhw__set_pixel", + "stbhw__stbhw__set_pixel_whiten", + "stbhw__draw_hline", + "stbhw__draw_vline", + "stbhw__draw_clipped_corner", + "stbhw__edge_process_h_rect", + "stbhw__edge_process_v_rect", + "stbhw__corner_process_h_rect", + "stbhw__corner_process_v_rect" + ] + }, + "enum_constants": {}, + "include_graph": { + "stb/stb_herringbone_wang_tile.h": [] + }, + "system_includes": { + "stb/stb_herringbone_wang_tile.h": [ + "assert.h", + "stdlib.h", + "string.h" + ] + }, + "unresolved_includes": { + "stb/stb_herringbone_wang_tile.h": [] + }, + "header_source_pairs": { + "stb/stb_herringbone_wang_tile.h": [] + }, + "diagnostics": [ + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STB_HBWANG_RAND' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 325, + "column": 1, + "source_line": "#define STB_HBWANG_RAND() (rand() >> 4)" + }, + "unit_kind": "macro", + "unit_name": "STB_HBWANG_RAND" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STB_HBWANG_ASSERT' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 330, + "column": 1, + "source_line": "#define STB_HBWANG_ASSERT(x) assert(x)" + }, + "unit_kind": "macro", + "unit_name": "STB_HBWANG_ASSERT" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBHW_EXTERN'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 170, + "column": 1, + "source_line": "STBHW_EXTERN const char *stbhw_get_last_error(void);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBHW_EXTERN" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBHW_EXTERN'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 176, + "column": 1, + "source_line": "STBHW_EXTERN int stbhw_build_tileset_from_image(stbhw_tileset *ts," + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBHW_EXTERN" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBHW_EXTERN'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 180, + "column": 1, + "source_line": "STBHW_EXTERN void stbhw_free_tileset(stbhw_tileset *ts);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBHW_EXTERN" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBHW_EXTERN'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 186, + "column": 1, + "source_line": "STBHW_EXTERN int stbhw_generate_image(stbhw_tileset *ts, int **weighting," + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBHW_EXTERN" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBHW_EXTERN'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 241, + "column": 1, + "source_line": "STBHW_EXTERN void stbhw_get_template_size(stbhw_config *c, int *w, int *h);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBHW_EXTERN" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBHW_EXTERN'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 244, + "column": 1, + "source_line": "STBHW_EXTERN int stbhw_make_template(stbhw_config *c, unsigned char *data, int w, int h, int stride_in_bytes);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBHW_EXTERN" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBHW_EXTERN'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 350, + "column": 1, + "source_line": "STBHW_EXTERN const char *stbhw_get_last_error(void)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBHW_EXTERN" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBHW_EXTERN'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 478, + "column": 1, + "source_line": "STBHW_EXTERN void stbhw_get_template_size(stbhw_config *c, int *w, int *h)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBHW_EXTERN" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBHW_EXTERN'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 693, + "column": 1, + "source_line": "STBHW_EXTERN int stbhw_generate_image(stbhw_tileset *ts, int **weighting, unsigned char *output, int stride, int w, int h)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBHW_EXTERN" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBHW_EXTERN'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 873, + "column": 1, + "source_line": "STBHW_EXTERN int stbhw_build_tileset_from_image(stbhw_tileset *ts, unsigned char *data, int stride, int w, int h)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBHW_EXTERN" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBHW_EXTERN'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 939, + "column": 1, + "source_line": "STBHW_EXTERN void stbhw_free_tileset(stbhw_tileset *ts)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBHW_EXTERN" + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 978, + "column": 1, + "source_line": "static unsigned char stbhw__black[3] = { 0,0,0 };" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 984, + "column": 1, + "source_line": "static unsigned char stbhw__color[7][8][3] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 1055, + "column": 1, + "source_line": "unsigned char stbhw__corner_colors[4][4][3] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 1063, + "column": 1, + "source_line": "int stbhw__corner_colors_to_edge_color[4][4] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBHW_EXTERN'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_herringbone_wang_tile.h", + "line": 1173, + "column": 1, + "source_line": "STBHW_EXTERN int stbhw_make_template(stbhw_config *c, unsigned char *data, int w, int h, int stride_in_bytes)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBHW_EXTERN" + } + ] +} diff --git a/tests/parser/c/fixtures/stb/stb_hexwave.json b/tests/parser/c/fixtures/stb/stb_hexwave.json new file mode 100644 index 000000000..2bcff41a1 --- /dev/null +++ b/tests/parser/c/fixtures/stb/stb_hexwave.json @@ -0,0 +1,2320 @@ +{ + "files": { + "stb/stb_hexwave.h": { + "filename": "stb/stb_hexwave.h", + "language": "c", + "parser_status": "partial", + "preprocessing": "raw", + "functions": [ + { + "name": "hex_add_oversampled_bleplike", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "output", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *output", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *output", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "time_since_transition", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float time_since_transition" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float time_since_transition" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "scale", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float scale" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float scale" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 315, + "column": 1, + "source_line": "static void hex_add_oversampled_bleplike(float *output, float time_since_transition, float scale, float *data)" + }, + "start": { + "filename": "stb/stb_hexwave.h", + "line": 315, + "column": 1, + "source_line": "static void hex_add_oversampled_bleplike(float *output, float time_since_transition, float scale, float *data)" + }, + "end": { + "filename": "stb/stb_hexwave.h", + "line": 331, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "hex_blep", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "output", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *output", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *output", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "time_since_transition", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float time_since_transition" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float time_since_transition" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "scale", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float scale" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float scale" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 333, + "column": 1, + "source_line": "static void hex_blep (float *output, float time_since_transition, float scale)" + }, + "start": { + "filename": "stb/stb_hexwave.h", + "line": 333, + "column": 1, + "source_line": "static void hex_blep (float *output, float time_since_transition, float scale)" + }, + "end": { + "filename": "stb/stb_hexwave.h", + "line": 336, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "hex_blamp", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "output", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *output", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *output", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "time_since_transition", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float time_since_transition" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float time_since_transition" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "scale", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float scale" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float scale" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 338, + "column": 1, + "source_line": "static void hex_blamp(float *output, float time_since_transition, float scale)" + }, + "start": { + "filename": "stb/stb_hexwave.h", + "line": 338, + "column": 1, + "source_line": "static void hex_blamp(float *output, float time_since_transition, float scale)" + }, + "end": { + "filename": "stb/stb_hexwave.h", + "line": 341, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "hexwave_generate_linesegs", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "vert", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "hexvert vert[9]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "hexvert", + "name": "hexvert", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "t", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float t" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 345, + "column": 4, + "source_line": " float t,v,s; // time, value, slope" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "v", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float v" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 345, + "column": 4, + "source_line": " float t,v,s; // time, value, slope" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "s", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float s" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 345, + "column": 4, + "source_line": " float t,v,s; // time, value, slope" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_hexwave.h:343:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 343, + "column": 1, + "source_line": "typedef struct" + } + }, + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 343, + "column": 1, + "source_line": "typedef struct" + }, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "hexvert vert[9]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "9", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "reference": "hexvert" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "hex", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "HexWave *hex", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "HexWave", + "name": "HexWave", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": "HexWave", + "members": [ + { + "name": "t", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float t" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 269, + "column": 4, + "source_line": " float t, prev_dt;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "prev_dt", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float prev_dt" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 269, + "column": 4, + "source_line": " float t, prev_dt;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "current", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "HexWaveParameters", + "name": "HexWaveParameters", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "reflect", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int reflect" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 261, + "column": 4, + "source_line": " int reflect;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "peak_time", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float peak_time" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 262, + "column": 4, + "source_line": " float peak_time;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "zero_wait", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float zero_wait" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 263, + "column": 4, + "source_line": " float zero_wait;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "half_height", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float half_height" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 264, + "column": 4, + "source_line": " float half_height;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_hexwave.h:259:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 259, + "column": 1, + "source_line": "typedef struct" + } + }, + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 259, + "column": 1, + "source_line": "typedef struct" + }, + "declaration_locations": [] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 270, + "column": 4, + "source_line": " HexWaveParameters current, pending;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "pending", + "type": { + "reference": "HexWaveParameters" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 270, + "column": 4, + "source_line": " HexWaveParameters current, pending;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "have_pending", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int have_pending" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 271, + "column": 4, + "source_line": " int have_pending;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float buffer[STB_HEXWAVE_MAX_BLEP_LENGTH]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STB_HEXWAVE_MAX_BLEP_LENGTH", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 272, + "column": 4, + "source_line": " float buffer[STB_HEXWAVE_MAX_BLEP_LENGTH];" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": null, + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 267, + "column": 1, + "source_line": "struct HexWave" + } + }, + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 226, + "column": 1, + "source_line": "typedef struct HexWave HexWave;" + }, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "HexWave *hex", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "HexWave" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dt", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dt" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dt" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 350, + "column": 1, + "source_line": "static void hexwave_generate_linesegs(hexvert vert[9], HexWave *hex, float dt)" + }, + "start": { + "filename": "stb/stb_hexwave.h", + "line": 350, + "column": 1, + "source_line": "static void hexwave_generate_linesegs(hexvert vert[9], HexWave *hex, float dt)" + }, + "end": { + "filename": "stb/stb_hexwave.h", + "line": 416, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + } + ], + "structs": [ + { + "reference": "struct@stb/stb_hexwave.h:259:1" + }, + { + "reference": "struct HexWave" + }, + { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "width", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 309, + "column": 4, + "source_line": " int width; // width of fixup in samples" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "oversample", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int oversample" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 310, + "column": 4, + "source_line": " int oversample; // number of oversampled versions (there's actually one more to allow lerpign)" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "blep", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *blep", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 311, + "column": 4, + "source_line": " float *blep;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "blamp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *blamp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 312, + "column": 4, + "source_line": " float *blamp;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_hexwave.h:307:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 307, + "column": 1, + "source_line": "static struct" + } + }, + { + "reference": "struct@stb/stb_hexwave.h:343:1" + } + ], + "unions": [], + "enums": [], + "typedefs": [ + { + "reference": "HexWave" + }, + { + "reference": "HexWaveParameters" + }, + { + "reference": "hexvert" + } + ], + "variables": [ + { + "name": "hexblep", + "type": { + "reference": "struct@stb/stb_hexwave.h:307:1" + }, + "storage": [ + "static" + ], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 307, + "column": 1, + "source_line": "static struct" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "macros": [ + { + "name": "STB_INCLUDE_STB_HEXWAVE_H", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 214, + "column": 1, + "source_line": "#define STB_INCLUDE_STB_HEXWAVE_H" + } + }, + { + "name": "STB_HEXWAVE_MAX_BLEP_LENGTH", + "value": "64", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 217, + "column": 1, + "source_line": "#define STB_HEXWAVE_MAX_BLEP_LENGTH 64 // good enough for anybody" + } + }, + { + "name": "STB_HEXWAVE_DEF", + "value": "static", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 221, + "column": 1, + "source_line": "#define STB_HEXWAVE_DEF static" + } + }, + { + "name": "STB_HEXWAVE_DEF", + "value": "extern", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 223, + "column": 1, + "source_line": "#define STB_HEXWAVE_DEF extern" + } + }, + { + "name": "hexwave_clamp", + "value": "((v) < (a) ? (a) : (v) > (b) ? (b) : (v))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 285, + "column": 1, + "source_line": "#define hexwave_clamp(v,a,b) ((v) < (a) ? (a) : (v) > (b) ? (b) : (v))" + } + } + ], + "includes": [ + { + "target": "stdlib.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 279, + "column": 1, + "source_line": "#include // malloc,free" + } + }, + { + "target": "string.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 282, + "column": 1, + "source_line": "#include // memset,memcpy,memmove" + } + }, + { + "target": "math.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 283, + "column": 1, + "source_line": "#include // sin,cos,fabs" + } + } + ], + "raw_directives": [ + { + "directive": "ifndef", + "argument": "STB_INCLUDE_STB_HEXWAVE_H", + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 213, + "column": 1, + "source_line": "#ifndef STB_INCLUDE_STB_HEXWAVE_H" + } + }, + { + "directive": "ifndef", + "argument": "STB_HEXWAVE_MAX_BLEP_LENGTH", + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 216, + "column": 1, + "source_line": "#ifndef STB_HEXWAVE_MAX_BLEP_LENGTH" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 218, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STB_HEXWAVE_STATIC", + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 220, + "column": 1, + "source_line": "#ifdef STB_HEXWAVE_STATIC" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 222, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 224, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 274, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STB_HEXWAVE_IMPLEMENTATION", + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 276, + "column": 1, + "source_line": "#ifdef STB_HEXWAVE_IMPLEMENTATION" + } + }, + { + "directive": "ifndef", + "argument": "STB_HEXWAVE_NO_ALLOCATION", + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 278, + "column": 1, + "source_line": "#ifndef STB_HEXWAVE_NO_ALLOCATION" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 280, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_HEXWAVE_NO_ALLOCATION", + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 548, + "column": 4, + "source_line": " #ifndef STB_HEXWAVE_NO_ALLOCATION" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 553, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "STB_HEXWAVE_NO_ALLOCATION", + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 563, + "column": 1, + "source_line": "#ifdef STB_HEXWAVE_NO_ALLOCATION" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 565, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 567, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_HEXWAVE_NO_ALLOCATION", + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 578, + "column": 7, + "source_line": " #ifndef STB_HEXWAVE_NO_ALLOCATION" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 581, + "column": 7, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_HEXWAVE_NO_ALLOCATION", + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 633, + "column": 4, + "source_line": " #ifndef STB_HEXWAVE_NO_ALLOCATION" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 636, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 638, + "column": 1, + "source_line": "#endif // STB_HEXWAVE_IMPLEMENTATION" + } + } + ], + "macro_dependencies": [ + { + "name": "STB_HEXWAVE_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 228, + "column": 1, + "source_line": "STB_HEXWAVE_DEF void hexwave_init(int width, int oversample, float *user_buffer);" + }, + "source_text": "STB_HEXWAVE_DEF void hexwave_init(int width, int oversample, float *user_buffer)" + }, + { + "name": "STB_HEXWAVE_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 238, + "column": 1, + "source_line": "STB_HEXWAVE_DEF void hexwave_shutdown(float *user_buffer);" + }, + "source_text": "STB_HEXWAVE_DEF void hexwave_shutdown(float *user_buffer)" + }, + { + "name": "STB_HEXWAVE_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 241, + "column": 1, + "source_line": "STB_HEXWAVE_DEF void hexwave_create(HexWave *hex, int reflect, float peak_time, float half_height, float zero_wait);" + }, + "source_text": "STB_HEXWAVE_DEF void hexwave_create(HexWave *hex, int reflect, float peak_time, float half_height, float zero_wait)" + }, + { + "name": "STB_HEXWAVE_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 249, + "column": 1, + "source_line": "STB_HEXWAVE_DEF void hexwave_change(HexWave *hex, int reflect, float peak_time, float half_height, float zero_wait);" + }, + "source_text": "STB_HEXWAVE_DEF void hexwave_change(HexWave *hex, int reflect, float peak_time, float half_height, float zero_wait)" + }, + { + "name": "STB_HEXWAVE_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 252, + "column": 1, + "source_line": "STB_HEXWAVE_DEF void hexwave_generate_samples(float *output, int num_samples, HexWave *hex, float freq);" + }, + "source_text": "STB_HEXWAVE_DEF void hexwave_generate_samples(float *output, int num_samples, HexWave *hex, float freq)" + }, + { + "name": "STB_HEXWAVE_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 287, + "column": 1, + "source_line": "STB_HEXWAVE_DEF void hexwave_change(HexWave *hex, int reflect, float peak_time, float half_height, float zero_wait)" + }, + "source_text": "STB_HEXWAVE_DEF void hexwave_change(HexWave *hex, int reflect, float peak_time, float half_height, float zero_wait)" + }, + { + "name": "STB_HEXWAVE_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 297, + "column": 1, + "source_line": "STB_HEXWAVE_DEF void hexwave_create(HexWave *hex, int reflect, float peak_time, float half_height, float zero_wait)" + }, + "source_text": "STB_HEXWAVE_DEF void hexwave_create(HexWave *hex, int reflect, float peak_time, float half_height, float zero_wait)" + }, + { + "name": "STB_HEXWAVE_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 418, + "column": 1, + "source_line": "STB_HEXWAVE_DEF void hexwave_generate_samples(float *output, int num_samples, HexWave *hex, float freq)" + }, + "source_text": "STB_HEXWAVE_DEF void hexwave_generate_samples(float *output, int num_samples, HexWave *hex, float freq)" + }, + { + "name": "STB_HEXWAVE_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 546, + "column": 1, + "source_line": "STB_HEXWAVE_DEF void hexwave_shutdown(float *user_buffer)" + }, + "source_text": "STB_HEXWAVE_DEF void hexwave_shutdown(float *user_buffer)" + }, + { + "name": "STB_HEXWAVE_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 557, + "column": 1, + "source_line": "STB_HEXWAVE_DEF void hexwave_init(int width, int oversample, float *user_buffer)" + }, + "source_text": "STB_HEXWAVE_DEF void hexwave_init(int width, int oversample, float *user_buffer)" + } + ], + "diagnostics": [ + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'hexwave_clamp' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_hexwave.h", + "line": 285, + "column": 1, + "source_line": "#define hexwave_clamp(v,a,b) ((v) < (a) ? (a) : (v) > (b) ? (b) : (v))" + }, + "unit_kind": "macro", + "unit_name": "hexwave_clamp" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STB_HEXWAVE_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_hexwave.h", + "line": 228, + "column": 1, + "source_line": "STB_HEXWAVE_DEF void hexwave_init(int width, int oversample, float *user_buffer);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STB_HEXWAVE_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STB_HEXWAVE_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_hexwave.h", + "line": 238, + "column": 1, + "source_line": "STB_HEXWAVE_DEF void hexwave_shutdown(float *user_buffer);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STB_HEXWAVE_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STB_HEXWAVE_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_hexwave.h", + "line": 241, + "column": 1, + "source_line": "STB_HEXWAVE_DEF void hexwave_create(HexWave *hex, int reflect, float peak_time, float half_height, float zero_wait);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STB_HEXWAVE_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STB_HEXWAVE_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_hexwave.h", + "line": 249, + "column": 1, + "source_line": "STB_HEXWAVE_DEF void hexwave_change(HexWave *hex, int reflect, float peak_time, float half_height, float zero_wait);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STB_HEXWAVE_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STB_HEXWAVE_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_hexwave.h", + "line": 252, + "column": 1, + "source_line": "STB_HEXWAVE_DEF void hexwave_generate_samples(float *output, int num_samples, HexWave *hex, float freq);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STB_HEXWAVE_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STB_HEXWAVE_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_hexwave.h", + "line": 287, + "column": 1, + "source_line": "STB_HEXWAVE_DEF void hexwave_change(HexWave *hex, int reflect, float peak_time, float half_height, float zero_wait)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STB_HEXWAVE_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STB_HEXWAVE_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_hexwave.h", + "line": 297, + "column": 1, + "source_line": "STB_HEXWAVE_DEF void hexwave_create(HexWave *hex, int reflect, float peak_time, float half_height, float zero_wait)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STB_HEXWAVE_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STB_HEXWAVE_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_hexwave.h", + "line": 418, + "column": 1, + "source_line": "STB_HEXWAVE_DEF void hexwave_generate_samples(float *output, int num_samples, HexWave *hex, float freq)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STB_HEXWAVE_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STB_HEXWAVE_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_hexwave.h", + "line": 546, + "column": 1, + "source_line": "STB_HEXWAVE_DEF void hexwave_shutdown(float *user_buffer)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STB_HEXWAVE_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STB_HEXWAVE_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_hexwave.h", + "line": 557, + "column": 1, + "source_line": "STB_HEXWAVE_DEF void hexwave_init(int width, int oversample, float *user_buffer)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STB_HEXWAVE_DEF" + } + ] + } + }, + "functions": { + "hex_add_oversampled_bleplike": { + "name": "hex_add_oversampled_bleplike", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "output", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *output", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *output", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "time_since_transition", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float time_since_transition" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float time_since_transition" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "scale", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float scale" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float scale" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 315, + "column": 1, + "source_line": "static void hex_add_oversampled_bleplike(float *output, float time_since_transition, float scale, float *data)" + }, + "start": { + "filename": "stb/stb_hexwave.h", + "line": 315, + "column": 1, + "source_line": "static void hex_add_oversampled_bleplike(float *output, float time_since_transition, float scale, float *data)" + }, + "end": { + "filename": "stb/stb_hexwave.h", + "line": 331, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "hex_blep": { + "name": "hex_blep", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "output", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *output", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *output", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "time_since_transition", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float time_since_transition" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float time_since_transition" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "scale", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float scale" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float scale" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 333, + "column": 1, + "source_line": "static void hex_blep (float *output, float time_since_transition, float scale)" + }, + "start": { + "filename": "stb/stb_hexwave.h", + "line": 333, + "column": 1, + "source_line": "static void hex_blep (float *output, float time_since_transition, float scale)" + }, + "end": { + "filename": "stb/stb_hexwave.h", + "line": 336, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "hex_blamp": { + "name": "hex_blamp", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "output", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *output", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *output", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "time_since_transition", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float time_since_transition" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float time_since_transition" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "scale", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float scale" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float scale" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 338, + "column": 1, + "source_line": "static void hex_blamp(float *output, float time_since_transition, float scale)" + }, + "start": { + "filename": "stb/stb_hexwave.h", + "line": 338, + "column": 1, + "source_line": "static void hex_blamp(float *output, float time_since_transition, float scale)" + }, + "end": { + "filename": "stb/stb_hexwave.h", + "line": 341, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "hexwave_generate_linesegs": { + "name": "hexwave_generate_linesegs", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "vert", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "hexvert vert[9]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "hexvert" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "hexvert vert[9]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "9", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "reference": "hexvert" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "hex", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "HexWave *hex", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "HexWave" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "HexWave *hex", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "HexWave" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dt", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dt" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dt" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 350, + "column": 1, + "source_line": "static void hexwave_generate_linesegs(hexvert vert[9], HexWave *hex, float dt)" + }, + "start": { + "filename": "stb/stb_hexwave.h", + "line": 350, + "column": 1, + "source_line": "static void hexwave_generate_linesegs(hexvert vert[9], HexWave *hex, float dt)" + }, + "end": { + "filename": "stb/stb_hexwave.h", + "line": 416, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + } + }, + "structs": { + "HexWave": { + "reference": "struct HexWave" + } + }, + "unions": {}, + "enums": {}, + "typedefs": { + "HexWave": { + "reference": "HexWave" + }, + "HexWaveParameters": { + "reference": "HexWaveParameters" + }, + "hexvert": { + "reference": "hexvert" + } + }, + "variables": { + "hexblep": { + "name": "hexblep", + "type": { + "reference": "struct@stb/stb_hexwave.h:307:1" + }, + "storage": [ + "static" + ], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 307, + "column": 1, + "source_line": "static struct" + }, + "callback_policy": null, + "declaration_locations": [] + } + }, + "macros": { + "STB_INCLUDE_STB_HEXWAVE_H": { + "name": "STB_INCLUDE_STB_HEXWAVE_H", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 214, + "column": 1, + "source_line": "#define STB_INCLUDE_STB_HEXWAVE_H" + } + }, + "STB_HEXWAVE_MAX_BLEP_LENGTH": { + "name": "STB_HEXWAVE_MAX_BLEP_LENGTH", + "value": "64", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 217, + "column": 1, + "source_line": "#define STB_HEXWAVE_MAX_BLEP_LENGTH 64 // good enough for anybody" + } + }, + "STB_HEXWAVE_DEF": { + "name": "STB_HEXWAVE_DEF", + "value": "extern", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 223, + "column": 1, + "source_line": "#define STB_HEXWAVE_DEF extern" + } + }, + "hexwave_clamp": { + "name": "hexwave_clamp", + "value": "((v) < (a) ? (a) : (v) > (b) ? (b) : (v))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 285, + "column": 1, + "source_line": "#define hexwave_clamp(v,a,b) ((v) < (a) ? (a) : (v) > (b) ? (b) : (v))" + } + } + }, + "includes": { + "stb/stb_hexwave.h:stdlib.h": { + "target": "stdlib.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 279, + "column": 1, + "source_line": "#include // malloc,free" + } + }, + "stb/stb_hexwave.h:string.h": { + "target": "string.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 282, + "column": 1, + "source_line": "#include // memset,memcpy,memmove" + } + }, + "stb/stb_hexwave.h:math.h": { + "target": "math.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_hexwave.h", + "line": 283, + "column": 1, + "source_line": "#include // sin,cos,fabs" + } + } + }, + "functions_by_file": { + "stb/stb_hexwave.h": [ + "hex_add_oversampled_bleplike", + "hex_blep", + "hex_blamp", + "hexwave_generate_linesegs" + ] + }, + "enum_constants": {}, + "include_graph": { + "stb/stb_hexwave.h": [] + }, + "system_includes": { + "stb/stb_hexwave.h": [ + "math.h", + "stdlib.h", + "string.h" + ] + }, + "unresolved_includes": { + "stb/stb_hexwave.h": [] + }, + "header_source_pairs": { + "stb/stb_hexwave.h": [] + }, + "diagnostics": [ + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'hexwave_clamp' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_hexwave.h", + "line": 285, + "column": 1, + "source_line": "#define hexwave_clamp(v,a,b) ((v) < (a) ? (a) : (v) > (b) ? (b) : (v))" + }, + "unit_kind": "macro", + "unit_name": "hexwave_clamp" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STB_HEXWAVE_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_hexwave.h", + "line": 228, + "column": 1, + "source_line": "STB_HEXWAVE_DEF void hexwave_init(int width, int oversample, float *user_buffer);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STB_HEXWAVE_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STB_HEXWAVE_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_hexwave.h", + "line": 238, + "column": 1, + "source_line": "STB_HEXWAVE_DEF void hexwave_shutdown(float *user_buffer);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STB_HEXWAVE_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STB_HEXWAVE_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_hexwave.h", + "line": 241, + "column": 1, + "source_line": "STB_HEXWAVE_DEF void hexwave_create(HexWave *hex, int reflect, float peak_time, float half_height, float zero_wait);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STB_HEXWAVE_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STB_HEXWAVE_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_hexwave.h", + "line": 249, + "column": 1, + "source_line": "STB_HEXWAVE_DEF void hexwave_change(HexWave *hex, int reflect, float peak_time, float half_height, float zero_wait);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STB_HEXWAVE_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STB_HEXWAVE_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_hexwave.h", + "line": 252, + "column": 1, + "source_line": "STB_HEXWAVE_DEF void hexwave_generate_samples(float *output, int num_samples, HexWave *hex, float freq);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STB_HEXWAVE_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STB_HEXWAVE_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_hexwave.h", + "line": 287, + "column": 1, + "source_line": "STB_HEXWAVE_DEF void hexwave_change(HexWave *hex, int reflect, float peak_time, float half_height, float zero_wait)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STB_HEXWAVE_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STB_HEXWAVE_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_hexwave.h", + "line": 297, + "column": 1, + "source_line": "STB_HEXWAVE_DEF void hexwave_create(HexWave *hex, int reflect, float peak_time, float half_height, float zero_wait)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STB_HEXWAVE_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STB_HEXWAVE_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_hexwave.h", + "line": 418, + "column": 1, + "source_line": "STB_HEXWAVE_DEF void hexwave_generate_samples(float *output, int num_samples, HexWave *hex, float freq)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STB_HEXWAVE_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STB_HEXWAVE_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_hexwave.h", + "line": 546, + "column": 1, + "source_line": "STB_HEXWAVE_DEF void hexwave_shutdown(float *user_buffer)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STB_HEXWAVE_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STB_HEXWAVE_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_hexwave.h", + "line": 557, + "column": 1, + "source_line": "STB_HEXWAVE_DEF void hexwave_init(int width, int oversample, float *user_buffer)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STB_HEXWAVE_DEF" + } + ] +} diff --git a/tests/parser/c/fixtures/stb/stb_image.json b/tests/parser/c/fixtures/stb/stb_image.json new file mode 100644 index 000000000..ba84efa99 --- /dev/null +++ b/tests/parser/c/fixtures/stb/stb_image.json @@ -0,0 +1,56534 @@ +{ + "files": { + "stb/stb_image.h": { + "filename": "stb/stb_image.h", + "language": "c", + "parser_status": "partial", + "preprocessing": "raw", + "functions": [ + { + "name": "stbi__cpuid3", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 732, + "column": 1, + "source_line": "static int stbi__cpuid3(void)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 732, + "column": 1, + "source_line": "static int stbi__cpuid3(void)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 737, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__sse2_available", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 754, + "column": 1, + "source_line": "static int stbi__sse2_available(void)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 754, + "column": 1, + "source_line": "static int stbi__sse2_available(void)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 758, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__refill_buffer", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbi__context", + "name": "stbi__context", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "img_x", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbi__uint32", + "name": "stbi__uint32", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "typedef unsigned int stbi__uint32" + }, + "source_location": { + "filename": "stb/stb_image.h", + "line": 644, + "column": 1, + "source_line": "typedef unsigned int stbi__uint32;" + }, + "declaration_locations": [] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 807, + "column": 4, + "source_line": " stbi__uint32 img_x, img_y;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "img_y", + "type": { + "reference": "stbi__uint32" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 807, + "column": 4, + "source_line": " stbi__uint32 img_x, img_y;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "img_n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int img_n" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 808, + "column": 4, + "source_line": " int img_n, img_out_n;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "img_out_n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int img_out_n" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 808, + "column": 4, + "source_line": " int img_n, img_out_n;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "io", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbi_io_callbacks io", + "name": "stbi_io_callbacks", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 810, + "column": 4, + "source_line": " stbi_io_callbacks io;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "io_user_data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *io_user_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 811, + "column": 4, + "source_line": " void *io_user_data;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "read_from_callbacks", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int read_from_callbacks" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 813, + "column": 4, + "source_line": " int read_from_callbacks;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "buflen", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int buflen" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 814, + "column": 4, + "source_line": " int buflen;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "buffer_start", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc buffer_start[128]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "128", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbi_uc", + "name": "stbi_uc", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "typedef unsigned char stbi_uc" + }, + "source_location": { + "filename": "stb/stb_image.h", + "line": 387, + "column": 1, + "source_line": "typedef unsigned char stbi_uc;" + }, + "declaration_locations": [] + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 815, + "column": 4, + "source_line": " stbi_uc buffer_start[128];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "callback_already_read", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int callback_already_read" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 816, + "column": 4, + "source_line": " int callback_already_read;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "img_buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *img_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 818, + "column": 4, + "source_line": " stbi_uc *img_buffer, *img_buffer_end;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "img_buffer_end", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *img_buffer_end", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 818, + "column": 4, + "source_line": " stbi_uc *img_buffer, *img_buffer_end;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "img_buffer_original", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *img_buffer_original", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 819, + "column": 4, + "source_line": " stbi_uc *img_buffer_original, *img_buffer_original_end;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "img_buffer_original_end", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *img_buffer_original_end", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 819, + "column": 4, + "source_line": " stbi_uc *img_buffer_original, *img_buffer_original_end;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_image.h:805:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_image.h", + "line": 805, + "column": 1, + "source_line": "typedef struct" + } + }, + "source_location": { + "filename": "stb/stb_image.h", + "line": 805, + "column": 1, + "source_line": "typedef struct" + }, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1597, + "column": 1, + "source_line": "static void stbi__refill_buffer(stbi__context *s)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 1597, + "column": 1, + "source_line": "static void stbi__refill_buffer(stbi__context *s)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 1612, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_image.h", + "line": 823, + "column": 1, + "source_line": "static void stbi__refill_buffer(stbi__context *s);" + } + ] + }, + { + "name": "stbi__start_mem", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc const *buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc const *buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 826, + "column": 1, + "source_line": "static void stbi__start_mem(stbi__context *s, stbi_uc const *buffer, int len)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 826, + "column": 1, + "source_line": "static void stbi__start_mem(stbi__context *s, stbi_uc const *buffer, int len)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 833, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__start_callbacks", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_io_callbacks *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbi_io_callbacks", + "name": "stbi_io_callbacks", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_io_callbacks *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_io_callbacks" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "user", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *user", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *user", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 836, + "column": 1, + "source_line": "static void stbi__start_callbacks(stbi__context *s, stbi_io_callbacks *c, void *user)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 836, + "column": 1, + "source_line": "static void stbi__start_callbacks(stbi__context *s, stbi_io_callbacks *c, void *user)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 846, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__stdio_read", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "user", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *user", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *user", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "size", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int size" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int size" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 850, + "column": 1, + "source_line": "static int stbi__stdio_read(void *user, char *data, int size)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 850, + "column": 1, + "source_line": "static int stbi__stdio_read(void *user, char *data, int size)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 853, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__stdio_skip", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "user", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *user", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *user", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 855, + "column": 1, + "source_line": "static void stbi__stdio_skip(void *user, int n)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 855, + "column": 1, + "source_line": "static void stbi__stdio_skip(void *user, int n)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 863, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__stdio_eof", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "user", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *user", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *user", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 865, + "column": 1, + "source_line": "static int stbi__stdio_eof(void *user)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 865, + "column": 1, + "source_line": "static int stbi__stdio_eof(void *user)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 868, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__start_file", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "FILE *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "FILE", + "name": "FILE", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "FILE *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "FILE" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 877, + "column": 1, + "source_line": "static void stbi__start_file(stbi__context *s, FILE *f)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 877, + "column": 1, + "source_line": "static void stbi__start_file(stbi__context *s, FILE *f)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 880, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__rewind", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 886, + "column": 1, + "source_line": "static void stbi__rewind(stbi__context *s)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 886, + "column": 1, + "source_line": "static void stbi__rewind(stbi__context *s)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 893, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__jpeg_test", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4042, + "column": 1, + "source_line": "static int stbi__jpeg_test(stbi__context *s)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 4042, + "column": 1, + "source_line": "static int stbi__jpeg_test(stbi__context *s)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 4054, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_image.h", + "line": 909, + "column": 1, + "source_line": "static int stbi__jpeg_test(stbi__context *s);" + } + ] + }, + { + "name": "stbi__jpeg_load", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "req_comp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ri", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__result_info *ri", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbi__result_info", + "name": "stbi__result_info", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "bits_per_channel", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int bits_per_channel" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 903, + "column": 4, + "source_line": " int bits_per_channel;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "num_channels", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_channels" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 904, + "column": 4, + "source_line": " int num_channels;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "channel_order", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int channel_order" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 905, + "column": 4, + "source_line": " int channel_order;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_image.h:901:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_image.h", + "line": 901, + "column": 1, + "source_line": "typedef struct" + } + }, + "source_location": { + "filename": "stb/stb_image.h", + "line": 901, + "column": 1, + "source_line": "typedef struct" + }, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__result_info *ri", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__result_info" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4028, + "column": 1, + "source_line": "static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 4028, + "column": 1, + "source_line": "static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 4040, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_image.h", + "line": 910, + "column": 1, + "source_line": "static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);" + } + ] + }, + { + "name": "stbi__jpeg_info", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4068, + "column": 1, + "source_line": "static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 4068, + "column": 1, + "source_line": "static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 4078, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_image.h", + "line": 911, + "column": 1, + "source_line": "static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp);" + } + ] + }, + { + "name": "stbi__png_test", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 5302, + "column": 1, + "source_line": "static int stbi__png_test(stbi__context *s)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 5302, + "column": 1, + "source_line": "static int stbi__png_test(stbi__context *s)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 5308, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_image.h", + "line": 915, + "column": 1, + "source_line": "static int stbi__png_test(stbi__context *s);" + } + ] + }, + { + "name": "stbi__png_load", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "req_comp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ri", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__result_info *ri", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__result_info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__result_info *ri", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__result_info" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 5295, + "column": 1, + "source_line": "static void *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 5295, + "column": 1, + "source_line": "static void *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 5300, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_image.h", + "line": 916, + "column": 1, + "source_line": "static void *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);" + } + ] + }, + { + "name": "stbi__png_info", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 5322, + "column": 1, + "source_line": "static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 5322, + "column": 1, + "source_line": "static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 5327, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_image.h", + "line": 917, + "column": 1, + "source_line": "static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp);" + } + ] + }, + { + "name": "stbi__png_is16", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 5329, + "column": 1, + "source_line": "static int stbi__png_is16(stbi__context *s)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 5329, + "column": 1, + "source_line": "static int stbi__png_is16(stbi__context *s)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 5340, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_image.h", + "line": 918, + "column": 1, + "source_line": "static int stbi__png_is16(stbi__context *s);" + } + ] + }, + { + "name": "stbi__bmp_test", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 5361, + "column": 1, + "source_line": "static int stbi__bmp_test(stbi__context *s)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 5361, + "column": 1, + "source_line": "static int stbi__bmp_test(stbi__context *s)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 5366, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_image.h", + "line": 922, + "column": 1, + "source_line": "static int stbi__bmp_test(stbi__context *s);" + } + ] + }, + { + "name": "stbi__bmp_load", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "req_comp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ri", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__result_info *ri", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__result_info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__result_info *ri", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__result_info" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 5531, + "column": 1, + "source_line": "static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 5531, + "column": 1, + "source_line": "static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 5732, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_image.h", + "line": 923, + "column": 1, + "source_line": "static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);" + } + ] + }, + { + "name": "stbi__bmp_info", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7335, + "column": 1, + "source_line": "static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 7335, + "column": 1, + "source_line": "static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 7355, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_image.h", + "line": 924, + "column": 1, + "source_line": "static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp);" + } + ] + }, + { + "name": "stbi__tga_test", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 5820, + "column": 1, + "source_line": "static int stbi__tga_test(stbi__context *s)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 5820, + "column": 1, + "source_line": "static int stbi__tga_test(stbi__context *s)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 5849, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_image.h", + "line": 928, + "column": 1, + "source_line": "static int stbi__tga_test(stbi__context *s);" + } + ] + }, + { + "name": "stbi__tga_load", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "req_comp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ri", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__result_info *ri", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__result_info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__result_info *ri", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__result_info" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 5871, + "column": 1, + "source_line": "static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 5871, + "column": 1, + "source_line": "static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 6074, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_image.h", + "line": 929, + "column": 1, + "source_line": "static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);" + } + ] + }, + { + "name": "stbi__tga_info", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 5755, + "column": 1, + "source_line": "static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 5755, + "column": 1, + "source_line": "static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 5818, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_image.h", + "line": 930, + "column": 1, + "source_line": "static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp);" + } + ] + }, + { + "name": "stbi__psd_test", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 6081, + "column": 1, + "source_line": "static int stbi__psd_test(stbi__context *s)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 6081, + "column": 1, + "source_line": "static int stbi__psd_test(stbi__context *s)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 6086, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_image.h", + "line": 934, + "column": 1, + "source_line": "static int stbi__psd_test(stbi__context *s);" + } + ] + }, + { + "name": "stbi__psd_load", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "req_comp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ri", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__result_info *ri", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__result_info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__result_info *ri", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__result_info" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "bpc", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int bpc" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int bpc" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 6126, + "column": 1, + "source_line": "static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 6126, + "column": 1, + "source_line": "static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 6325, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_image.h", + "line": 935, + "column": 1, + "source_line": "static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc);" + } + ] + }, + { + "name": "stbi__psd_info", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7359, + "column": 1, + "source_line": "static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 7359, + "column": 1, + "source_line": "static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 7392, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_image.h", + "line": 936, + "column": 1, + "source_line": "static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp);" + } + ] + }, + { + "name": "stbi__psd_is16", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7394, + "column": 1, + "source_line": "static int stbi__psd_is16(stbi__context *s)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 7394, + "column": 1, + "source_line": "static int stbi__psd_is16(stbi__context *s)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 7419, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_image.h", + "line": 937, + "column": 1, + "source_line": "static int stbi__psd_is16(stbi__context *s);" + } + ] + }, + { + "name": "stbi__hdr_test", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context * s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context * s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7097, + "column": 1, + "source_line": "static int stbi__hdr_test(stbi__context* s)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 7097, + "column": 1, + "source_line": "static int stbi__hdr_test(stbi__context* s)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 7106, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_image.h", + "line": 941, + "column": 1, + "source_line": "static int stbi__hdr_test(stbi__context *s);" + } + ] + }, + { + "name": "stbi__hdr_load", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "req_comp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ri", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__result_info *ri", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__result_info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__result_info *ri", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__result_info" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7158, + "column": 1, + "source_line": "static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 7158, + "column": 1, + "source_line": "static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 7287, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_image.h", + "line": 942, + "column": 1, + "source_line": "static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);" + } + ] + }, + { + "name": "stbi__hdr_info", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7289, + "column": 1, + "source_line": "static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 7289, + "column": 1, + "source_line": "static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 7331, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_image.h", + "line": 943, + "column": 1, + "source_line": "static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp);" + } + ] + }, + { + "name": "stbi__pic_test", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 6541, + "column": 1, + "source_line": "static int stbi__pic_test(stbi__context *s)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 6541, + "column": 1, + "source_line": "static int stbi__pic_test(stbi__context *s)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 6546, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_image.h", + "line": 947, + "column": 1, + "source_line": "static int stbi__pic_test(stbi__context *s);" + } + ] + }, + { + "name": "stbi__pic_load", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "px", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *px", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *px", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "py", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *py", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *py", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "req_comp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ri", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__result_info *ri", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__result_info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__result_info *ri", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__result_info" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 6500, + "column": 1, + "source_line": "static void *stbi__pic_load(stbi__context *s,int *px,int *py,int *comp,int req_comp, stbi__result_info *ri)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 6500, + "column": 1, + "source_line": "static void *stbi__pic_load(stbi__context *s,int *px,int *py,int *comp,int req_comp, stbi__result_info *ri)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 6539, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_image.h", + "line": 948, + "column": 1, + "source_line": "static void *stbi__pic_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);" + } + ] + }, + { + "name": "stbi__pic_info", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7423, + "column": 1, + "source_line": "static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 7423, + "column": 1, + "source_line": "static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 7478, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_image.h", + "line": 949, + "column": 1, + "source_line": "static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp);" + } + ] + }, + { + "name": "stbi__gif_test", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 6590, + "column": 1, + "source_line": "static int stbi__gif_test(stbi__context *s)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 6590, + "column": 1, + "source_line": "static int stbi__gif_test(stbi__context *s)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 6595, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_image.h", + "line": 953, + "column": 1, + "source_line": "static int stbi__gif_test(stbi__context *s);" + } + ] + }, + { + "name": "stbi__gif_load", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "req_comp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ri", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__result_info *ri", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__result_info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__result_info *ri", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__result_info" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7048, + "column": 1, + "source_line": "static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 7048, + "column": 1, + "source_line": "static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 7075, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_image.h", + "line": 954, + "column": 1, + "source_line": "static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);" + } + ] + }, + { + "name": "stbi__load_gif_main", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "delays", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int **delays", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int **delays", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "z", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "req_comp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 6963, + "column": 1, + "source_line": "static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, int req_comp)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 6963, + "column": 1, + "source_line": "static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, int req_comp)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 7046, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_image.h", + "line": 955, + "column": 1, + "source_line": "static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, int req_comp);" + } + ] + }, + { + "name": "stbi__gif_info", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7077, + "column": 1, + "source_line": "static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 7077, + "column": 1, + "source_line": "static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 7080, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_image.h", + "line": 956, + "column": 1, + "source_line": "static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp);" + } + ] + }, + { + "name": "stbi__pnm_test", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7494, + "column": 1, + "source_line": "static int stbi__pnm_test(stbi__context *s)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 7494, + "column": 1, + "source_line": "static int stbi__pnm_test(stbi__context *s)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 7504, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_image.h", + "line": 960, + "column": 1, + "source_line": "static int stbi__pnm_test(stbi__context *s);" + } + ] + }, + { + "name": "stbi__pnm_load", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "req_comp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ri", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__result_info *ri", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__result_info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__result_info *ri", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__result_info" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7506, + "column": 1, + "source_line": "static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 7506, + "column": 1, + "source_line": "static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 7541, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_image.h", + "line": 961, + "column": 1, + "source_line": "static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);" + } + ] + }, + { + "name": "stbi__pnm_info", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7581, + "column": 1, + "source_line": "static int stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 7581, + "column": 1, + "source_line": "static int stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 7622, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_image.h", + "line": 962, + "column": 1, + "source_line": "static int stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp);" + } + ] + }, + { + "name": "stbi__pnm_is16", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7624, + "column": 1, + "source_line": "static int stbi__pnm_is16(stbi__context *s)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 7624, + "column": 1, + "source_line": "static int stbi__pnm_is16(stbi__context *s)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 7629, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_image.h", + "line": 963, + "column": 1, + "source_line": "static int stbi__pnm_is16(stbi__context *s);" + } + ] + }, + { + "name": "stbi__malloc", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "parameters": [ + { + "name": "size", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t size", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 985, + "column": 1, + "source_line": "static void *stbi__malloc(size_t size)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 985, + "column": 1, + "source_line": "static void *stbi__malloc(size_t size)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 988, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__addsizes_valid", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1002, + "column": 1, + "source_line": "static int stbi__addsizes_valid(int a, int b)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 1002, + "column": 1, + "source_line": "static int stbi__addsizes_valid(int a, int b)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 1010, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__mul2sizes_valid", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1014, + "column": 1, + "source_line": "static int stbi__mul2sizes_valid(int a, int b)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 1014, + "column": 1, + "source_line": "static int stbi__mul2sizes_valid(int a, int b)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 1020, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__mad2sizes_valid", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "add", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int add" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int add" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1024, + "column": 1, + "source_line": "static int stbi__mad2sizes_valid(int a, int b, int add)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 1024, + "column": 1, + "source_line": "static int stbi__mad2sizes_valid(int a, int b, int add)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 1027, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__mad3sizes_valid", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "add", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int add" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int add" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1031, + "column": 1, + "source_line": "static int stbi__mad3sizes_valid(int a, int b, int c, int add)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 1031, + "column": 1, + "source_line": "static int stbi__mad3sizes_valid(int a, int b, int c, int add)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 1035, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__mad4sizes_valid", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "d", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int d" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int d" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "add", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int add" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int add" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1039, + "column": 1, + "source_line": "static int stbi__mad4sizes_valid(int a, int b, int c, int d, int add)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 1039, + "column": 1, + "source_line": "static int stbi__mad4sizes_valid(int a, int b, int c, int d, int add)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 1043, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__malloc_mad2", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "add", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int add" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int add" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1048, + "column": 1, + "source_line": "static void *stbi__malloc_mad2(int a, int b, int add)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 1048, + "column": 1, + "source_line": "static void *stbi__malloc_mad2(int a, int b, int add)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 1052, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__malloc_mad3", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "add", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int add" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int add" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1055, + "column": 1, + "source_line": "static void *stbi__malloc_mad3(int a, int b, int c, int add)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 1055, + "column": 1, + "source_line": "static void *stbi__malloc_mad3(int a, int b, int c, int add)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 1059, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__malloc_mad4", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "d", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int d" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int d" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "add", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int add" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int add" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1062, + "column": 1, + "source_line": "static void *stbi__malloc_mad4(int a, int b, int c, int d, int add)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 1062, + "column": 1, + "source_line": "static void *stbi__malloc_mad4(int a, int b, int c, int d, int add)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 1066, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__addints_valid", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1070, + "column": 1, + "source_line": "static int stbi__addints_valid(int a, int b)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 1070, + "column": 1, + "source_line": "static int stbi__addints_valid(int a, int b)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 1075, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__mul2shorts_valid", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1078, + "column": 1, + "source_line": "static int stbi__mul2shorts_valid(int a, int b)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 1078, + "column": 1, + "source_line": "static int stbi__mul2shorts_valid(int a, int b)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 1084, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__ldr_to_hdr", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "parameters": [ + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int comp" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int comp" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1858, + "column": 1, + "source_line": "static float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 1858, + "column": 1, + "source_line": "static float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 1879, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_image.h", + "line": 1107, + "column": 1, + "source_line": "static float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp);" + } + ] + }, + { + "name": "stbi__hdr_to_ldr", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "parameters": [ + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int comp" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int comp" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1884, + "column": 1, + "source_line": "static stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 1884, + "column": 1, + "source_line": "static stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 1909, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_image.h", + "line": 1111, + "column": 1, + "source_line": "static stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp);" + } + ] + }, + { + "name": "stbi__load_main", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "req_comp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ri", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__result_info *ri", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__result_info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__result_info *ri", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__result_info" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "bpc", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int bpc" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int bpc" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1137, + "column": 1, + "source_line": "static void *stbi__load_main(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 1137, + "column": 1, + "source_line": "static void *stbi__load_main(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 1188, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__convert_16_to_8", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "parameters": [ + { + "name": "orig", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__uint16 *orig", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbi__uint16", + "name": "stbi__uint16", + "type": { + "model": "CUnsignedShort", + "qualifiers": [], + "source_text": "typedef unsigned short stbi__uint16" + }, + "source_location": { + "filename": "stb/stb_image.h", + "line": 642, + "column": 1, + "source_line": "typedef unsigned short stbi__uint16;" + }, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__uint16 *orig", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__uint16" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "w", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "h", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "channels", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int channels" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int channels" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1190, + "column": 1, + "source_line": "static stbi_uc *stbi__convert_16_to_8(stbi__uint16 *orig, int w, int h, int channels)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 1190, + "column": 1, + "source_line": "static stbi_uc *stbi__convert_16_to_8(stbi__uint16 *orig, int w, int h, int channels)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 1204, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__convert_8_to_16", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__uint16", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__uint16" + } + ] + }, + "parameters": [ + { + "name": "orig", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *orig", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *orig", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "w", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "h", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "channels", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int channels" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int channels" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1206, + "column": 1, + "source_line": "static stbi__uint16 *stbi__convert_8_to_16(stbi_uc *orig, int w, int h, int channels)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 1206, + "column": 1, + "source_line": "static stbi__uint16 *stbi__convert_8_to_16(stbi_uc *orig, int w, int h, int channels)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 1220, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__vertical_flip", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "image", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *image", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *image", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "w", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "h", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "bytes_per_pixel", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int bytes_per_pixel" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int bytes_per_pixel" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1222, + "column": 1, + "source_line": "static void stbi__vertical_flip(void *image, int w, int h, int bytes_per_pixel)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 1222, + "column": 1, + "source_line": "static void stbi__vertical_flip(void *image, int w, int h, int bytes_per_pixel)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 1244, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__vertical_flip_slices", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "image", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *image", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *image", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "w", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "h", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "z", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int z" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int z" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "bytes_per_pixel", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int bytes_per_pixel" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int bytes_per_pixel" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1247, + "column": 1, + "source_line": "static void stbi__vertical_flip_slices(void *image, int w, int h, int z, int bytes_per_pixel)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 1247, + "column": 1, + "source_line": "static void stbi__vertical_flip_slices(void *image, int w, int h, int z, int bytes_per_pixel)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 1257, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__load_and_postprocess_8bit", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "req_comp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1260, + "column": 1, + "source_line": "static unsigned char *stbi__load_and_postprocess_8bit(stbi__context *s, int *x, int *y, int *comp, int req_comp)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 1260, + "column": 1, + "source_line": "static unsigned char *stbi__load_and_postprocess_8bit(stbi__context *s, int *x, int *y, int *comp, int req_comp)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 1284, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__load_and_postprocess_16bit", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__uint16", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__uint16" + } + ] + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "req_comp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1286, + "column": 1, + "source_line": "static stbi__uint16 *stbi__load_and_postprocess_16bit(stbi__context *s, int *x, int *y, int *comp, int req_comp)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 1286, + "column": 1, + "source_line": "static stbi__uint16 *stbi__load_and_postprocess_16bit(stbi__context *s, int *x, int *y, int *comp, int req_comp)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 1311, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__float_postprocess", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "result", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *result", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *result", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "req_comp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1314, + "column": 1, + "source_line": "static void stbi__float_postprocess(float *result, int *x, int *y, int *comp, int req_comp)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 1314, + "column": 1, + "source_line": "static void stbi__float_postprocess(float *result, int *x, int *y, int *comp, int req_comp)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 1320, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__fopen", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "FILE", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "FILE", + "name": "FILE", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "parameters": [ + { + "name": "filename", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char const *filename", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char const *filename", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mode", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char const *mode", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char const *mode", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1337, + "column": 1, + "source_line": "static FILE *stbi__fopen(char const *filename, char const *mode)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 1337, + "column": 1, + "source_line": "static FILE *stbi__fopen(char const *filename, char const *mode)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 1363, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__loadf_main", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "req_comp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1460, + "column": 1, + "source_line": "static float *stbi__loadf_main(stbi__context *s, int *x, int *y, int *comp, int req_comp)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 1460, + "column": 1, + "source_line": "static float *stbi__loadf_main(stbi__context *s, int *x, int *y, int *comp, int req_comp)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 1476, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__skip", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1644, + "column": 1, + "source_line": "static void stbi__skip(stbi__context *s, int n)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 1644, + "column": 1, + "source_line": "static void stbi__skip(stbi__context *s, int n)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 1660, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__getn", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1666, + "column": 1, + "source_line": "static int stbi__getn(stbi__context *s, stbi_uc *buffer, int n)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 1666, + "column": 1, + "source_line": "static int stbi__getn(stbi__context *s, stbi_uc *buffer, int n)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 1688, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__get16be", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1694, + "column": 1, + "source_line": "static int stbi__get16be(stbi__context *s)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 1694, + "column": 1, + "source_line": "static int stbi__get16be(stbi__context *s)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 1698, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__get32be", + "result_type": { + "reference": "stbi__uint32" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1704, + "column": 1, + "source_line": "static stbi__uint32 stbi__get32be(stbi__context *s)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 1704, + "column": 1, + "source_line": "static stbi__uint32 stbi__get32be(stbi__context *s)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 1708, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__get16le", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1714, + "column": 1, + "source_line": "static int stbi__get16le(stbi__context *s)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 1714, + "column": 1, + "source_line": "static int stbi__get16le(stbi__context *s)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 1718, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__get32le", + "result_type": { + "reference": "stbi__uint32" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1722, + "column": 1, + "source_line": "static stbi__uint32 stbi__get32le(stbi__context *s)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 1722, + "column": 1, + "source_line": "static stbi__uint32 stbi__get32le(stbi__context *s)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 1727, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__compute_y", + "result_type": { + "reference": "stbi_uc" + }, + "parameters": [ + { + "name": "r", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int r" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int r" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "g", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int g" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int g" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1746, + "column": 1, + "source_line": "static stbi_uc stbi__compute_y(int r, int g, int b)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 1746, + "column": 1, + "source_line": "static stbi_uc stbi__compute_y(int r, int g, int b)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 1749, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__convert_format", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "parameters": [ + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "img_n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int img_n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int img_n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "req_comp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int x" + }, + "declared_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int y" + }, + "declared_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int y" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1755, + "column": 1, + "source_line": "static unsigned char *stbi__convert_format(unsigned char *data, int img_n, int req_comp, unsigned int x, unsigned int y)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 1755, + "column": 1, + "source_line": "static unsigned char *stbi__convert_format(unsigned char *data, int img_n, int req_comp, unsigned int x, unsigned int y)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 1797, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__compute_y_16", + "result_type": { + "reference": "stbi__uint16" + }, + "parameters": [ + { + "name": "r", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int r" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int r" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "g", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int g" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int g" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1803, + "column": 1, + "source_line": "static stbi__uint16 stbi__compute_y_16(int r, int g, int b)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 1803, + "column": 1, + "source_line": "static stbi__uint16 stbi__compute_y_16(int r, int g, int b)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 1806, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__convert_format16", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__uint16", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__uint16" + } + ] + }, + "parameters": [ + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__uint16 *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__uint16" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__uint16 *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__uint16" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "img_n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int img_n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int img_n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "req_comp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int x" + }, + "declared_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int y" + }, + "declared_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int y" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1812, + "column": 1, + "source_line": "static stbi__uint16 *stbi__convert_format16(stbi__uint16 *data, int img_n, int req_comp, unsigned int x, unsigned int y)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 1812, + "column": 1, + "source_line": "static stbi__uint16 *stbi__convert_format16(stbi__uint16 *data, int img_n, int req_comp, unsigned int x, unsigned int y)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 1854, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__build_huffman", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "h", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__huffman *h", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbi__huffman", + "name": "stbi__huffman", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "fast", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc fast[1 << FAST_BITS]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "1 << FAST_BITS", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "reference": "stbi_uc" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1940, + "column": 4, + "source_line": " stbi_uc fast[1 << FAST_BITS];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "code", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__uint16 code[256]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "256", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "reference": "stbi__uint16" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1942, + "column": 4, + "source_line": " stbi__uint16 code[256];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "values", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc values[256]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "256", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "reference": "stbi_uc" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1943, + "column": 4, + "source_line": " stbi_uc values[256];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "size", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc size[257]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "257", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "reference": "stbi_uc" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1944, + "column": 4, + "source_line": " stbi_uc size[257];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "maxcode", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned int maxcode[18]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "18", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1945, + "column": 4, + "source_line": " unsigned int maxcode[18];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "delta", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int delta[17]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "17", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1946, + "column": 4, + "source_line": " int delta[17]; // old 'firstsymbol' - old 'firstcode'" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_image.h:1938:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1938, + "column": 1, + "source_line": "typedef struct" + } + }, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1938, + "column": 1, + "source_line": "typedef struct" + }, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__huffman *h", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__huffman" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "count", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *count", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *count", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2003, + "column": 1, + "source_line": "static int stbi__build_huffman(stbi__huffman *h, int *count)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 2003, + "column": 1, + "source_line": "static int stbi__build_huffman(stbi__huffman *h, int *count)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 2046, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__build_fast_ac", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "fast_ac", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__int16 *fast_ac", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbi__int16", + "name": "stbi__int16", + "type": { + "model": "CShort", + "qualifiers": [], + "source_text": "typedef signed short stbi__int16" + }, + "source_location": { + "filename": "stb/stb_image.h", + "line": 643, + "column": 1, + "source_line": "typedef signed short stbi__int16;" + }, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__int16 *fast_ac", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__int16" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "h", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__huffman *h", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__huffman" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__huffman *h", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__huffman" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2050, + "column": 1, + "source_line": "static void stbi__build_fast_ac(stbi__int16 *fast_ac, stbi__huffman *h)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 2050, + "column": 1, + "source_line": "static void stbi__build_fast_ac(stbi__int16 *fast_ac, stbi__huffman *h)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 2073, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__grow_buffer_unsafe", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "j", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *j", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbi__jpeg", + "name": "stbi__jpeg", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1951, + "column": 4, + "source_line": " stbi__context *s;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "huff_dc", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__huffman huff_dc[4]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "4", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "reference": "stbi__huffman" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1952, + "column": 4, + "source_line": " stbi__huffman huff_dc[4];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "huff_ac", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__huffman huff_ac[4]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "4", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "reference": "stbi__huffman" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1953, + "column": 4, + "source_line": " stbi__huffman huff_ac[4];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "dequant", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__uint16 dequant[4][64]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "4", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "64", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "reference": "stbi__uint16" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1954, + "column": 4, + "source_line": " stbi__uint16 dequant[4][64];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "fast_ac", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__int16 fast_ac[4][1 << FAST_BITS]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "4", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "1 << FAST_BITS", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "reference": "stbi__int16" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1955, + "column": 4, + "source_line": " stbi__int16 fast_ac[4][1 << FAST_BITS];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "img_h_max", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int img_h_max" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1958, + "column": 4, + "source_line": " int img_h_max, img_v_max;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "img_v_max", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int img_v_max" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1958, + "column": 4, + "source_line": " int img_h_max, img_v_max;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "img_mcu_x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int img_mcu_x" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1959, + "column": 4, + "source_line": " int img_mcu_x, img_mcu_y;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "img_mcu_y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int img_mcu_y" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1959, + "column": 4, + "source_line": " int img_mcu_x, img_mcu_y;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "img_mcu_w", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int img_mcu_w" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1960, + "column": 4, + "source_line": " int img_mcu_w, img_mcu_h;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "img_mcu_h", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int img_mcu_h" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1960, + "column": 4, + "source_line": " int img_mcu_w, img_mcu_h;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "code_buffer", + "type": { + "reference": "stbi__uint32" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1979, + "column": 4, + "source_line": " stbi__uint32 code_buffer; // jpeg entropy-coded buffer" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "code_bits", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int code_bits" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1980, + "column": 4, + "source_line": " int code_bits; // number of valid bits" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "marker", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char marker" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1981, + "column": 4, + "source_line": " unsigned char marker; // marker seen while filling entropy buffer" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "nomore", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int nomore" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1982, + "column": 4, + "source_line": " int nomore; // flag if we saw a marker so must stop" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "progressive", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int progressive" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1984, + "column": 4, + "source_line": " int progressive;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "spec_start", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int spec_start" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1985, + "column": 4, + "source_line": " int spec_start;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "spec_end", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int spec_end" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1986, + "column": 4, + "source_line": " int spec_end;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "succ_high", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int succ_high" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1987, + "column": 4, + "source_line": " int succ_high;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "succ_low", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int succ_low" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1988, + "column": 4, + "source_line": " int succ_low;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "eob_run", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int eob_run" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1989, + "column": 4, + "source_line": " int eob_run;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "jfif", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int jfif" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1990, + "column": 4, + "source_line": " int jfif;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "app14_color_transform", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int app14_color_transform" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1991, + "column": 4, + "source_line": " int app14_color_transform; // Adobe APP14 tag" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "rgb", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int rgb" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1992, + "column": 4, + "source_line": " int rgb;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "scan_n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int scan_n" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1994, + "column": 4, + "source_line": " int scan_n, order[4];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "order", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int order[4]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "4", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1994, + "column": 4, + "source_line": " int scan_n, order[4];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "restart_interval", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int restart_interval" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1995, + "column": 4, + "source_line": " int restart_interval, todo;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "todo", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int todo" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1995, + "column": 4, + "source_line": " int restart_interval, todo;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "idct_block_kernel", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void (*idct_block_kernel)(stbi_uc *out, int out_stride, short data[64])", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFunctionType", + "qualifiers": [], + "source_text": "void", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameter_types": [ + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *out", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int out_stride" + }, + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short data[64]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + } + ], + "is_variadic": false, + "prototype_style": "prototype" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1998, + "column": 4, + "source_line": " void (*idct_block_kernel)(stbi_uc *out, int out_stride, short data[64]);" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "YCbCr_to_RGB_kernel", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void (*YCbCr_to_RGB_kernel)(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step)", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFunctionType", + "qualifiers": [], + "source_text": "void", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameter_types": [ + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *out", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stbi_uc *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stbi_uc *pcb", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stbi_uc *pcr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int count" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int step" + } + ], + "is_variadic": false, + "prototype_style": "prototype" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1999, + "column": 4, + "source_line": " void (*YCbCr_to_RGB_kernel)(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step);" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "resample_row_hv_2_kernel", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *(*resample_row_hv_2_kernel)(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFunctionType", + "qualifiers": [], + "source_text": "stbi_uc", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "parameter_types": [ + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *out", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *in_near", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *in_far", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int hs" + } + ], + "is_variadic": false, + "prototype_style": "prototype" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 2000, + "column": 4, + "source_line": " stbi_uc *(*resample_row_hv_2_kernel)(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs);" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_image.h:1949:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1949, + "column": 1, + "source_line": "typedef struct" + } + }, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1949, + "column": 1, + "source_line": "typedef struct" + }, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *j", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2075, + "column": 1, + "source_line": "static void stbi__grow_buffer_unsafe(stbi__jpeg *j)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 2075, + "column": 1, + "source_line": "static void stbi__grow_buffer_unsafe(stbi__jpeg *j)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 2091, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__jpeg_decode_block", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "j", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *j", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *j", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short data[64]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short data[64]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "64", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "hdc", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__huffman *hdc", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__huffman" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__huffman *hdc", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__huffman" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "hac", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__huffman *hac", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__huffman" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__huffman *hac", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__huffman" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "fac", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__int16 *fac", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__int16" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__int16 *fac", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__int16" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dequant", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__uint16 *dequant", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__uint16" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__uint16 *dequant", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__uint16" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2210, + "column": 1, + "source_line": "static int stbi__jpeg_decode_block(stbi__jpeg *j, short data[64], stbi__huffman *hdc, stbi__huffman *hac, stbi__int16 *fac, int b, stbi__uint16 *dequant)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 2210, + "column": 1, + "source_line": "static int stbi__jpeg_decode_block(stbi__jpeg *j, short data[64], stbi__huffman *hdc, stbi__huffman *hac, stbi__int16 *fac, int b, stbi__uint16 *dequant)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 2263, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__jpeg_decode_block_prog_dc", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "j", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *j", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *j", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short data[64]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short data[64]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "64", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "hdc", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__huffman *hdc", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__huffman" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__huffman *hdc", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__huffman" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2265, + "column": 1, + "source_line": "static int stbi__jpeg_decode_block_prog_dc(stbi__jpeg *j, short data[64], stbi__huffman *hdc, int b)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 2265, + "column": 1, + "source_line": "static int stbi__jpeg_decode_block_prog_dc(stbi__jpeg *j, short data[64], stbi__huffman *hdc, int b)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 2291, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__jpeg_decode_block_prog_ac", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "j", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *j", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *j", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short data[64]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short data[64]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "64", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "hac", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__huffman *hac", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__huffman" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__huffman *hac", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__huffman" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "fac", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__int16 *fac", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__int16" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__int16 *fac", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__int16" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2295, + "column": 1, + "source_line": "static int stbi__jpeg_decode_block_prog_ac(stbi__jpeg *j, short data[64], stbi__huffman *hac, stbi__int16 *fac)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 2295, + "column": 1, + "source_line": "static int stbi__jpeg_decode_block_prog_ac(stbi__jpeg *j, short data[64], stbi__huffman *hac, stbi__int16 *fac)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 2413, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__idct_block", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "out", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *out", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *out", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "out_stride", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int out_stride" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int out_stride" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short data[64]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short data[64]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "64", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2467, + "column": 1, + "source_line": "static void stbi__idct_block(stbi_uc *out, int out_stride, short data[64])" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 2467, + "column": 1, + "source_line": "static void stbi__idct_block(stbi_uc *out, int out_stride, short data[64])" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 2524, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__idct_simd", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "out", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *out", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *out", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "out_stride", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int out_stride" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int out_stride" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short data[64]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short data[64]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "64", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2530, + "column": 1, + "source_line": "static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64])" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 2530, + "column": 1, + "source_line": "static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64])" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 2703, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__get_marker", + "result_type": { + "reference": "stbi_uc" + }, + "parameters": [ + { + "name": "j", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *j", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *j", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2919, + "column": 1, + "source_line": "static stbi_uc stbi__get_marker(stbi__jpeg *j)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 2919, + "column": 1, + "source_line": "static stbi_uc stbi__get_marker(stbi__jpeg *j)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 2928, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__jpeg_reset", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "j", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *j", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *j", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2936, + "column": 1, + "source_line": "static void stbi__jpeg_reset(stbi__jpeg *j)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 2936, + "column": 1, + "source_line": "static void stbi__jpeg_reset(stbi__jpeg *j)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 2947, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__parse_entropy_coded_data", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "z", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2949, + "column": 1, + "source_line": "static int stbi__parse_entropy_coded_data(stbi__jpeg *z)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 2949, + "column": 1, + "source_line": "static int stbi__parse_entropy_coded_data(stbi__jpeg *z)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 3071, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__jpeg_dequantize", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dequant", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__uint16 *dequant", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__uint16" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__uint16 *dequant", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__uint16" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 3073, + "column": 1, + "source_line": "static void stbi__jpeg_dequantize(short *data, stbi__uint16 *dequant)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 3073, + "column": 1, + "source_line": "static void stbi__jpeg_dequantize(short *data, stbi__uint16 *dequant)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 3078, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__jpeg_finish", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "z", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 3080, + "column": 1, + "source_line": "static void stbi__jpeg_finish(stbi__jpeg *z)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 3080, + "column": 1, + "source_line": "static void stbi__jpeg_finish(stbi__jpeg *z)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 3097, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__process_marker", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "z", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "m", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int m" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int m" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 3099, + "column": 1, + "source_line": "static int stbi__process_marker(stbi__jpeg *z, int m)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 3099, + "column": 1, + "source_line": "static int stbi__process_marker(stbi__jpeg *z, int m)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 3200, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__process_scan_header", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "z", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 3203, + "column": 1, + "source_line": "static int stbi__process_scan_header(stbi__jpeg *z)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 3203, + "column": 1, + "source_line": "static int stbi__process_scan_header(stbi__jpeg *z)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 3240, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__free_jpeg_components", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "z", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ncomp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ncomp" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ncomp" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "why", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int why" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int why" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 3242, + "column": 1, + "source_line": "static int stbi__free_jpeg_components(stbi__jpeg *z, int ncomp, int why)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 3242, + "column": 1, + "source_line": "static int stbi__free_jpeg_components(stbi__jpeg *z, int ncomp, int why)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 3262, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__process_frame_header", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "z", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "scan", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int scan" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int scan" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 3264, + "column": 1, + "source_line": "static int stbi__process_frame_header(stbi__jpeg *z, int scan)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 3264, + "column": 1, + "source_line": "static int stbi__process_frame_header(stbi__jpeg *z, int scan)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 3354, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__decode_jpeg_header", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "z", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "scan", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int scan" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int scan" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 3365, + "column": 1, + "source_line": "static int stbi__decode_jpeg_header(stbi__jpeg *z, int scan)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 3365, + "column": 1, + "source_line": "static int stbi__decode_jpeg_header(stbi__jpeg *z, int scan)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 3387, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__skip_jpeg_junk_at_end", + "result_type": { + "reference": "stbi_uc" + }, + "parameters": [ + { + "name": "j", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *j", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *j", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 3389, + "column": 1, + "source_line": "static stbi_uc stbi__skip_jpeg_junk_at_end(stbi__jpeg *j)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 3389, + "column": 1, + "source_line": "static stbi_uc stbi__skip_jpeg_junk_at_end(stbi__jpeg *j)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 3409, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__decode_jpeg_image", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "j", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *j", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *j", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 3412, + "column": 1, + "source_line": "static int stbi__decode_jpeg_image(stbi__jpeg *j)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 3412, + "column": 1, + "source_line": "static int stbi__decode_jpeg_image(stbi__jpeg *j)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 3447, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "resample_row_1", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "parameters": [ + { + "name": "out", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *out", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *out", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "in_near", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *in_near", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *in_near", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "in_far", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *in_far", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *in_far", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "w", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "hs", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int hs" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int hs" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 3456, + "column": 1, + "source_line": "static stbi_uc *resample_row_1(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 3456, + "column": 1, + "source_line": "static stbi_uc *resample_row_1(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 3463, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__resample_row_v_2", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "parameters": [ + { + "name": "out", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *out", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *out", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "in_near", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *in_near", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *in_near", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "in_far", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *in_far", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *in_far", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "w", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "hs", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int hs" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int hs" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 3465, + "column": 1, + "source_line": "static stbi_uc* stbi__resample_row_v_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 3465, + "column": 1, + "source_line": "static stbi_uc* stbi__resample_row_v_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 3473, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__resample_row_h_2", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "parameters": [ + { + "name": "out", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *out", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *out", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "in_near", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *in_near", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *in_near", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "in_far", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *in_far", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *in_far", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "w", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "hs", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int hs" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int hs" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 3475, + "column": 1, + "source_line": "static stbi_uc* stbi__resample_row_h_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 3475, + "column": 1, + "source_line": "static stbi_uc* stbi__resample_row_h_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 3501, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__resample_row_hv_2", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "parameters": [ + { + "name": "out", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *out", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *out", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "in_near", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *in_near", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *in_near", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "in_far", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *in_far", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *in_far", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "w", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "hs", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int hs" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int hs" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 3505, + "column": 1, + "source_line": "static stbi_uc *stbi__resample_row_hv_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 3505, + "column": 1, + "source_line": "static stbi_uc *stbi__resample_row_hv_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 3527, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__resample_row_hv_2_simd", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "parameters": [ + { + "name": "out", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *out", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *out", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "in_near", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *in_near", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *in_near", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "in_far", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *in_far", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *in_far", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "w", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "hs", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int hs" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int hs" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 3530, + "column": 1, + "source_line": "static stbi_uc *stbi__resample_row_hv_2_simd(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 3530, + "column": 1, + "source_line": "static stbi_uc *stbi__resample_row_hv_2_simd(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 3643, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__resample_row_generic", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "parameters": [ + { + "name": "out", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *out", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *out", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "in_near", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *in_near", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *in_near", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "in_far", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *in_far", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *in_far", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "w", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "hs", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int hs" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int hs" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 3646, + "column": 1, + "source_line": "static stbi_uc *stbi__resample_row_generic(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 3646, + "column": 1, + "source_line": "static stbi_uc *stbi__resample_row_generic(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 3655, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__YCbCr_to_RGB_row", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "out", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *out", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *out", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stbi_uc *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stbi_uc *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "pcb", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stbi_uc *pcb", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stbi_uc *pcb", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "pcr", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stbi_uc *pcr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stbi_uc *pcr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "count", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int count" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int count" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "step", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int step" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int step" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 3660, + "column": 1, + "source_line": "static void stbi__YCbCr_to_RGB_row(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 3660, + "column": 1, + "source_line": "static void stbi__YCbCr_to_RGB_row(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 3683, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__YCbCr_to_RGB_simd", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "out", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *out", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *out", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc const *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc const *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "pcb", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc const *pcb", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc const *pcb", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "pcr", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc const *pcr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc const *pcr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "count", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int count" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int count" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "step", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int step" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int step" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 3686, + "column": 1, + "source_line": "static void stbi__YCbCr_to_RGB_simd(stbi_uc *out, stbi_uc const *y, stbi_uc const *pcb, stbi_uc const *pcr, int count, int step)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 3686, + "column": 1, + "source_line": "static void stbi__YCbCr_to_RGB_simd(stbi_uc *out, stbi_uc const *y, stbi_uc const *pcb, stbi_uc const *pcr, int count, int step)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 3817, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__setup_jpeg", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "j", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *j", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *j", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 3821, + "column": 1, + "source_line": "static void stbi__setup_jpeg(stbi__jpeg *j)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 3821, + "column": 1, + "source_line": "static void stbi__setup_jpeg(stbi__jpeg *j)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 3840, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__cleanup_jpeg", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "j", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *j", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *j", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 3843, + "column": 1, + "source_line": "static void stbi__cleanup_jpeg(stbi__jpeg *j)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 3843, + "column": 1, + "source_line": "static void stbi__cleanup_jpeg(stbi__jpeg *j)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 3846, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__blinn_8x8", + "result_type": { + "reference": "stbi_uc" + }, + "parameters": [ + { + "name": "x", + "type": { + "reference": "stbi_uc" + }, + "declared_type": { + "reference": "stbi_uc" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "reference": "stbi_uc" + }, + "declared_type": { + "reference": "stbi_uc" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 3859, + "column": 1, + "source_line": "static stbi_uc stbi__blinn_8x8(stbi_uc x, stbi_uc y)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 3859, + "column": 1, + "source_line": "static stbi_uc stbi__blinn_8x8(stbi_uc x, stbi_uc y)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 3863, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "load_jpeg_image", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "parameters": [ + { + "name": "z", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "out_x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *out_x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *out_x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "out_y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *out_y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *out_y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "req_comp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 3865, + "column": 1, + "source_line": "static stbi_uc *load_jpeg_image(stbi__jpeg *z, int *out_x, int *out_y, int *comp, int req_comp)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 3865, + "column": 1, + "source_line": "static stbi_uc *load_jpeg_image(stbi__jpeg *z, int *out_x, int *out_y, int *comp, int req_comp)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 4026, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__jpeg_info_raw", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "j", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *j", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *j", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4056, + "column": 1, + "source_line": "static int stbi__jpeg_info_raw(stbi__jpeg *j, int *x, int *y, int *comp)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 4056, + "column": 1, + "source_line": "static int stbi__jpeg_info_raw(stbi__jpeg *j, int *x, int *y, int *comp)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 4066, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__zbuild_huffman", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "z", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__zhuffman *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbi__zhuffman", + "name": "stbi__zhuffman", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "fast", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__uint16 fast[1 << STBI__ZFAST_BITS]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "1 << STBI__ZFAST_BITS", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "reference": "stbi__uint16" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 4099, + "column": 4, + "source_line": " stbi__uint16 fast[1 << STBI__ZFAST_BITS];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "firstcode", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__uint16 firstcode[16]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "16", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "reference": "stbi__uint16" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 4100, + "column": 4, + "source_line": " stbi__uint16 firstcode[16];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "maxcode", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int maxcode[17]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "17", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 4101, + "column": 4, + "source_line": " int maxcode[17];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "firstsymbol", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__uint16 firstsymbol[16]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "16", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "reference": "stbi__uint16" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 4102, + "column": 4, + "source_line": " stbi__uint16 firstsymbol[16];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "size", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc size[STBI__ZNSYMS]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STBI__ZNSYMS", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "reference": "stbi_uc" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 4103, + "column": 4, + "source_line": " stbi_uc size[STBI__ZNSYMS];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "value", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__uint16 value[STBI__ZNSYMS]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STBI__ZNSYMS", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "reference": "stbi__uint16" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 4104, + "column": 4, + "source_line": " stbi__uint16 value[STBI__ZNSYMS];" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_image.h:4097:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_image.h", + "line": 4097, + "column": 1, + "source_line": "typedef struct" + } + }, + "source_location": { + "filename": "stb/stb_image.h", + "line": 4097, + "column": 1, + "source_line": "typedef struct" + }, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__zhuffman *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__zhuffman" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "sizelist", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stbi_uc *sizelist", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stbi_uc *sizelist", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "num", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4124, + "column": 1, + "source_line": "static int stbi__zbuild_huffman(stbi__zhuffman *z, const stbi_uc *sizelist, int num)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 4124, + "column": 1, + "source_line": "static int stbi__zbuild_huffman(stbi__zhuffman *z, const stbi_uc *sizelist, int num)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 4169, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__fill_bits", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "z", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__zbuf *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbi__zbuf", + "name": "stbi__zbuf", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "zbuffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *zbuffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 4179, + "column": 4, + "source_line": " stbi_uc *zbuffer, *zbuffer_end;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "zbuffer_end", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *zbuffer_end", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 4179, + "column": 4, + "source_line": " stbi_uc *zbuffer, *zbuffer_end;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "num_bits", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_bits" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 4180, + "column": 4, + "source_line": " int num_bits;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "hit_zeof_once", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int hit_zeof_once" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 4181, + "column": 4, + "source_line": " int hit_zeof_once;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "code_buffer", + "type": { + "reference": "stbi__uint32" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 4182, + "column": 4, + "source_line": " stbi__uint32 code_buffer;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "zout", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *zout", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 4184, + "column": 4, + "source_line": " char *zout;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "zout_start", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *zout_start", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 4185, + "column": 4, + "source_line": " char *zout_start;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "zout_end", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *zout_end", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 4186, + "column": 4, + "source_line": " char *zout_end;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "z_expandable", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int z_expandable" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 4187, + "column": 4, + "source_line": " int z_expandable;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "z_length", + "type": { + "reference": "stbi__zhuffman" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 4189, + "column": 4, + "source_line": " stbi__zhuffman z_length, z_distance;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "z_distance", + "type": { + "reference": "stbi__zhuffman" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 4189, + "column": 4, + "source_line": " stbi__zhuffman z_length, z_distance;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_image.h:4177:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_image.h", + "line": 4177, + "column": 1, + "source_line": "typedef struct" + } + }, + "source_location": { + "filename": "stb/stb_image.h", + "line": 4177, + "column": 1, + "source_line": "typedef struct" + }, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__zbuf *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__zbuf" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4202, + "column": 1, + "source_line": "static void stbi__fill_bits(stbi__zbuf *z)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 4202, + "column": 1, + "source_line": "static void stbi__fill_bits(stbi__zbuf *z)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 4212, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__zhuffman_decode_slowpath", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__zbuf *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__zbuf" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__zbuf *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__zbuf" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "z", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__zhuffman *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__zhuffman" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__zhuffman *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__zhuffman" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4224, + "column": 1, + "source_line": "static int stbi__zhuffman_decode_slowpath(stbi__zbuf *a, stbi__zhuffman *z)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 4224, + "column": 1, + "source_line": "static int stbi__zhuffman_decode_slowpath(stbi__zbuf *a, stbi__zhuffman *z)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 4241, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__zexpand", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "z", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__zbuf *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__zbuf" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__zbuf *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__zbuf" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "zout", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *zout", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *zout", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4273, + "column": 1, + "source_line": "static int stbi__zexpand(stbi__zbuf *z, char *zout, int n) // need to make room for n bytes" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 4273, + "column": 1, + "source_line": "static int stbi__zexpand(stbi__zbuf *z, char *zout, int n) // need to make room for n bytes" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 4293, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__parse_huffman_block", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__zbuf *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__zbuf" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__zbuf *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__zbuf" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4309, + "column": 1, + "source_line": "static int stbi__parse_huffman_block(stbi__zbuf *a)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 4309, + "column": 1, + "source_line": "static int stbi__parse_huffman_block(stbi__zbuf *a)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 4357, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__compute_huffman_codes", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__zbuf *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__zbuf" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__zbuf *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__zbuf" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4359, + "column": 1, + "source_line": "static int stbi__compute_huffman_codes(stbi__zbuf *a)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 4359, + "column": 1, + "source_line": "static int stbi__compute_huffman_codes(stbi__zbuf *a)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 4407, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__parse_uncompressed_block", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__zbuf *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__zbuf" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__zbuf *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__zbuf" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4409, + "column": 1, + "source_line": "static int stbi__parse_uncompressed_block(stbi__zbuf *a)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 4409, + "column": 1, + "source_line": "static int stbi__parse_uncompressed_block(stbi__zbuf *a)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 4436, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__parse_zlib_header", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__zbuf *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__zbuf" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__zbuf *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__zbuf" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4438, + "column": 1, + "source_line": "static int stbi__parse_zlib_header(stbi__zbuf *a)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 4438, + "column": 1, + "source_line": "static int stbi__parse_zlib_header(stbi__zbuf *a)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 4450, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__parse_zlib", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__zbuf *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__zbuf" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__zbuf *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__zbuf" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "parse_header", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int parse_header" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int parse_header" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4481, + "column": 1, + "source_line": "static int stbi__parse_zlib(stbi__zbuf *a, int parse_header)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 4481, + "column": 1, + "source_line": "static int stbi__parse_zlib(stbi__zbuf *a, int parse_header)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 4508, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__do_zlib", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__zbuf *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__zbuf" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__zbuf *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__zbuf" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "obuf", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *obuf", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *obuf", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "olen", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int olen" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int olen" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "exp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int exp" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int exp" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "parse_header", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int parse_header" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int parse_header" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4510, + "column": 1, + "source_line": "static int stbi__do_zlib(stbi__zbuf *a, char *obuf, int olen, int exp, int parse_header)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 4510, + "column": 1, + "source_line": "static int stbi__do_zlib(stbi__zbuf *a, char *obuf, int olen, int exp, int parse_header)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 4518, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__get_chunk_header", + "result_type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbi__pngchunk", + "name": "stbi__pngchunk", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "length", + "type": { + "reference": "stbi__uint32" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 4609, + "column": 4, + "source_line": " stbi__uint32 length;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "type", + "type": { + "reference": "stbi__uint32" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 4610, + "column": 4, + "source_line": " stbi__uint32 type;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_image.h:4607:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_image.h", + "line": 4607, + "column": 1, + "source_line": "typedef struct" + } + }, + "source_location": { + "filename": "stb/stb_image.h", + "line": 4607, + "column": 1, + "source_line": "typedef struct" + }, + "declaration_locations": [] + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4613, + "column": 1, + "source_line": "static stbi__pngchunk stbi__get_chunk_header(stbi__context *s)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 4613, + "column": 1, + "source_line": "static stbi__pngchunk stbi__get_chunk_header(stbi__context *s)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 4619, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__check_png_header", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4621, + "column": 1, + "source_line": "static int stbi__check_png_header(stbi__context *s)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 4621, + "column": 1, + "source_line": "static int stbi__check_png_header(stbi__context *s)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 4628, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__paeth", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4657, + "column": 1, + "source_line": "static int stbi__paeth(int a, int b, int c)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 4657, + "column": 1, + "source_line": "static int stbi__paeth(int a, int b, int c)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 4668, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__create_png_alpha_expand8", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "dest", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *dest", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *dest", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "src", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *src", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *src", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "reference": "stbi__uint32" + }, + "declared_type": { + "reference": "stbi__uint32" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "img_n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int img_n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int img_n" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4675, + "column": 1, + "source_line": "static void stbi__create_png_alpha_expand8(stbi_uc *dest, stbi_uc *src, stbi__uint32 x, int img_n)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 4675, + "column": 1, + "source_line": "static void stbi__create_png_alpha_expand8(stbi_uc *dest, stbi_uc *src, stbi__uint32 x, int img_n)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 4693, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__create_png_image_raw", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__png *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbi__png", + "name": "stbi__png", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 4632, + "column": 4, + "source_line": " stbi__context *s;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "idata", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *idata", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 4633, + "column": 4, + "source_line": " stbi_uc *idata, *expanded, *out;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "expanded", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *expanded", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 4633, + "column": 4, + "source_line": " stbi_uc *idata, *expanded, *out;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "out", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *out", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 4633, + "column": 4, + "source_line": " stbi_uc *idata, *expanded, *out;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "depth", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int depth" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 4634, + "column": 4, + "source_line": " int depth;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_image.h:4630:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_image.h", + "line": 4630, + "column": 1, + "source_line": "typedef struct" + } + }, + "source_location": { + "filename": "stb/stb_image.h", + "line": 4630, + "column": 1, + "source_line": "typedef struct" + }, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__png *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__png" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "raw", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *raw", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *raw", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "raw_len", + "type": { + "reference": "stbi__uint32" + }, + "declared_type": { + "reference": "stbi__uint32" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "out_n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int out_n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int out_n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "reference": "stbi__uint32" + }, + "declared_type": { + "reference": "stbi__uint32" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "reference": "stbi__uint32" + }, + "declared_type": { + "reference": "stbi__uint32" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "depth", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int depth" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int depth" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "color", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int color" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int color" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4696, + "column": 1, + "source_line": "static int stbi__create_png_image_raw(stbi__png *a, stbi_uc *raw, stbi__uint32 raw_len, int out_n, stbi__uint32 x, stbi__uint32 y, int depth, int color)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 4696, + "column": 1, + "source_line": "static int stbi__create_png_image_raw(stbi__png *a, stbi_uc *raw, stbi__uint32 raw_len, int out_n, stbi__uint32 x, stbi__uint32 y, int depth, int color)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 4859, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__create_png_image", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__png *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__png" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__png *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__png" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "image_data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *image_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *image_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "image_data_len", + "type": { + "reference": "stbi__uint32" + }, + "declared_type": { + "reference": "stbi__uint32" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "out_n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int out_n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int out_n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "depth", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int depth" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int depth" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "color", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int color" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int color" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "interlaced", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int interlaced" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int interlaced" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4861, + "column": 1, + "source_line": "static int stbi__create_png_image(stbi__png *a, stbi_uc *image_data, stbi__uint32 image_data_len, int out_n, int depth, int color, int interlaced)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 4861, + "column": 1, + "source_line": "static int stbi__create_png_image(stbi__png *a, stbi_uc *image_data, stbi__uint32 image_data_len, int out_n, int depth, int color, int interlaced)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 4904, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__compute_transparency", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "z", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__png *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__png" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__png *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__png" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "tc", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc tc[3]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc tc[3]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "3", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "out_n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int out_n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int out_n" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4906, + "column": 1, + "source_line": "static int stbi__compute_transparency(stbi__png *z, stbi_uc tc[3], int out_n)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 4906, + "column": 1, + "source_line": "static int stbi__compute_transparency(stbi__png *z, stbi_uc tc[3], int out_n)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 4929, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__compute_transparency16", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "z", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__png *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__png" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__png *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__png" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "tc", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__uint16 tc[3]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__uint16" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__uint16 tc[3]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "3", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "reference": "stbi__uint16" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "out_n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int out_n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int out_n" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4931, + "column": 1, + "source_line": "static int stbi__compute_transparency16(stbi__png *z, stbi__uint16 tc[3], int out_n)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 4931, + "column": 1, + "source_line": "static int stbi__compute_transparency16(stbi__png *z, stbi__uint16 tc[3], int out_n)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 4954, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__expand_png_palette", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__png *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__png" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__png *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__png" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "palette", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *palette", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *palette", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "pal_img_n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int pal_img_n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int pal_img_n" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4956, + "column": 1, + "source_line": "static int stbi__expand_png_palette(stbi__png *a, stbi_uc *palette, int len, int pal_img_n)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 4956, + "column": 1, + "source_line": "static int stbi__expand_png_palette(stbi__png *a, stbi_uc *palette, int len, int pal_img_n)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 4991, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__de_iphone", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "z", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__png *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__png" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__png *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__png" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 5033, + "column": 1, + "source_line": "static void stbi__de_iphone(stbi__png *z)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 5033, + "column": 1, + "source_line": "static void stbi__de_iphone(stbi__png *z)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 5074, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__parse_png_file", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "z", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__png *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__png" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__png *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__png" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "scan", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int scan" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int scan" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "req_comp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 5078, + "column": 1, + "source_line": "static int stbi__parse_png_file(stbi__png *z, int scan, int req_comp)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 5078, + "column": 1, + "source_line": "static int stbi__parse_png_file(stbi__png *z, int scan, int req_comp)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 5261, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__do_png", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__png *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__png" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__png *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__png" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *n", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *n", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "req_comp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ri", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__result_info *ri", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__result_info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__result_info *ri", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__result_info" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 5263, + "column": 1, + "source_line": "static void *stbi__do_png(stbi__png *p, int *x, int *y, int *n, int req_comp, stbi__result_info *ri)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 5263, + "column": 1, + "source_line": "static void *stbi__do_png(stbi__png *p, int *x, int *y, int *n, int req_comp, stbi__result_info *ri)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 5293, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__png_info_raw", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__png *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__png" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__png *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__png" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 5310, + "column": 1, + "source_line": "static int stbi__png_info_raw(stbi__png *p, int *x, int *y, int *comp)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 5310, + "column": 1, + "source_line": "static int stbi__png_info_raw(stbi__png *p, int *x, int *y, int *comp)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 5320, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__bmp_test_raw", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 5346, + "column": 1, + "source_line": "static int stbi__bmp_test_raw(stbi__context *s)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 5346, + "column": 1, + "source_line": "static int stbi__bmp_test_raw(stbi__context *s)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 5359, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__high_bit", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "z", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int z" + }, + "declared_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int z" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 5370, + "column": 1, + "source_line": "static int stbi__high_bit(unsigned int z)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 5370, + "column": 1, + "source_line": "static int stbi__high_bit(unsigned int z)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 5380, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__bitcount", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int a" + }, + "declared_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int a" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 5382, + "column": 1, + "source_line": "static int stbi__bitcount(unsigned int a)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 5382, + "column": 1, + "source_line": "static int stbi__bitcount(unsigned int a)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 5390, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__shiftsigned", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "v", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int v" + }, + "declared_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int v" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "shift", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int shift" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int shift" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "bits", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int bits" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int bits" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 5395, + "column": 1, + "source_line": "static int stbi__shiftsigned(unsigned int v, int shift, int bits)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 5395, + "column": 1, + "source_line": "static int stbi__shiftsigned(unsigned int v, int shift, int bits)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 5413, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__bmp_set_mask_defaults", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__bmp_data *info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbi__bmp_data", + "name": "stbi__bmp_data", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "bpp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int bpp" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 5417, + "column": 4, + "source_line": " int bpp, offset, hsz;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "offset", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int offset" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 5417, + "column": 4, + "source_line": " int bpp, offset, hsz;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "hsz", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int hsz" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 5417, + "column": 4, + "source_line": " int bpp, offset, hsz;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "mr", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int mr" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 5418, + "column": 4, + "source_line": " unsigned int mr,mg,mb,ma, all_a;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "mg", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int mg" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 5418, + "column": 4, + "source_line": " unsigned int mr,mg,mb,ma, all_a;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "mb", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int mb" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 5418, + "column": 4, + "source_line": " unsigned int mr,mg,mb,ma, all_a;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "ma", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int ma" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 5418, + "column": 4, + "source_line": " unsigned int mr,mg,mb,ma, all_a;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "all_a", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int all_a" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 5418, + "column": 4, + "source_line": " unsigned int mr,mg,mb,ma, all_a;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "extra_read", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int extra_read" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 5419, + "column": 4, + "source_line": " int extra_read;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_image.h:5415:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_image.h", + "line": 5415, + "column": 1, + "source_line": "typedef struct" + } + }, + "source_location": { + "filename": "stb/stb_image.h", + "line": 5415, + "column": 1, + "source_line": "typedef struct" + }, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__bmp_data *info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__bmp_data" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "compress", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int compress" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int compress" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 5422, + "column": 1, + "source_line": "static int stbi__bmp_set_mask_defaults(stbi__bmp_data *info, int compress)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 5422, + "column": 1, + "source_line": "static int stbi__bmp_set_mask_defaults(stbi__bmp_data *info, int compress)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 5446, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__bmp_parse_header", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__bmp_data *info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__bmp_data" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__bmp_data *info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__bmp_data" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 5448, + "column": 1, + "source_line": "static void *stbi__bmp_parse_header(stbi__context *s, stbi__bmp_data *info)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 5448, + "column": 1, + "source_line": "static void *stbi__bmp_parse_header(stbi__context *s, stbi__bmp_data *info)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 5528, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__tga_get_comp", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "bits_per_pixel", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int bits_per_pixel" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int bits_per_pixel" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "is_grey", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int is_grey" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int is_grey" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "is_rgb16", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int * is_rgb16", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int * is_rgb16", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 5739, + "column": 1, + "source_line": "static int stbi__tga_get_comp(int bits_per_pixel, int is_grey, int* is_rgb16)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 5739, + "column": 1, + "source_line": "static int stbi__tga_get_comp(int bits_per_pixel, int is_grey, int* is_rgb16)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 5753, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__tga_read_rgb16", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "out", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc * out", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc * out", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 5852, + "column": 1, + "source_line": "static void stbi__tga_read_rgb16(stbi__context *s, stbi_uc* out)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 5852, + "column": 1, + "source_line": "static void stbi__tga_read_rgb16(stbi__context *s, stbi_uc* out)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 5869, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__psd_decode_rle", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "pixelCount", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int pixelCount" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int pixelCount" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 6088, + "column": 1, + "source_line": "static int stbi__psd_decode_rle(stbi__context *s, stbi_uc *p, int pixelCount)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 6088, + "column": 1, + "source_line": "static int stbi__psd_decode_rle(stbi__context *s, stbi_uc *p, int pixelCount)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 6124, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__pic_is4", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 6336, + "column": 1, + "source_line": "static int stbi__pic_is4(stbi__context *s,const char *str)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 6336, + "column": 1, + "source_line": "static int stbi__pic_is4(stbi__context *s,const char *str)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 6344, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__pic_test_core", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 6346, + "column": 1, + "source_line": "static int stbi__pic_test_core(stbi__context *s)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 6346, + "column": 1, + "source_line": "static int stbi__pic_test_core(stbi__context *s)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 6360, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__readval", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "channel", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int channel" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int channel" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dest", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *dest", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *dest", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 6367, + "column": 1, + "source_line": "static stbi_uc *stbi__readval(stbi__context *s, int channel, stbi_uc *dest)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 6367, + "column": 1, + "source_line": "static stbi_uc *stbi__readval(stbi__context *s, int channel, stbi_uc *dest)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 6379, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__copyval", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "channel", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int channel" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int channel" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dest", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *dest", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *dest", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "src", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stbi_uc *src", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stbi_uc *src", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 6381, + "column": 1, + "source_line": "static void stbi__copyval(int channel,stbi_uc *dest,const stbi_uc *src)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 6381, + "column": 1, + "source_line": "static void stbi__copyval(int channel,stbi_uc *dest,const stbi_uc *src)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 6388, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__pic_load_core", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "width", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "height", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int height" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int height" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "result", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *result", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *result", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 6390, + "column": 1, + "source_line": "static stbi_uc *stbi__pic_load_core(stbi__context *s,int width,int height,int *comp, stbi_uc *result)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 6390, + "column": 1, + "source_line": "static stbi_uc *stbi__pic_load_core(stbi__context *s,int width,int height,int *comp, stbi_uc *result)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 6498, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__gif_test_raw", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 6580, + "column": 1, + "source_line": "static int stbi__gif_test_raw(stbi__context *s)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 6580, + "column": 1, + "source_line": "static int stbi__gif_test_raw(stbi__context *s)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 6588, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__gif_parse_colortable", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "pal", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc pal[256][4]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "4", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc pal[256][4]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "256", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "4", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "num_entries", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_entries" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_entries" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "transp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int transp" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int transp" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 6597, + "column": 1, + "source_line": "static void stbi__gif_parse_colortable(stbi__context *s, stbi_uc pal[256][4], int num_entries, int transp)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 6597, + "column": 1, + "source_line": "static void stbi__gif_parse_colortable(stbi__context *s, stbi_uc pal[256][4], int num_entries, int transp)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 6606, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__gif_header", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "g", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__gif *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbi__gif", + "name": "stbi__gif", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "w", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 6562, + "column": 4, + "source_line": " int w,h;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "h", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 6562, + "column": 4, + "source_line": " int w,h;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "out", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *out", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 6563, + "column": 4, + "source_line": " stbi_uc *out; // output buffer (always 4 components)" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "background", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *background", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 6564, + "column": 4, + "source_line": " stbi_uc *background; // The current \"background\" as far as a gif is concerned" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "history", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *history", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 6565, + "column": 4, + "source_line": " stbi_uc *history;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "flags", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int flags" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 6566, + "column": 4, + "source_line": " int flags, bgindex, ratio, transparent, eflags;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "bgindex", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int bgindex" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 6566, + "column": 4, + "source_line": " int flags, bgindex, ratio, transparent, eflags;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "ratio", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ratio" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 6566, + "column": 4, + "source_line": " int flags, bgindex, ratio, transparent, eflags;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "transparent", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int transparent" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 6566, + "column": 4, + "source_line": " int flags, bgindex, ratio, transparent, eflags;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "eflags", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int eflags" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 6566, + "column": 4, + "source_line": " int flags, bgindex, ratio, transparent, eflags;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "pal", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc pal[256][4]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "256", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "4", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "reference": "stbi_uc" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 6567, + "column": 4, + "source_line": " stbi_uc pal[256][4];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "lpal", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc lpal[256][4]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "256", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "4", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "reference": "stbi_uc" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 6568, + "column": 4, + "source_line": " stbi_uc lpal[256][4];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "codes", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__gif_lzw codes[8192]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "8192", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbi__gif_lzw", + "name": "stbi__gif_lzw", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "prefix", + "type": { + "reference": "stbi__int16" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 6555, + "column": 4, + "source_line": " stbi__int16 prefix;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "first", + "type": { + "reference": "stbi_uc" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 6556, + "column": 4, + "source_line": " stbi_uc first;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "suffix", + "type": { + "reference": "stbi_uc" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 6557, + "column": 4, + "source_line": " stbi_uc suffix;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_image.h:6553:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_image.h", + "line": 6553, + "column": 1, + "source_line": "typedef struct" + } + }, + "source_location": { + "filename": "stb/stb_image.h", + "line": 6553, + "column": 1, + "source_line": "typedef struct" + }, + "declaration_locations": [] + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 6569, + "column": 4, + "source_line": " stbi__gif_lzw codes[8192];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "color_table", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *color_table", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 6570, + "column": 4, + "source_line": " stbi_uc *color_table;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "parse", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int parse" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 6571, + "column": 4, + "source_line": " int parse, step;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "step", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int step" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 6571, + "column": 4, + "source_line": " int parse, step;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "lflags", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int lflags" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 6572, + "column": 4, + "source_line": " int lflags;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "start_x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int start_x" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 6573, + "column": 4, + "source_line": " int start_x, start_y;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "start_y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int start_y" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 6573, + "column": 4, + "source_line": " int start_x, start_y;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "max_x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int max_x" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 6574, + "column": 4, + "source_line": " int max_x, max_y;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "max_y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int max_y" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 6574, + "column": 4, + "source_line": " int max_x, max_y;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "cur_x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int cur_x" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 6575, + "column": 4, + "source_line": " int cur_x, cur_y;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "cur_y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int cur_y" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 6575, + "column": 4, + "source_line": " int cur_x, cur_y;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "line_size", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int line_size" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 6576, + "column": 4, + "source_line": " int line_size;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "delay", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int delay" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 6577, + "column": 4, + "source_line": " int delay;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_image.h:6560:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_image.h", + "line": 6560, + "column": 1, + "source_line": "typedef struct" + } + }, + "source_location": { + "filename": "stb/stb_image.h", + "line": 6560, + "column": 1, + "source_line": "typedef struct" + }, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__gif *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__gif" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "is_info", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int is_info" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int is_info" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 6608, + "column": 1, + "source_line": "static int stbi__gif_header(stbi__context *s, stbi__gif *g, int *comp, int is_info)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 6608, + "column": 1, + "source_line": "static int stbi__gif_header(stbi__context *s, stbi__gif *g, int *comp, int is_info)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 6637, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__gif_info_raw", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 6639, + "column": 1, + "source_line": "static int stbi__gif_info_raw(stbi__context *s, int *x, int *y, int *comp)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 6639, + "column": 1, + "source_line": "static int stbi__gif_info_raw(stbi__context *s, int *x, int *y, int *comp)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 6652, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__out_gif_code", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "g", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__gif *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__gif" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__gif *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__gif" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "code", + "type": { + "reference": "stbi__uint16" + }, + "declared_type": { + "reference": "stbi__uint16" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 6654, + "column": 1, + "source_line": "static void stbi__out_gif_code(stbi__gif *g, stbi__uint16 code)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 6654, + "column": 1, + "source_line": "static void stbi__out_gif_code(stbi__gif *g, stbi__uint16 code)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 6689, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__process_gif_raster", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "g", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__gif *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__gif" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__gif *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__gif" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 6691, + "column": 1, + "source_line": "static stbi_uc *stbi__process_gif_raster(stbi__context *s, stbi__gif *g)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 6691, + "column": 1, + "source_line": "static stbi_uc *stbi__process_gif_raster(stbi__context *s, stbi__gif *g)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 6774, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__gif_load_next", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "g", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__gif *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__gif" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__gif *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__gif" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "req_comp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "two_back", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *two_back", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *two_back", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 6778, + "column": 1, + "source_line": "static stbi_uc *stbi__gif_load_next(stbi__context *s, stbi__gif *g, int *comp, int req_comp, stbi_uc *two_back)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 6778, + "column": 1, + "source_line": "static stbi_uc *stbi__gif_load_next(stbi__context *s, stbi__gif *g, int *comp, int req_comp, stbi_uc *two_back)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 6950, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__load_gif_main_outofmem", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "parameters": [ + { + "name": "g", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__gif *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__gif" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__gif *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__gif" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "out", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *out", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *out", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "delays", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int **delays", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int **delays", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 6952, + "column": 1, + "source_line": "static void *stbi__load_gif_main_outofmem(stbi__gif *g, stbi_uc *out, int **delays)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 6952, + "column": 1, + "source_line": "static void *stbi__load_gif_main_outofmem(stbi__gif *g, stbi_uc *out, int **delays)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 6961, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__hdr_test_core", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "signature", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *signature", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *signature", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7087, + "column": 1, + "source_line": "static int stbi__hdr_test_core(stbi__context *s, const char *signature)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 7087, + "column": 1, + "source_line": "static int stbi__hdr_test_core(stbi__context *s, const char *signature)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 7095, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__hdr_gettoken", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "parameters": [ + { + "name": "z", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7109, + "column": 1, + "source_line": "static char *stbi__hdr_gettoken(stbi__context *z, char *buffer)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 7109, + "column": 1, + "source_line": "static char *stbi__hdr_gettoken(stbi__context *z, char *buffer)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 7129, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__hdr_convert", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "output", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *output", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *output", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "input", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *input", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *input", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "req_comp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7131, + "column": 1, + "source_line": "static void stbi__hdr_convert(float *output, stbi_uc *input, int req_comp)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 7131, + "column": 1, + "source_line": "static void stbi__hdr_convert(float *output, stbi_uc *input, int req_comp)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 7156, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__pnm_isspace", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "c", + "type": { + "model": "CChar", + "qualifiers": [], + "source_text": "char c" + }, + "declared_type": { + "model": "CChar", + "qualifiers": [], + "source_text": "char c" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7543, + "column": 1, + "source_line": "static int stbi__pnm_isspace(char c)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 7543, + "column": 1, + "source_line": "static int stbi__pnm_isspace(char c)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 7546, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__pnm_skip_whitespace", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7548, + "column": 1, + "source_line": "static void stbi__pnm_skip_whitespace(stbi__context *s, char *c)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 7548, + "column": 1, + "source_line": "static void stbi__pnm_skip_whitespace(stbi__context *s, char *c)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 7560, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__pnm_isdigit", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "c", + "type": { + "model": "CChar", + "qualifiers": [], + "source_text": "char c" + }, + "declared_type": { + "model": "CChar", + "qualifiers": [], + "source_text": "char c" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7562, + "column": 1, + "source_line": "static int stbi__pnm_isdigit(char c)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 7562, + "column": 1, + "source_line": "static int stbi__pnm_isdigit(char c)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 7565, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__pnm_getinteger", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7567, + "column": 1, + "source_line": "static int stbi__pnm_getinteger(stbi__context *s, char *c)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 7567, + "column": 1, + "source_line": "static int stbi__pnm_getinteger(stbi__context *s, char *c)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 7579, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__info_main", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7632, + "column": 1, + "source_line": "static int stbi__info_main(stbi__context *s, int *x, int *y, int *comp)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 7632, + "column": 1, + "source_line": "static int stbi__info_main(stbi__context *s, int *x, int *y, int *comp)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 7672, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__is_16_main", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7674, + "column": 1, + "source_line": "static int stbi__is_16_main(stbi__context *s)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 7674, + "column": 1, + "source_line": "static int stbi__is_16_main(stbi__context *s)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 7688, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + } + ], + "structs": [ + { + "reference": "struct@stb/stb_image.h:805:1" + }, + { + "reference": "struct@stb/stb_image.h:901:1" + }, + { + "reference": "struct@stb/stb_image.h:1938:1" + }, + { + "reference": "struct@stb/stb_image.h:1949:1" + }, + { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "resample", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "resample_row_func", + "name": "resample_row_func", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "typedef stbi_uc *(*resample_row_func)(stbi_uc *out, stbi_uc *in0, stbi_uc *in1,\n int w, int hs)", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFunctionType", + "qualifiers": [], + "source_text": "stbi_uc", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "parameter_types": [ + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *out", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *in0", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *in1", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int hs" + } + ], + "is_variadic": false, + "prototype_style": "prototype" + } + ] + }, + "source_location": { + "filename": "stb/stb_image.h", + "line": 3451, + "column": 1, + "source_line": "typedef stbi_uc *(*resample_row_func)(stbi_uc *out, stbi_uc *in0, stbi_uc *in1," + }, + "declaration_locations": [] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 3850, + "column": 4, + "source_line": " resample_row_func resample;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "line0", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *line0", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 3851, + "column": 4, + "source_line": " stbi_uc *line0,*line1;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "line1", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *line1", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 3851, + "column": 4, + "source_line": " stbi_uc *line0,*line1;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "hs", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int hs" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 3852, + "column": 4, + "source_line": " int hs,vs; // expansion factor in each axis" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "vs", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int vs" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 3852, + "column": 4, + "source_line": " int hs,vs; // expansion factor in each axis" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "w_lores", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w_lores" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 3853, + "column": 4, + "source_line": " int w_lores; // horizontal pixels pre-expansion" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "ystep", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ystep" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 3854, + "column": 4, + "source_line": " int ystep; // how far through vertical expansion we are" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "ypos", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ypos" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 3855, + "column": 4, + "source_line": " int ypos; // which pre-expansion row we're on" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_image.h:3848:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_image.h", + "line": 3848, + "column": 1, + "source_line": "typedef struct" + } + }, + { + "reference": "struct@stb/stb_image.h:4097:1" + }, + { + "reference": "struct@stb/stb_image.h:4177:1" + }, + { + "reference": "struct@stb/stb_image.h:4607:1" + }, + { + "reference": "struct@stb/stb_image.h:4630:1" + }, + { + "reference": "struct@stb/stb_image.h:5415:1" + }, + { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "size", + "type": { + "reference": "stbi_uc" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 6364, + "column": 4, + "source_line": " stbi_uc size,type,channel;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "type", + "type": { + "reference": "stbi_uc" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 6364, + "column": 4, + "source_line": " stbi_uc size,type,channel;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "channel", + "type": { + "reference": "stbi_uc" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 6364, + "column": 4, + "source_line": " stbi_uc size,type,channel;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_image.h:6362:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_image.h", + "line": 6362, + "column": 1, + "source_line": "typedef struct" + } + }, + { + "reference": "struct@stb/stb_image.h:6553:1" + }, + { + "reference": "struct@stb/stb_image.h:6560:1" + } + ], + "unions": [], + "enums": [ + { + "model": "CEnum", + "qualifiers": [], + "source_text": "", + "name": null, + "constants": [ + { + "name": "STBI_default", + "value": "0", + "source_location": { + "filename": "stb/stb_image.h", + "line": 376, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBI_grey", + "value": "1", + "source_location": { + "filename": "stb/stb_image.h", + "line": 376, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBI_grey_alpha", + "value": "2", + "source_location": { + "filename": "stb/stb_image.h", + "line": 376, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBI_rgb", + "value": "3", + "source_location": { + "filename": "stb/stb_image.h", + "line": 376, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBI_rgb_alpha", + "value": "4", + "source_location": { + "filename": "stb/stb_image.h", + "line": 376, + "column": 1, + "source_line": "enum" + } + } + ], + "anonymous_id": "enum@stb/stb_image.h:376:1", + "source_location": { + "filename": "stb/stb_image.h", + "line": 376, + "column": 1, + "source_line": "enum" + } + }, + { + "model": "CEnum", + "qualifiers": [], + "source_text": "", + "name": null, + "constants": [ + { + "name": "STBI_ORDER_RGB", + "value": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 895, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBI_ORDER_BGR", + "value": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 895, + "column": 1, + "source_line": "enum" + } + } + ], + "anonymous_id": "enum@stb/stb_image.h:895:1", + "source_location": { + "filename": "stb/stb_image.h", + "line": 895, + "column": 1, + "source_line": "enum" + } + }, + { + "model": "CEnum", + "qualifiers": [], + "source_text": "", + "name": null, + "constants": [ + { + "name": "STBI__SCAN_load", + "value": "0", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1590, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBI__SCAN_type", + "value": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1590, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBI__SCAN_header", + "value": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1590, + "column": 1, + "source_line": "enum" + } + } + ], + "anonymous_id": "enum@stb/stb_image.h:1590:1", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1590, + "column": 1, + "source_line": "enum" + } + }, + { + "model": "CEnum", + "qualifiers": [], + "source_text": "", + "name": null, + "constants": [ + { + "name": "STBI__F_none", + "value": "0", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4638, + "column": 1, + "source_line": "enum {" + } + }, + { + "name": "STBI__F_sub", + "value": "1", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4638, + "column": 1, + "source_line": "enum {" + } + }, + { + "name": "STBI__F_up", + "value": "2", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4638, + "column": 1, + "source_line": "enum {" + } + }, + { + "name": "STBI__F_avg", + "value": "3", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4638, + "column": 1, + "source_line": "enum {" + } + }, + { + "name": "STBI__F_paeth", + "value": "4", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4638, + "column": 1, + "source_line": "enum {" + } + }, + { + "name": "STBI__F_avg_first", + "value": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 4638, + "column": 1, + "source_line": "enum {" + } + } + ], + "anonymous_id": "enum@stb/stb_image.h:4638:1", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4638, + "column": 1, + "source_line": "enum {" + } + } + ], + "typedefs": [ + { + "reference": "stbi_uc" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbi_us", + "name": "stbi_us", + "type": { + "model": "CUnsignedShort", + "qualifiers": [], + "source_text": "typedef unsigned short stbi_us" + }, + "source_location": { + "filename": "stb/stb_image.h", + "line": 388, + "column": 1, + "source_line": "typedef unsigned short stbi_us;" + }, + "declaration_locations": [] + }, + { + "reference": "stbi__uint16" + }, + { + "reference": "stbi__int16" + }, + { + "reference": "stbi__uint32" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbi__int32", + "name": "stbi__int32", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "typedef signed int stbi__int32" + }, + "source_location": { + "filename": "stb/stb_image.h", + "line": 645, + "column": 1, + "source_line": "typedef signed int stbi__int32;" + }, + "declaration_locations": [] + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "validate_uint32", + "name": "validate_uint32", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "typedef unsigned char validate_uint32[sizeof(stbi__uint32)==4 ? 1 : -1]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "sizeof(stbi__uint32)==4 ? 1 : -1", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": { + "filename": "stb/stb_image.h", + "line": 655, + "column": 1, + "source_line": "typedef unsigned char validate_uint32[sizeof(stbi__uint32)==4 ? 1 : -1];" + }, + "declaration_locations": [] + }, + { + "reference": "stbi__context" + }, + { + "reference": "stbi__result_info" + }, + { + "reference": "stbi__huffman" + }, + { + "reference": "stbi__jpeg" + }, + { + "reference": "resample_row_func" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbi__resample", + "name": "stbi__resample", + "type": { + "reference": "struct@stb/stb_image.h:3848:1" + }, + "source_location": { + "filename": "stb/stb_image.h", + "line": 3848, + "column": 1, + "source_line": "typedef struct" + }, + "declaration_locations": [] + }, + { + "reference": "stbi__zhuffman" + }, + { + "reference": "stbi__zbuf" + }, + { + "reference": "stbi__pngchunk" + }, + { + "reference": "stbi__png" + }, + { + "reference": "stbi__bmp_data" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbi__pic_packet", + "name": "stbi__pic_packet", + "type": { + "reference": "struct@stb/stb_image.h:6362:1" + }, + "source_location": { + "filename": "stb/stb_image.h", + "line": 6362, + "column": 1, + "source_line": "typedef struct" + }, + "declaration_locations": [] + }, + { + "reference": "stbi__gif_lzw" + }, + { + "reference": "stbi__gif" + } + ], + "variables": [ + { + "name": "stbi__vertically_flip_on_load_global", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "static int stbi__vertically_flip_on_load_global" + }, + "storage": [ + "static" + ], + "initializer": { + "source_text": "0" + }, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1114, + "column": 1, + "source_line": "static int stbi__vertically_flip_on_load_global = 0;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "stbi__l2h_gamma", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "static float stbi__l2h_gamma" + }, + "storage": [ + "static" + ], + "initializer": { + "source_text": "2.2f" + }, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1573, + "column": 1, + "source_line": "static float stbi__l2h_gamma=2.2f, stbi__l2h_scale=1.0f;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "stbi__l2h_scale", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "static float stbi__l2h_scale" + }, + "storage": [ + "static" + ], + "initializer": { + "source_text": "1.0f" + }, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1573, + "column": 1, + "source_line": "static float stbi__l2h_gamma=2.2f, stbi__l2h_scale=1.0f;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "stbi__h2l_gamma_i", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "static float stbi__h2l_gamma_i" + }, + "storage": [ + "static" + ], + "initializer": { + "source_text": "1.0f/2.2f" + }, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1579, + "column": 1, + "source_line": "static float stbi__h2l_gamma_i=1.0f/2.2f, stbi__h2l_scale_i=1.0f;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "stbi__h2l_scale_i", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "static float stbi__h2l_scale_i" + }, + "storage": [ + "static" + ], + "initializer": { + "source_text": "1.0f" + }, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1579, + "column": 1, + "source_line": "static float stbi__h2l_gamma_i=1.0f/2.2f, stbi__h2l_scale_i=1.0f;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "stbi__unpremultiply_on_load_global", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "static int stbi__unpremultiply_on_load_global" + }, + "storage": [ + "static" + ], + "initializer": { + "source_text": "0" + }, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 4993, + "column": 1, + "source_line": "static int stbi__unpremultiply_on_load_global = 0;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "stbi__de_iphone_flag_global", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "static int stbi__de_iphone_flag_global" + }, + "storage": [ + "static" + ], + "initializer": { + "source_text": "0" + }, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 4994, + "column": 1, + "source_line": "static int stbi__de_iphone_flag_global = 0;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "macros": [ + { + "name": "STBI_INCLUDE_STB_IMAGE_H", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 130, + "column": 1, + "source_line": "#define STBI_INCLUDE_STB_IMAGE_H" + } + }, + { + "name": "STBI_VERSION", + "value": "1", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 374, + "column": 1, + "source_line": "#define STBI_VERSION 1" + } + }, + { + "name": "STBIDEF", + "value": "static", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 396, + "column": 1, + "source_line": "#define STBIDEF static" + } + }, + { + "name": "STBIDEF", + "value": "extern", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 398, + "column": 1, + "source_line": "#define STBIDEF extern" + } + }, + { + "name": "STBI_NO_JPEG", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 554, + "column": 4, + "source_line": " #define STBI_NO_JPEG" + } + }, + { + "name": "STBI_NO_PNG", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 557, + "column": 4, + "source_line": " #define STBI_NO_PNG" + } + }, + { + "name": "STBI_NO_BMP", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 560, + "column": 4, + "source_line": " #define STBI_NO_BMP" + } + }, + { + "name": "STBI_NO_PSD", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 563, + "column": 4, + "source_line": " #define STBI_NO_PSD" + } + }, + { + "name": "STBI_NO_TGA", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 566, + "column": 4, + "source_line": " #define STBI_NO_TGA" + } + }, + { + "name": "STBI_NO_GIF", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 569, + "column": 4, + "source_line": " #define STBI_NO_GIF" + } + }, + { + "name": "STBI_NO_HDR", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 572, + "column": 4, + "source_line": " #define STBI_NO_HDR" + } + }, + { + "name": "STBI_NO_PIC", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 575, + "column": 4, + "source_line": " #define STBI_NO_PIC" + } + }, + { + "name": "STBI_NO_PNM", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 578, + "column": 4, + "source_line": " #define STBI_NO_PNM" + } + }, + { + "name": "STBI_NO_ZLIB", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 583, + "column": 1, + "source_line": "#define STBI_NO_ZLIB" + } + }, + { + "name": "STBI_ASSERT", + "value": "assert(x)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 603, + "column": 1, + "source_line": "#define STBI_ASSERT(x) assert(x)" + } + }, + { + "name": "STBI_EXTERN", + "value": "extern \"C\"", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 607, + "column": 1, + "source_line": "#define STBI_EXTERN extern \"C\"" + } + }, + { + "name": "STBI_EXTERN", + "value": "extern", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 609, + "column": 1, + "source_line": "#define STBI_EXTERN extern" + } + }, + { + "name": "stbi_inline", + "value": "inline", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 615, + "column": 4, + "source_line": " #define stbi_inline inline" + } + }, + { + "name": "stbi_inline", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 617, + "column": 4, + "source_line": " #define stbi_inline" + } + }, + { + "name": "stbi_inline", + "value": "__forceinline", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 620, + "column": 4, + "source_line": " #define stbi_inline __forceinline" + } + }, + { + "name": "STBI_THREAD_LOCAL", + "value": "thread_local", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 625, + "column": 7, + "source_line": " #define STBI_THREAD_LOCAL thread_local" + } + }, + { + "name": "STBI_THREAD_LOCAL", + "value": "__thread", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 627, + "column": 7, + "source_line": " #define STBI_THREAD_LOCAL __thread" + } + }, + { + "name": "STBI_THREAD_LOCAL", + "value": "__declspec(thread)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 629, + "column": 7, + "source_line": " #define STBI_THREAD_LOCAL __declspec(thread)" + } + }, + { + "name": "STBI_THREAD_LOCAL", + "value": "_Thread_local", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 631, + "column": 7, + "source_line": " #define STBI_THREAD_LOCAL _Thread_local" + } + }, + { + "name": "STBI_THREAD_LOCAL", + "value": "__thread", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 636, + "column": 9, + "source_line": " #define STBI_THREAD_LOCAL __thread" + } + }, + { + "name": "STBI_NOTUSED", + "value": "(void)(v)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 658, + "column": 1, + "source_line": "#define STBI_NOTUSED(v) (void)(v)" + } + }, + { + "name": "STBI_NOTUSED", + "value": "(void)sizeof(v)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 660, + "column": 1, + "source_line": "#define STBI_NOTUSED(v) (void)sizeof(v)" + } + }, + { + "name": "STBI_HAS_LROTL", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 664, + "column": 1, + "source_line": "#define STBI_HAS_LROTL" + } + }, + { + "name": "stbi_lrot", + "value": "_lrotl(x,y)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 668, + "column": 4, + "source_line": " #define stbi_lrot(x,y) _lrotl(x,y)" + } + }, + { + "name": "stbi_lrot", + "value": "(((x) << (y)) | ((x) >> (-(y) & 31)))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 670, + "column": 4, + "source_line": " #define stbi_lrot(x,y) (((x) << (y)) | ((x) >> (-(y) & 31)))" + } + }, + { + "name": "STBI_MALLOC", + "value": "malloc(sz)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 682, + "column": 1, + "source_line": "#define STBI_MALLOC(sz) malloc(sz)" + } + }, + { + "name": "STBI_REALLOC", + "value": "realloc(p,newsz)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 683, + "column": 1, + "source_line": "#define STBI_REALLOC(p,newsz) realloc(p,newsz)" + } + }, + { + "name": "STBI_FREE", + "value": "free(p)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 684, + "column": 1, + "source_line": "#define STBI_FREE(p) free(p)" + } + }, + { + "name": "STBI_REALLOC_SIZED", + "value": "STBI_REALLOC(p,newsz)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 688, + "column": 1, + "source_line": "#define STBI_REALLOC_SIZED(p,oldsz,newsz) STBI_REALLOC(p,newsz)" + } + }, + { + "name": "STBI__X64_TARGET", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 693, + "column": 1, + "source_line": "#define STBI__X64_TARGET" + } + }, + { + "name": "STBI__X86_TARGET", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 695, + "column": 1, + "source_line": "#define STBI__X86_TARGET" + } + }, + { + "name": "STBI_NO_SIMD", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 706, + "column": 1, + "source_line": "#define STBI_NO_SIMD" + } + }, + { + "name": "STBI_NO_SIMD", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 721, + "column": 1, + "source_line": "#define STBI_NO_SIMD" + } + }, + { + "name": "STBI_SSE2", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 725, + "column": 1, + "source_line": "#define STBI_SSE2" + } + }, + { + "name": "STBI_SIMD_ALIGN", + "value": "__declspec(align(16)) type name", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 751, + "column": 1, + "source_line": "#define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name" + } + }, + { + "name": "STBI_SIMD_ALIGN", + "value": "type name __attribute__((aligned(16)))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 762, + "column": 1, + "source_line": "#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16)))" + } + }, + { + "name": "STBI_NEON", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image.h", + "line": 779, + "column": 1, + "source_line": "#undef STBI_NEON" + } + }, + { + "name": "STBI_SIMD_ALIGN", + "value": "__declspec(align(16)) type name", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 785, + "column": 1, + "source_line": "#define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name" + } + }, + { + "name": "STBI_SIMD_ALIGN", + "value": "type name __attribute__((aligned(16)))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 787, + "column": 1, + "source_line": "#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16)))" + } + }, + { + "name": "STBI_SIMD_ALIGN", + "value": "type name", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 792, + "column": 1, + "source_line": "#define STBI_SIMD_ALIGN(type, name) type name" + } + }, + { + "name": "STBI_MAX_DIMENSIONS", + "value": "(1 << 24)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 796, + "column": 1, + "source_line": "#define STBI_MAX_DIMENSIONS (1 << 24)" + } + }, + { + "name": "stbi__err", + "value": "0", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1091, + "column": 4, + "source_line": " #define stbi__err(x,y) 0" + } + }, + { + "name": "stbi__err", + "value": "stbi__err(y)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1093, + "column": 4, + "source_line": " #define stbi__err(x,y) stbi__err(y)" + } + }, + { + "name": "stbi__err", + "value": "stbi__err(x)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1095, + "column": 4, + "source_line": " #define stbi__err(x,y) stbi__err(x)" + } + }, + { + "name": "stbi__errpf", + "value": "((float *)(size_t) (stbi__err(x,y)?NULL:NULL))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1098, + "column": 1, + "source_line": "#define stbi__errpf(x,y) ((float *)(size_t) (stbi__err(x,y)?NULL:NULL))" + } + }, + { + "name": "stbi__errpuc", + "value": "((unsigned char *)(size_t) (stbi__err(x,y)?NULL:NULL))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1099, + "column": 1, + "source_line": "#define stbi__errpuc(x,y) ((unsigned char *)(size_t) (stbi__err(x,y)?NULL:NULL))" + } + }, + { + "name": "stbi__vertically_flip_on_load", + "value": "stbi__vertically_flip_on_load_global", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1122, + "column": 1, + "source_line": "#define stbi__vertically_flip_on_load stbi__vertically_flip_on_load_global" + } + }, + { + "name": "stbi__vertically_flip_on_load", + "value": "(stbi__vertically_flip_on_load_set ? stbi__vertically_flip_on_load_local : stbi__vertically_flip_on_load_global)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1132, + "column": 1, + "source_line": "#define stbi__vertically_flip_on_load (stbi__vertically_flip_on_load_set \\" + } + }, + { + "name": "STBI__BYTECAST", + "value": "((stbi_uc) ((x) & 255))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1730, + "column": 1, + "source_line": "#define STBI__BYTECAST(x) ((stbi_uc) ((x) & 255)) // truncate int to byte without warnings" + } + }, + { + "name": "STBI__COMBO", + "value": "((a)*8+(b))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1773, + "column": 7, + "source_line": " #define STBI__COMBO(a,b) ((a)*8+(b))" + } + }, + { + "name": "STBI__CASE", + "value": "case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1774, + "column": 7, + "source_line": " #define STBI__CASE(a,b) case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b)" + } + }, + { + "name": "STBI__CASE", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1792, + "column": 7, + "source_line": " #undef STBI__CASE" + } + }, + { + "name": "STBI__COMBO", + "value": "((a)*8+(b))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1830, + "column": 7, + "source_line": " #define STBI__COMBO(a,b) ((a)*8+(b))" + } + }, + { + "name": "STBI__CASE", + "value": "case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1831, + "column": 7, + "source_line": " #define STBI__CASE(a,b) case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b)" + } + }, + { + "name": "STBI__CASE", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1849, + "column": 7, + "source_line": " #undef STBI__CASE" + } + }, + { + "name": "stbi__float2int", + "value": "((int) (x))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1883, + "column": 1, + "source_line": "#define stbi__float2int(x) ((int) (x))" + } + }, + { + "name": "FAST_BITS", + "value": "9", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1936, + "column": 1, + "source_line": "#define FAST_BITS 9 // larger handles more cases; smaller stomps less cache" + } + }, + { + "name": "stbi__f2f", + "value": "((int) (((x) * 4096 + 0.5)))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2426, + "column": 1, + "source_line": "#define stbi__f2f(x) ((int) (((x) * 4096 + 0.5)))" + } + }, + { + "name": "stbi__fsh", + "value": "((x) * 4096)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2427, + "column": 1, + "source_line": "#define stbi__fsh(x) ((x) * 4096)" + } + }, + { + "name": "STBI__IDCT_1D", + "value": "int t0,t1,t2,t3,p1,p2,p3,p4,p5,x0,x1,x2,x3; p2 = s2; p3 = s6; p1 = (p2+p3) * stbi__f2f(0.5411961f); t2 = p1 + p3*stbi__f2f(-1.847759065f); t3 = p1 + p2*stbi__f2f( 0.765366865f); p2 = s0; p3 = s4; t0 = stbi__fsh(p2+p3); t1 = stbi__fsh(p2-p3); x0 = t0+t3; x3 = t0-t3; x1 = t1+t2; x2 = t1-t2; t0 = s7; t1 = s5; t2 = s3; t3 = s1; p3 = t0+t2; p4 = t1+t3; p1 = t0+t3; p2 = t1+t2; p5 = (p3+p4)*stbi__f2f( 1.175875602f); t0 = t0*stbi__f2f( 0.298631336f); t1 = t1*stbi__f2f( 2.053119869f); t2 = t2*stbi__f2f( 3.072711026f); t3 = t3*stbi__f2f( 1.501321110f); p1 = p5 + p1*stbi__f2f(-0.899976223f); p2 = p5 + p2*stbi__f2f(-2.562915447f); p3 = p3*stbi__f2f(-1.961570560f); p4 = p4*stbi__f2f(-0.390180644f); t3 += p1+p4; t2 += p2+p3; t1 += p2+p4; t0 += p1+p3;", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2430, + "column": 1, + "source_line": "#define STBI__IDCT_1D(s0,s1,s2,s3,s4,s5,s6,s7) \\" + } + }, + { + "name": "dct_const", + "value": "_mm_setr_epi16((x),(y),(x),(y),(x),(y),(x),(y))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2537, + "column": 4, + "source_line": " #define dct_const(x,y) _mm_setr_epi16((x),(y),(x),(y),(x),(y),(x),(y))" + } + }, + { + "name": "dct_rot", + "value": "__m128i c0##lo = _mm_unpacklo_epi16((x),(y)); __m128i c0##hi = _mm_unpackhi_epi16((x),(y)); __m128i out0##_l = _mm_madd_epi16(c0##lo, c0); __m128i out0##_h = _mm_madd_epi16(c0##hi, c0); __m128i out1##_l = _mm_madd_epi16(c0##lo, c1); __m128i out1##_h = _mm_madd_epi16(c0##hi, c1)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2541, + "column": 4, + "source_line": " #define dct_rot(out0,out1, x,y,c0,c1) \\" + } + }, + { + "name": "dct_widen", + "value": "__m128i out##_l = _mm_srai_epi32(_mm_unpacklo_epi16(_mm_setzero_si128(), (in)), 4); __m128i out##_h = _mm_srai_epi32(_mm_unpackhi_epi16(_mm_setzero_si128(), (in)), 4)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2550, + "column": 4, + "source_line": " #define dct_widen(out, in) \\" + } + }, + { + "name": "dct_wadd", + "value": "__m128i out##_l = _mm_add_epi32(a##_l, b##_l); __m128i out##_h = _mm_add_epi32(a##_h, b##_h)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2555, + "column": 4, + "source_line": " #define dct_wadd(out, a, b) \\" + } + }, + { + "name": "dct_wsub", + "value": "__m128i out##_l = _mm_sub_epi32(a##_l, b##_l); __m128i out##_h = _mm_sub_epi32(a##_h, b##_h)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2560, + "column": 4, + "source_line": " #define dct_wsub(out, a, b) \\" + } + }, + { + "name": "dct_bfly32o", + "value": "{ __m128i abiased_l = _mm_add_epi32(a##_l, bias); __m128i abiased_h = _mm_add_epi32(a##_h, bias); dct_wadd(sum, abiased, b); dct_wsub(dif, abiased, b); out0 = _mm_packs_epi32(_mm_srai_epi32(sum_l, s), _mm_srai_epi32(sum_h, s)); out1 = _mm_packs_epi32(_mm_srai_epi32(dif_l, s), _mm_srai_epi32(dif_h, s)); }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2565, + "column": 4, + "source_line": " #define dct_bfly32o(out0, out1, a,b,bias,s) \\" + } + }, + { + "name": "dct_interleave8", + "value": "tmp = a; a = _mm_unpacklo_epi8(a, b); b = _mm_unpackhi_epi8(tmp, b)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2576, + "column": 4, + "source_line": " #define dct_interleave8(a, b) \\" + } + }, + { + "name": "dct_interleave16", + "value": "tmp = a; a = _mm_unpacklo_epi16(a, b); b = _mm_unpackhi_epi16(tmp, b)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2582, + "column": 4, + "source_line": " #define dct_interleave16(a, b) \\" + } + }, + { + "name": "dct_pass", + "value": "{ dct_rot(t2e,t3e, row2,row6, rot0_0,rot0_1); __m128i sum04 = _mm_add_epi16(row0, row4); __m128i dif04 = _mm_sub_epi16(row0, row4); dct_widen(t0e, sum04); dct_widen(t1e, dif04); dct_wadd(x0, t0e, t3e); dct_wsub(x3, t0e, t3e); dct_wadd(x1, t1e, t2e); dct_wsub(x2, t1e, t2e); dct_rot(y0o,y2o, row7,row3, rot2_0,rot2_1); dct_rot(y1o,y3o, row5,row1, rot3_0,rot3_1); __m128i sum17 = _mm_add_epi16(row1, row7); __m128i sum35 = _mm_add_epi16(row3, row5); dct_rot(y4o,y5o, sum17,sum35, rot1_0,rot1_1); dct_wadd(x4, y0o, y4o); dct_wadd(x5, y1o, y5o); dct_wadd(x6, y2o, y5o); dct_wadd(x7, y3o, y4o); dct_bfly32o(row0,row7, x0,x7,bias,shift); dct_bfly32o(row1,row6, x1,x6,bias,shift); dct_bfly32o(row2,row5, x2,x5,bias,shift); dct_bfly32o(row3,row4, x3,x4,bias,shift); }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2587, + "column": 4, + "source_line": " #define dct_pass(bias,shift) \\" + } + }, + { + "name": "dct_const", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2694, + "column": 1, + "source_line": "#undef dct_const" + } + }, + { + "name": "dct_rot", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2695, + "column": 1, + "source_line": "#undef dct_rot" + } + }, + { + "name": "dct_widen", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2696, + "column": 1, + "source_line": "#undef dct_widen" + } + }, + { + "name": "dct_wadd", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2697, + "column": 1, + "source_line": "#undef dct_wadd" + } + }, + { + "name": "dct_wsub", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2698, + "column": 1, + "source_line": "#undef dct_wsub" + } + }, + { + "name": "dct_bfly32o", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2699, + "column": 1, + "source_line": "#undef dct_bfly32o" + } + }, + { + "name": "dct_interleave8", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2700, + "column": 1, + "source_line": "#undef dct_interleave8" + } + }, + { + "name": "dct_interleave16", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2701, + "column": 1, + "source_line": "#undef dct_interleave16" + } + }, + { + "name": "dct_pass", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2702, + "column": 1, + "source_line": "#undef dct_pass" + } + }, + { + "name": "dct_long_mul", + "value": "int32x4_t out##_l = vmull_s16(vget_low_s16(inq), coeff); int32x4_t out##_h = vmull_s16(vget_high_s16(inq), coeff)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2728, + "column": 1, + "source_line": "#define dct_long_mul(out, inq, coeff) \\" + } + }, + { + "name": "dct_long_mac", + "value": "int32x4_t out##_l = vmlal_s16(acc##_l, vget_low_s16(inq), coeff); int32x4_t out##_h = vmlal_s16(acc##_h, vget_high_s16(inq), coeff)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2732, + "column": 1, + "source_line": "#define dct_long_mac(out, acc, inq, coeff) \\" + } + }, + { + "name": "dct_widen", + "value": "int32x4_t out##_l = vshll_n_s16(vget_low_s16(inq), 12); int32x4_t out##_h = vshll_n_s16(vget_high_s16(inq), 12)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2736, + "column": 1, + "source_line": "#define dct_widen(out, inq) \\" + } + }, + { + "name": "dct_wadd", + "value": "int32x4_t out##_l = vaddq_s32(a##_l, b##_l); int32x4_t out##_h = vaddq_s32(a##_h, b##_h)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2741, + "column": 1, + "source_line": "#define dct_wadd(out, a, b) \\" + } + }, + { + "name": "dct_wsub", + "value": "int32x4_t out##_l = vsubq_s32(a##_l, b##_l); int32x4_t out##_h = vsubq_s32(a##_h, b##_h)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2746, + "column": 1, + "source_line": "#define dct_wsub(out, a, b) \\" + } + }, + { + "name": "dct_bfly32o", + "value": "{ dct_wadd(sum, a, b); dct_wsub(dif, a, b); out0 = vcombine_s16(shiftop(sum_l, s), shiftop(sum_h, s)); out1 = vcombine_s16(shiftop(dif_l, s), shiftop(dif_h, s)); }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2751, + "column": 1, + "source_line": "#define dct_bfly32o(out0,out1, a,b,shiftop,s) \\" + } + }, + { + "name": "dct_pass", + "value": "{ int16x8_t sum26 = vaddq_s16(row2, row6); dct_long_mul(p1e, sum26, rot0_0); dct_long_mac(t2e, p1e, row6, rot0_1); dct_long_mac(t3e, p1e, row2, rot0_2); int16x8_t sum04 = vaddq_s16(row0, row4); int16x8_t dif04 = vsubq_s16(row0, row4); dct_widen(t0e, sum04); dct_widen(t1e, dif04); dct_wadd(x0, t0e, t3e); dct_wsub(x3, t0e, t3e); dct_wadd(x1, t1e, t2e); dct_wsub(x2, t1e, t2e); int16x8_t sum15 = vaddq_s16(row1, row5); int16x8_t sum17 = vaddq_s16(row1, row7); int16x8_t sum35 = vaddq_s16(row3, row5); int16x8_t sum37 = vaddq_s16(row3, row7); int16x8_t sumodd = vaddq_s16(sum17, sum35); dct_long_mul(p5o, sumodd, rot1_0); dct_long_mac(p1o, p5o, sum17, rot1_1); dct_long_mac(p2o, p5o, sum35, rot1_2); dct_long_mul(p3o, sum37, rot2_0); dct_long_mul(p4o, sum15, rot2_1); dct_wadd(sump13o, p1o, p3o); dct_wadd(sump24o, p2o, p4o); dct_wadd(sump23o, p2o, p3o); dct_wadd(sump14o, p1o, p4o); dct_long_mac(x4, sump13o, row7, rot3_0); dct_long_mac(x5, sump24o, row5, rot3_1); dct_long_mac(x6, sump23o, row3, rot3_2); dct_long_mac(x7, sump14o, row1, rot3_3); dct_bfly32o(row0,row7, x0,x7,shiftop,shift); dct_bfly32o(row1,row6, x1,x6,shiftop,shift); dct_bfly32o(row2,row5, x2,x5,shiftop,shift); dct_bfly32o(row3,row4, x3,x4,shiftop,shift); }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2759, + "column": 1, + "source_line": "#define dct_pass(shiftop, shift) \\" + } + }, + { + "name": "dct_trn16", + "value": "{ int16x8x2_t t = vtrnq_s16(x, y); x = t.val[0]; y = t.val[1]; }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2819, + "column": 1, + "source_line": "#define dct_trn16(x, y) { int16x8x2_t t = vtrnq_s16(x, y); x = t.val[0]; y = t.val[1]; }" + } + }, + { + "name": "dct_trn32", + "value": "{ int32x4x2_t t = vtrnq_s32(vreinterpretq_s32_s16(x), vreinterpretq_s32_s16(y)); x = vreinterpretq_s16_s32(t.val[0]); y = vreinterpretq_s16_s32(t.val[1]); }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2820, + "column": 1, + "source_line": "#define dct_trn32(x, y) { int32x4x2_t t = vtrnq_s32(vreinterpretq_s32_s16(x), vreinterpretq_s32_s16(y)); x = vreinterpretq_s16_s32(t.val[0]); y = vreinterpretq_s16_s32(t.val[1]); }" + } + }, + { + "name": "dct_trn64", + "value": "{ int16x8_t x0 = x; int16x8_t y0 = y; x = vcombine_s16(vget_low_s16(x0), vget_low_s16(y0)); y = vcombine_s16(vget_high_s16(x0), vget_high_s16(y0)); }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2821, + "column": 1, + "source_line": "#define dct_trn64(x, y) { int16x8_t x0 = x; int16x8_t y0 = y; x = vcombine_s16(vget_low_s16(x0), vget_low_s16(y0)); y = vcombine_s16(vget_high_s16(x0), vget_high_s16(y0)); }" + } + }, + { + "name": "dct_trn16", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2841, + "column": 1, + "source_line": "#undef dct_trn16" + } + }, + { + "name": "dct_trn32", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2842, + "column": 1, + "source_line": "#undef dct_trn32" + } + }, + { + "name": "dct_trn64", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2843, + "column": 1, + "source_line": "#undef dct_trn64" + } + }, + { + "name": "dct_trn8_8", + "value": "{ uint8x8x2_t t = vtrn_u8(x, y); x = t.val[0]; y = t.val[1]; }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2864, + "column": 1, + "source_line": "#define dct_trn8_8(x, y) { uint8x8x2_t t = vtrn_u8(x, y); x = t.val[0]; y = t.val[1]; }" + } + }, + { + "name": "dct_trn8_16", + "value": "{ uint16x4x2_t t = vtrn_u16(vreinterpret_u16_u8(x), vreinterpret_u16_u8(y)); x = vreinterpret_u8_u16(t.val[0]); y = vreinterpret_u8_u16(t.val[1]); }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2865, + "column": 1, + "source_line": "#define dct_trn8_16(x, y) { uint16x4x2_t t = vtrn_u16(vreinterpret_u16_u8(x), vreinterpret_u16_u8(y)); x = vreinterpret_u8_u16(t.val[0]); y = vreinterpret_u8_u16(t.val[1]); }" + } + }, + { + "name": "dct_trn8_32", + "value": "{ uint32x2x2_t t = vtrn_u32(vreinterpret_u32_u8(x), vreinterpret_u32_u8(y)); x = vreinterpret_u8_u32(t.val[0]); y = vreinterpret_u8_u32(t.val[1]); }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2866, + "column": 1, + "source_line": "#define dct_trn8_32(x, y) { uint32x2x2_t t = vtrn_u32(vreinterpret_u32_u8(x), vreinterpret_u32_u8(y)); x = vreinterpret_u8_u32(t.val[0]); y = vreinterpret_u8_u32(t.val[1]); }" + } + }, + { + "name": "dct_trn8_8", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2899, + "column": 1, + "source_line": "#undef dct_trn8_8" + } + }, + { + "name": "dct_trn8_16", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2900, + "column": 1, + "source_line": "#undef dct_trn8_16" + } + }, + { + "name": "dct_trn8_32", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2901, + "column": 1, + "source_line": "#undef dct_trn8_32" + } + }, + { + "name": "dct_long_mul", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2904, + "column": 1, + "source_line": "#undef dct_long_mul" + } + }, + { + "name": "dct_long_mac", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2905, + "column": 1, + "source_line": "#undef dct_long_mac" + } + }, + { + "name": "dct_widen", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2906, + "column": 1, + "source_line": "#undef dct_widen" + } + }, + { + "name": "dct_wadd", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2907, + "column": 1, + "source_line": "#undef dct_wadd" + } + }, + { + "name": "dct_wsub", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2908, + "column": 1, + "source_line": "#undef dct_wsub" + } + }, + { + "name": "dct_bfly32o", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2909, + "column": 1, + "source_line": "#undef dct_bfly32o" + } + }, + { + "name": "dct_pass", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2910, + "column": 1, + "source_line": "#undef dct_pass" + } + }, + { + "name": "STBI__MARKER_none", + "value": "0xff", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2915, + "column": 1, + "source_line": "#define STBI__MARKER_none 0xff" + } + }, + { + "name": "STBI__RESTART", + "value": "((x) >= 0xd0 && (x) <= 0xd7)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2932, + "column": 1, + "source_line": "#define STBI__RESTART(x) ((x) >= 0xd0 && (x) <= 0xd7)" + } + }, + { + "name": "stbi__DNL", + "value": "((x) == 0xdc)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 3357, + "column": 1, + "source_line": "#define stbi__DNL(x) ((x) == 0xdc)" + } + }, + { + "name": "stbi__SOI", + "value": "((x) == 0xd8)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 3358, + "column": 1, + "source_line": "#define stbi__SOI(x) ((x) == 0xd8)" + } + }, + { + "name": "stbi__EOI", + "value": "((x) == 0xd9)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 3359, + "column": 1, + "source_line": "#define stbi__EOI(x) ((x) == 0xd9)" + } + }, + { + "name": "stbi__SOF", + "value": "((x) == 0xc0 || (x) == 0xc1 || (x) == 0xc2)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 3360, + "column": 1, + "source_line": "#define stbi__SOF(x) ((x) == 0xc0 || (x) == 0xc1 || (x) == 0xc2)" + } + }, + { + "name": "stbi__SOS", + "value": "((x) == 0xda)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 3361, + "column": 1, + "source_line": "#define stbi__SOS(x) ((x) == 0xda)" + } + }, + { + "name": "stbi__SOF_progressive", + "value": "((x) == 0xc2)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 3363, + "column": 1, + "source_line": "#define stbi__SOF_progressive(x) ((x) == 0xc2)" + } + }, + { + "name": "stbi__div4", + "value": "((stbi_uc) ((x) >> 2))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 3454, + "column": 1, + "source_line": "#define stbi__div4(x) ((stbi_uc) ((x) >> 2))" + } + }, + { + "name": "stbi__div16", + "value": "((stbi_uc) ((x) >> 4))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 3503, + "column": 1, + "source_line": "#define stbi__div16(x) ((stbi_uc) ((x) >> 4))" + } + }, + { + "name": "stbi__float2fixed", + "value": "(((int) ((x) * 4096.0f + 0.5f)) << 8)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 3659, + "column": 1, + "source_line": "#define stbi__float2fixed(x) (((int) ((x) * 4096.0f + 0.5f)) << 8)" + } + }, + { + "name": "STBI__ZFAST_BITS", + "value": "9", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4091, + "column": 1, + "source_line": "#define STBI__ZFAST_BITS 9 // accelerate all cases in default tables" + } + }, + { + "name": "STBI__ZFAST_MASK", + "value": "((1 << STBI__ZFAST_BITS) - 1)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4092, + "column": 1, + "source_line": "#define STBI__ZFAST_MASK ((1 << STBI__ZFAST_BITS) - 1)" + } + }, + { + "name": "STBI__ZNSYMS", + "value": "288", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4093, + "column": 1, + "source_line": "#define STBI__ZNSYMS 288 // number of symbols in literal/length alphabet" + } + }, + { + "name": "stbi__unpremultiply_on_load", + "value": "stbi__unpremultiply_on_load_global", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 5007, + "column": 1, + "source_line": "#define stbi__unpremultiply_on_load stbi__unpremultiply_on_load_global" + } + }, + { + "name": "stbi__de_iphone_flag", + "value": "stbi__de_iphone_flag_global", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 5008, + "column": 1, + "source_line": "#define stbi__de_iphone_flag stbi__de_iphone_flag_global" + } + }, + { + "name": "stbi__unpremultiply_on_load", + "value": "(stbi__unpremultiply_on_load_set ? stbi__unpremultiply_on_load_local : stbi__unpremultiply_on_load_global)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 5025, + "column": 1, + "source_line": "#define stbi__unpremultiply_on_load (stbi__unpremultiply_on_load_set \\" + } + }, + { + "name": "stbi__de_iphone_flag", + "value": "(stbi__de_iphone_flag_set ? stbi__de_iphone_flag_local : stbi__de_iphone_flag_global)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 5028, + "column": 1, + "source_line": "#define stbi__de_iphone_flag (stbi__de_iphone_flag_set \\" + } + }, + { + "name": "STBI__PNG_TYPE", + "value": "(((unsigned) (a) << 24) + ((unsigned) (b) << 16) + ((unsigned) (c) << 8) + (unsigned) (d))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 5076, + "column": 1, + "source_line": "#define STBI__PNG_TYPE(a,b,c,d) (((unsigned) (a) << 24) + ((unsigned) (b) << 16) + ((unsigned) (c) << 8) + (unsigned) (d))" + } + }, + { + "name": "STBI__HDR_BUFLEN", + "value": "1024", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7108, + "column": 1, + "source_line": "#define STBI__HDR_BUFLEN 1024" + } + } + ], + "includes": [ + { + "target": "stdio.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 371, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "stdlib.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 386, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "stdarg.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 587, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "stddef.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 588, + "column": 1, + "source_line": "#include // ptrdiff_t on osx" + } + }, + { + "target": "stdlib.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 589, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "string.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 590, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "limits.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 591, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "math.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 594, + "column": 1, + "source_line": "#include // ldexp, pow" + } + }, + { + "target": "stdio.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 598, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "assert.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 602, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "stdint.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 647, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "emmintrin.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 726, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "intrin.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 731, + "column": 1, + "source_line": "#include // __cpuid" + } + }, + { + "target": "arm_neon.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 783, + "column": 1, + "source_line": "#include " + } + } + ], + "raw_directives": [ + { + "directive": "ifndef", + "argument": "STBI_INCLUDE_STB_IMAGE_H", + "source_location": { + "filename": "stb/stb_image.h", + "line": 129, + "column": 1, + "source_line": "#ifndef STBI_INCLUDE_STB_IMAGE_H" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_STDIO", + "source_location": { + "filename": "stb/stb_image.h", + "line": 370, + "column": 1, + "source_line": "#ifndef STBI_NO_STDIO" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 372, + "column": 1, + "source_line": "#endif // STBI_NO_STDIO" + } + }, + { + "directive": "ifdef", + "argument": "__cplusplus", + "source_location": { + "filename": "stb/stb_image.h", + "line": 390, + "column": 1, + "source_line": "#ifdef __cplusplus" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 392, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBIDEF", + "source_location": { + "filename": "stb/stb_image.h", + "line": 394, + "column": 1, + "source_line": "#ifndef STBIDEF" + } + }, + { + "directive": "ifdef", + "argument": "STB_IMAGE_STATIC", + "source_location": { + "filename": "stb/stb_image.h", + "line": 395, + "column": 1, + "source_line": "#ifdef STB_IMAGE_STATIC" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 397, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 399, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 400, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_STDIO", + "source_location": { + "filename": "stb/stb_image.h", + "line": 426, + "column": 1, + "source_line": "#ifndef STBI_NO_STDIO" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 430, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_GIF", + "source_location": { + "filename": "stb/stb_image.h", + "line": 432, + "column": 1, + "source_line": "#ifndef STBI_NO_GIF" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 434, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBI_WINDOWS_UTF8", + "source_location": { + "filename": "stb/stb_image.h", + "line": 436, + "column": 1, + "source_line": "#ifdef STBI_WINDOWS_UTF8" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 438, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_STDIO", + "source_location": { + "filename": "stb/stb_image.h", + "line": 448, + "column": 1, + "source_line": "#ifndef STBI_NO_STDIO" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 451, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_LINEAR", + "source_location": { + "filename": "stb/stb_image.h", + "line": 457, + "column": 1, + "source_line": "#ifndef STBI_NO_LINEAR" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_STDIO", + "source_location": { + "filename": "stb/stb_image.h", + "line": 461, + "column": 4, + "source_line": " #ifndef STBI_NO_STDIO" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 464, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 465, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_HDR", + "source_location": { + "filename": "stb/stb_image.h", + "line": 467, + "column": 1, + "source_line": "#ifndef STBI_NO_HDR" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 470, + "column": 1, + "source_line": "#endif // STBI_NO_HDR" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_LINEAR", + "source_location": { + "filename": "stb/stb_image.h", + "line": 472, + "column": 1, + "source_line": "#ifndef STBI_NO_LINEAR" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 475, + "column": 1, + "source_line": "#endif // STBI_NO_LINEAR" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_STDIO", + "source_location": { + "filename": "stb/stb_image.h", + "line": 480, + "column": 1, + "source_line": "#ifndef STBI_NO_STDIO" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 483, + "column": 1, + "source_line": "#endif // STBI_NO_STDIO" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_STDIO", + "source_location": { + "filename": "stb/stb_image.h", + "line": 499, + "column": 1, + "source_line": "#ifndef STBI_NO_STDIO" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 504, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "__cplusplus", + "source_location": { + "filename": "stb/stb_image.h", + "line": 538, + "column": 1, + "source_line": "#ifdef __cplusplus" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 540, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 545, + "column": 1, + "source_line": "#endif // STBI_INCLUDE_STB_IMAGE_H" + } + }, + { + "directive": "ifdef", + "argument": "STB_IMAGE_IMPLEMENTATION", + "source_location": { + "filename": "stb/stb_image.h", + "line": 547, + "column": 1, + "source_line": "#ifdef STB_IMAGE_IMPLEMENTATION" + } + }, + { + "directive": "if", + "argument": "defined(STBI_ONLY_JPEG) || defined(STBI_ONLY_PNG) || defined(STBI_ONLY_BMP) || defined(STBI_ONLY_TGA) || defined(STBI_ONLY_GIF) || defined(STBI_ONLY_PSD) || defined(STBI_ONLY_HDR) || defined(STBI_ONLY_PIC) || defined(STBI_ONLY_PNM) || defined(STBI_ONLY_ZLIB)", + "source_location": { + "filename": "stb/stb_image.h", + "line": 549, + "column": 1, + "source_line": "#if defined(STBI_ONLY_JPEG) || defined(STBI_ONLY_PNG) || defined(STBI_ONLY_BMP) \\" + } + }, + { + "directive": "ifndef", + "argument": "STBI_ONLY_JPEG", + "source_location": { + "filename": "stb/stb_image.h", + "line": 553, + "column": 4, + "source_line": " #ifndef STBI_ONLY_JPEG" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 555, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_ONLY_PNG", + "source_location": { + "filename": "stb/stb_image.h", + "line": 556, + "column": 4, + "source_line": " #ifndef STBI_ONLY_PNG" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 558, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_ONLY_BMP", + "source_location": { + "filename": "stb/stb_image.h", + "line": 559, + "column": 4, + "source_line": " #ifndef STBI_ONLY_BMP" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 561, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_ONLY_PSD", + "source_location": { + "filename": "stb/stb_image.h", + "line": 562, + "column": 4, + "source_line": " #ifndef STBI_ONLY_PSD" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 564, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_ONLY_TGA", + "source_location": { + "filename": "stb/stb_image.h", + "line": 565, + "column": 4, + "source_line": " #ifndef STBI_ONLY_TGA" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 567, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_ONLY_GIF", + "source_location": { + "filename": "stb/stb_image.h", + "line": 568, + "column": 4, + "source_line": " #ifndef STBI_ONLY_GIF" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 570, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_ONLY_HDR", + "source_location": { + "filename": "stb/stb_image.h", + "line": 571, + "column": 4, + "source_line": " #ifndef STBI_ONLY_HDR" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 573, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_ONLY_PIC", + "source_location": { + "filename": "stb/stb_image.h", + "line": 574, + "column": 4, + "source_line": " #ifndef STBI_ONLY_PIC" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 576, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_ONLY_PNM", + "source_location": { + "filename": "stb/stb_image.h", + "line": 577, + "column": 4, + "source_line": " #ifndef STBI_ONLY_PNM" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 579, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 580, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "defined(STBI_NO_PNG) && !defined(STBI_SUPPORT_ZLIB) && !defined(STBI_NO_ZLIB)", + "source_location": { + "filename": "stb/stb_image.h", + "line": 582, + "column": 1, + "source_line": "#if defined(STBI_NO_PNG) && !defined(STBI_SUPPORT_ZLIB) && !defined(STBI_NO_ZLIB)" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 584, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "!defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR)", + "source_location": { + "filename": "stb/stb_image.h", + "line": 593, + "column": 1, + "source_line": "#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR)" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 595, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_STDIO", + "source_location": { + "filename": "stb/stb_image.h", + "line": 597, + "column": 1, + "source_line": "#ifndef STBI_NO_STDIO" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 599, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_ASSERT", + "source_location": { + "filename": "stb/stb_image.h", + "line": 601, + "column": 1, + "source_line": "#ifndef STBI_ASSERT" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 604, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "__cplusplus", + "source_location": { + "filename": "stb/stb_image.h", + "line": 606, + "column": 1, + "source_line": "#ifdef __cplusplus" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 608, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 610, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "_MSC_VER", + "source_location": { + "filename": "stb/stb_image.h", + "line": 613, + "column": 1, + "source_line": "#ifndef _MSC_VER" + } + }, + { + "directive": "ifdef", + "argument": "__cplusplus", + "source_location": { + "filename": "stb/stb_image.h", + "line": 614, + "column": 4, + "source_line": " #ifdef __cplusplus" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 616, + "column": 4, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 618, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 619, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 621, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_THREAD_LOCALS", + "source_location": { + "filename": "stb/stb_image.h", + "line": 623, + "column": 1, + "source_line": "#ifndef STBI_NO_THREAD_LOCALS" + } + }, + { + "directive": "if", + "argument": "defined(__cplusplus) && __cplusplus >= 201103L", + "source_location": { + "filename": "stb/stb_image.h", + "line": 624, + "column": 4, + "source_line": " #if defined(__cplusplus) && __cplusplus >= 201103L" + } + }, + { + "directive": "elif", + "argument": "defined(__GNUC__) && __GNUC__ < 5", + "source_location": { + "filename": "stb/stb_image.h", + "line": 626, + "column": 4, + "source_line": " #elif defined(__GNUC__) && __GNUC__ < 5" + } + }, + { + "directive": "elif", + "argument": "defined(_MSC_VER)", + "source_location": { + "filename": "stb/stb_image.h", + "line": 628, + "column": 4, + "source_line": " #elif defined(_MSC_VER)" + } + }, + { + "directive": "elif", + "argument": "defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L && !defined(__STDC_NO_THREADS__)", + "source_location": { + "filename": "stb/stb_image.h", + "line": 630, + "column": 4, + "source_line": " #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L && !defined(__STDC_NO_THREADS__)" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 632, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_THREAD_LOCAL", + "source_location": { + "filename": "stb/stb_image.h", + "line": 634, + "column": 4, + "source_line": " #ifndef STBI_THREAD_LOCAL" + } + }, + { + "directive": "if", + "argument": "defined(__GNUC__)", + "source_location": { + "filename": "stb/stb_image.h", + "line": 635, + "column": 7, + "source_line": " #if defined(__GNUC__)" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 637, + "column": 7, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 638, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 639, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "defined(_MSC_VER) || defined(__SYMBIAN32__)", + "source_location": { + "filename": "stb/stb_image.h", + "line": 641, + "column": 1, + "source_line": "#if defined(_MSC_VER) || defined(__SYMBIAN32__)" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 646, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 652, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "_MSC_VER", + "source_location": { + "filename": "stb/stb_image.h", + "line": 657, + "column": 1, + "source_line": "#ifdef _MSC_VER" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 659, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 661, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "_MSC_VER", + "source_location": { + "filename": "stb/stb_image.h", + "line": 663, + "column": 1, + "source_line": "#ifdef _MSC_VER" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 665, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBI_HAS_LROTL", + "source_location": { + "filename": "stb/stb_image.h", + "line": 667, + "column": 1, + "source_line": "#ifdef STBI_HAS_LROTL" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 669, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 671, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "defined(STBI_MALLOC) && defined(STBI_FREE) && (defined(STBI_REALLOC) || defined(STBI_REALLOC_SIZED))", + "source_location": { + "filename": "stb/stb_image.h", + "line": 673, + "column": 1, + "source_line": "#if defined(STBI_MALLOC) && defined(STBI_FREE) && (defined(STBI_REALLOC) || defined(STBI_REALLOC_SIZED))" + } + }, + { + "directive": "elif", + "argument": "!defined(STBI_MALLOC) && !defined(STBI_FREE) && !defined(STBI_REALLOC) && !defined(STBI_REALLOC_SIZED)", + "source_location": { + "filename": "stb/stb_image.h", + "line": 675, + "column": 1, + "source_line": "#elif !defined(STBI_MALLOC) && !defined(STBI_FREE) && !defined(STBI_REALLOC) && !defined(STBI_REALLOC_SIZED)" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 677, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 679, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_MALLOC", + "source_location": { + "filename": "stb/stb_image.h", + "line": 681, + "column": 1, + "source_line": "#ifndef STBI_MALLOC" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 685, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_REALLOC_SIZED", + "source_location": { + "filename": "stb/stb_image.h", + "line": 687, + "column": 1, + "source_line": "#ifndef STBI_REALLOC_SIZED" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 689, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "defined(__x86_64__) || defined(_M_X64)", + "source_location": { + "filename": "stb/stb_image.h", + "line": 692, + "column": 1, + "source_line": "#if defined(__x86_64__) || defined(_M_X64)" + } + }, + { + "directive": "elif", + "argument": "defined(__i386) || defined(_M_IX86)", + "source_location": { + "filename": "stb/stb_image.h", + "line": 694, + "column": 1, + "source_line": "#elif defined(__i386) || defined(_M_IX86)" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 696, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "defined(__GNUC__) && defined(STBI__X86_TARGET) && !defined(__SSE2__) && !defined(STBI_NO_SIMD)", + "source_location": { + "filename": "stb/stb_image.h", + "line": 698, + "column": 1, + "source_line": "#if defined(__GNUC__) && defined(STBI__X86_TARGET) && !defined(__SSE2__) && !defined(STBI_NO_SIMD)" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 707, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "defined(__MINGW32__) && defined(STBI__X86_TARGET) && !defined(STBI_MINGW_ENABLE_SSE2) && !defined(STBI_NO_SIMD)", + "source_location": { + "filename": "stb/stb_image.h", + "line": 709, + "column": 1, + "source_line": "#if defined(__MINGW32__) && defined(STBI__X86_TARGET) && !defined(STBI_MINGW_ENABLE_SSE2) && !defined(STBI_NO_SIMD)" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 722, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "!defined(STBI_NO_SIMD) && (defined(STBI__X86_TARGET) || defined(STBI__X64_TARGET))", + "source_location": { + "filename": "stb/stb_image.h", + "line": 724, + "column": 1, + "source_line": "#if !defined(STBI_NO_SIMD) && (defined(STBI__X86_TARGET) || defined(STBI__X64_TARGET))" + } + }, + { + "directive": "ifdef", + "argument": "_MSC_VER", + "source_location": { + "filename": "stb/stb_image.h", + "line": 728, + "column": 1, + "source_line": "#ifdef _MSC_VER" + } + }, + { + "directive": "if", + "argument": "_MSC_VER >= 1400", + "source_location": { + "filename": "stb/stb_image.h", + "line": 730, + "column": 1, + "source_line": "#if _MSC_VER >= 1400 // not VC6" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 738, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 749, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "!defined(STBI_NO_JPEG) && defined(STBI_SSE2)", + "source_location": { + "filename": "stb/stb_image.h", + "line": 753, + "column": 1, + "source_line": "#if !defined(STBI_NO_JPEG) && defined(STBI_SSE2)" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 759, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 761, + "column": 1, + "source_line": "#else // assume GCC-style if not VC++" + } + }, + { + "directive": "if", + "argument": "!defined(STBI_NO_JPEG) && defined(STBI_SSE2)", + "source_location": { + "filename": "stb/stb_image.h", + "line": 764, + "column": 1, + "source_line": "#if !defined(STBI_NO_JPEG) && defined(STBI_SSE2)" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 772, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 774, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 775, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "defined(STBI_NO_SIMD) && defined(STBI_NEON)", + "source_location": { + "filename": "stb/stb_image.h", + "line": 778, + "column": 1, + "source_line": "#if defined(STBI_NO_SIMD) && defined(STBI_NEON)" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 780, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBI_NEON", + "source_location": { + "filename": "stb/stb_image.h", + "line": 782, + "column": 1, + "source_line": "#ifdef STBI_NEON" + } + }, + { + "directive": "ifdef", + "argument": "_MSC_VER", + "source_location": { + "filename": "stb/stb_image.h", + "line": 784, + "column": 1, + "source_line": "#ifdef _MSC_VER" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 786, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 788, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 789, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_SIMD_ALIGN", + "source_location": { + "filename": "stb/stb_image.h", + "line": 791, + "column": 1, + "source_line": "#ifndef STBI_SIMD_ALIGN" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 793, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_MAX_DIMENSIONS", + "source_location": { + "filename": "stb/stb_image.h", + "line": 795, + "column": 1, + "source_line": "#ifndef STBI_MAX_DIMENSIONS" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 797, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_STDIO", + "source_location": { + "filename": "stb/stb_image.h", + "line": 848, + "column": 1, + "source_line": "#ifndef STBI_NO_STDIO" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 884, + "column": 1, + "source_line": "#endif // !STBI_NO_STDIO" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_JPEG", + "source_location": { + "filename": "stb/stb_image.h", + "line": 908, + "column": 1, + "source_line": "#ifndef STBI_NO_JPEG" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 912, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_PNG", + "source_location": { + "filename": "stb/stb_image.h", + "line": 914, + "column": 1, + "source_line": "#ifndef STBI_NO_PNG" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 919, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_BMP", + "source_location": { + "filename": "stb/stb_image.h", + "line": 921, + "column": 1, + "source_line": "#ifndef STBI_NO_BMP" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 925, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_TGA", + "source_location": { + "filename": "stb/stb_image.h", + "line": 927, + "column": 1, + "source_line": "#ifndef STBI_NO_TGA" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 931, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_PSD", + "source_location": { + "filename": "stb/stb_image.h", + "line": 933, + "column": 1, + "source_line": "#ifndef STBI_NO_PSD" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 938, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_HDR", + "source_location": { + "filename": "stb/stb_image.h", + "line": 940, + "column": 1, + "source_line": "#ifndef STBI_NO_HDR" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 944, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_PIC", + "source_location": { + "filename": "stb/stb_image.h", + "line": 946, + "column": 1, + "source_line": "#ifndef STBI_NO_PIC" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 950, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_GIF", + "source_location": { + "filename": "stb/stb_image.h", + "line": 952, + "column": 1, + "source_line": "#ifndef STBI_NO_GIF" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 957, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_PNM", + "source_location": { + "filename": "stb/stb_image.h", + "line": 959, + "column": 1, + "source_line": "#ifndef STBI_NO_PNM" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 964, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBI_THREAD_LOCAL", + "source_location": { + "filename": "stb/stb_image.h", + "line": 967, + "column": 1, + "source_line": "#ifdef STBI_THREAD_LOCAL" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 969, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_FAILURE_STRINGS", + "source_location": { + "filename": "stb/stb_image.h", + "line": 977, + "column": 1, + "source_line": "#ifndef STBI_NO_FAILURE_STRINGS" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 983, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "!defined(STBI_NO_JPEG) || !defined(STBI_NO_PNG) || !defined(STBI_NO_TGA) || !defined(STBI_NO_HDR)", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1022, + "column": 1, + "source_line": "#if !defined(STBI_NO_JPEG) || !defined(STBI_NO_PNG) || !defined(STBI_NO_TGA) || !defined(STBI_NO_HDR)" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1028, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "!defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) || !defined(STBI_NO_PNM)", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1038, + "column": 1, + "source_line": "#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) || !defined(STBI_NO_PNM)" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1044, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "!defined(STBI_NO_JPEG) || !defined(STBI_NO_PNG) || !defined(STBI_NO_TGA) || !defined(STBI_NO_HDR)", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1046, + "column": 1, + "source_line": "#if !defined(STBI_NO_JPEG) || !defined(STBI_NO_PNG) || !defined(STBI_NO_TGA) || !defined(STBI_NO_HDR)" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1053, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "!defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) || !defined(STBI_NO_PNM)", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1061, + "column": 1, + "source_line": "#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) || !defined(STBI_NO_PNM)" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1067, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBI_NO_FAILURE_STRINGS", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1090, + "column": 1, + "source_line": "#ifdef STBI_NO_FAILURE_STRINGS" + } + }, + { + "directive": "elif", + "argument": "defined(STBI_FAILURE_USERMSG)", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1092, + "column": 1, + "source_line": "#elif defined(STBI_FAILURE_USERMSG)" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1094, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1096, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_LINEAR", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1106, + "column": 1, + "source_line": "#ifndef STBI_NO_LINEAR" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1108, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_HDR", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1110, + "column": 1, + "source_line": "#ifndef STBI_NO_HDR" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1112, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_THREAD_LOCAL", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1121, + "column": 1, + "source_line": "#ifndef STBI_THREAD_LOCAL" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1123, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1135, + "column": 1, + "source_line": "#endif // STBI_THREAD_LOCAL" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_PNG", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1146, + "column": 4, + "source_line": " #ifndef STBI_NO_PNG" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1148, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_BMP", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1149, + "column": 4, + "source_line": " #ifndef STBI_NO_BMP" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1151, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_GIF", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1152, + "column": 4, + "source_line": " #ifndef STBI_NO_GIF" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1154, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_PSD", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1155, + "column": 4, + "source_line": " #ifndef STBI_NO_PSD" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1157, + "column": 4, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1159, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_PIC", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1160, + "column": 4, + "source_line": " #ifndef STBI_NO_PIC" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1162, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_JPEG", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1167, + "column": 4, + "source_line": " #ifndef STBI_NO_JPEG" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1169, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_PNM", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1170, + "column": 4, + "source_line": " #ifndef STBI_NO_PNM" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1172, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_HDR", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1174, + "column": 4, + "source_line": " #ifndef STBI_NO_HDR" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1179, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_TGA", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1181, + "column": 4, + "source_line": " #ifndef STBI_NO_TGA" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1185, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_GIF", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1246, + "column": 1, + "source_line": "#ifndef STBI_NO_GIF" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1258, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "!defined(STBI_NO_HDR) && !defined(STBI_NO_LINEAR)", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1313, + "column": 1, + "source_line": "#if !defined(STBI_NO_HDR) && !defined(STBI_NO_LINEAR)" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1321, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_STDIO", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1323, + "column": 1, + "source_line": "#ifndef STBI_NO_STDIO" + } + }, + { + "directive": "if", + "argument": "defined(_WIN32) && defined(STBI_WINDOWS_UTF8)", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1325, + "column": 1, + "source_line": "#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8)" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1328, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "defined(_WIN32) && defined(STBI_WINDOWS_UTF8)", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1330, + "column": 1, + "source_line": "#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8)" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1335, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "defined(_WIN32) && defined(STBI_WINDOWS_UTF8)", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1340, + "column": 1, + "source_line": "#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8)" + } + }, + { + "directive": "if", + "argument": "defined(_MSC_VER) && _MSC_VER >= 1400", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1349, + "column": 1, + "source_line": "#if defined(_MSC_VER) && _MSC_VER >= 1400" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1352, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1354, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "elif", + "argument": "defined(_MSC_VER) && _MSC_VER >= 1400", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1356, + "column": 1, + "source_line": "#elif defined(_MSC_VER) && _MSC_VER >= 1400" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1359, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1361, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1413, + "column": 1, + "source_line": "#endif //!STBI_NO_STDIO" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_GIF", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1443, + "column": 1, + "source_line": "#ifndef STBI_NO_GIF" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1457, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_LINEAR", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1459, + "column": 1, + "source_line": "#ifndef STBI_NO_LINEAR" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_HDR", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1463, + "column": 4, + "source_line": " #ifndef STBI_NO_HDR" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1471, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_STDIO", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1492, + "column": 1, + "source_line": "#ifndef STBI_NO_STDIO" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1509, + "column": 1, + "source_line": "#endif // !STBI_NO_STDIO" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1511, + "column": 1, + "source_line": "#endif // !STBI_NO_LINEAR" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_HDR", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1519, + "column": 4, + "source_line": " #ifndef STBI_NO_HDR" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1523, + "column": 4, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1527, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_STDIO", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1530, + "column": 1, + "source_line": "#ifndef STBI_NO_STDIO" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_HDR", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1544, + "column": 4, + "source_line": " #ifndef STBI_NO_HDR" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1552, + "column": 4, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1555, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1557, + "column": 1, + "source_line": "#endif // !STBI_NO_STDIO" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_HDR", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1561, + "column": 4, + "source_line": " #ifndef STBI_NO_HDR" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1565, + "column": 4, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1569, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_LINEAR", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1572, + "column": 1, + "source_line": "#ifndef STBI_NO_LINEAR" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1577, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "defined(STBI_NO_JPEG) && defined(STBI_NO_HDR) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM)", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1625, + "column": 1, + "source_line": "#if defined(STBI_NO_JPEG) && defined(STBI_NO_HDR) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM)" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1627, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1639, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC)", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1641, + "column": 1, + "source_line": "#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC)" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1643, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1661, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "defined(STBI_NO_PNG) && defined(STBI_NO_TGA) && defined(STBI_NO_HDR) && defined(STBI_NO_PNM)", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1663, + "column": 1, + "source_line": "#if defined(STBI_NO_PNG) && defined(STBI_NO_TGA) && defined(STBI_NO_HDR) && defined(STBI_NO_PNM)" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1665, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1689, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_PSD) && defined(STBI_NO_PIC)", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1691, + "column": 1, + "source_line": "#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_PSD) && defined(STBI_NO_PIC)" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1693, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1699, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "defined(STBI_NO_PNG) && defined(STBI_NO_PSD) && defined(STBI_NO_PIC)", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1701, + "column": 1, + "source_line": "#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD) && defined(STBI_NO_PIC)" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1703, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1709, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "defined(STBI_NO_BMP) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF)", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1711, + "column": 1, + "source_line": "#if defined(STBI_NO_BMP) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF)" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1713, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1719, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_BMP", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1721, + "column": 1, + "source_line": "#ifndef STBI_NO_BMP" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1728, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM)", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1732, + "column": 1, + "source_line": "#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM)" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1734, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1750, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM)", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1752, + "column": 1, + "source_line": "#if defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM)" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1754, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1798, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "defined(STBI_NO_PNG) && defined(STBI_NO_PSD)", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1800, + "column": 1, + "source_line": "#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD)" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1802, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1807, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "defined(STBI_NO_PNG) && defined(STBI_NO_PSD)", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1809, + "column": 1, + "source_line": "#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD)" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1811, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1855, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_LINEAR", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1857, + "column": 1, + "source_line": "#ifndef STBI_NO_LINEAR" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1880, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_HDR", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1882, + "column": 1, + "source_line": "#ifndef STBI_NO_HDR" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1910, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_JPEG", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1933, + "column": 1, + "source_line": "#ifndef STBI_NO_JPEG" + } + }, + { + "directive": "ifdef", + "argument": "STBI_SSE2", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2526, + "column": 1, + "source_line": "#ifdef STBI_SSE2" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 2705, + "column": 1, + "source_line": "#endif // STBI_SSE2" + } + }, + { + "directive": "ifdef", + "argument": "STBI_NEON", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2707, + "column": 1, + "source_line": "#ifdef STBI_NEON" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 2913, + "column": 1, + "source_line": "#endif // STBI_NEON" + } + }, + { + "directive": "if", + "argument": "defined(STBI_SSE2) || defined(STBI_NEON)", + "source_location": { + "filename": "stb/stb_image.h", + "line": 3529, + "column": 1, + "source_line": "#if defined(STBI_SSE2) || defined(STBI_NEON)" + } + }, + { + "directive": "if", + "argument": "defined(STBI_SSE2)", + "source_location": { + "filename": "stb/stb_image.h", + "line": 3545, + "column": 1, + "source_line": "#if defined(STBI_SSE2)" + } + }, + { + "directive": "elif", + "argument": "defined(STBI_NEON)", + "source_location": { + "filename": "stb/stb_image.h", + "line": 3588, + "column": 1, + "source_line": "#elif defined(STBI_NEON)" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 3622, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 3644, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "defined(STBI_SSE2) || defined(STBI_NEON)", + "source_location": { + "filename": "stb/stb_image.h", + "line": 3685, + "column": 1, + "source_line": "#if defined(STBI_SSE2) || defined(STBI_NEON)" + } + }, + { + "directive": "ifdef", + "argument": "STBI_SSE2", + "source_location": { + "filename": "stb/stb_image.h", + "line": 3690, + "column": 1, + "source_line": "#ifdef STBI_SSE2" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 3749, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBI_NEON", + "source_location": { + "filename": "stb/stb_image.h", + "line": 3751, + "column": 1, + "source_line": "#ifdef STBI_NEON" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 3795, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 3818, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBI_SSE2", + "source_location": { + "filename": "stb/stb_image.h", + "line": 3827, + "column": 1, + "source_line": "#ifdef STBI_SSE2" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 3833, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBI_NEON", + "source_location": { + "filename": "stb/stb_image.h", + "line": 3835, + "column": 1, + "source_line": "#ifdef STBI_NEON" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 3839, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 4079, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_ZLIB", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4088, + "column": 1, + "source_line": "#ifndef STBI_NO_ZLIB" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 4594, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_PNG", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4606, + "column": 1, + "source_line": "#ifndef STBI_NO_PNG" + } + }, + { + "directive": "ifndef", + "argument": "STBI_THREAD_LOCAL", + "source_location": { + "filename": "stb/stb_image.h", + "line": 5006, + "column": 1, + "source_line": "#ifndef STBI_THREAD_LOCAL" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 5009, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 5031, + "column": 1, + "source_line": "#endif // STBI_THREAD_LOCAL" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_FAILURE_STRINGS", + "source_location": { + "filename": "stb/stb_image.h", + "line": 5245, + "column": 16, + "source_line": " #ifndef STBI_NO_FAILURE_STRINGS" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 5252, + "column": 16, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 5341, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_BMP", + "source_location": { + "filename": "stb/stb_image.h", + "line": 5345, + "column": 1, + "source_line": "#ifndef STBI_NO_BMP" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 5733, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_TGA", + "source_location": { + "filename": "stb/stb_image.h", + "line": 5737, + "column": 1, + "source_line": "#ifndef STBI_NO_TGA" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 6075, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_PSD", + "source_location": { + "filename": "stb/stb_image.h", + "line": 6080, + "column": 1, + "source_line": "#ifndef STBI_NO_PSD" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 6326, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_PIC", + "source_location": { + "filename": "stb/stb_image.h", + "line": 6335, + "column": 1, + "source_line": "#ifndef STBI_NO_PIC" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 6547, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_GIF", + "source_location": { + "filename": "stb/stb_image.h", + "line": 6552, + "column": 1, + "source_line": "#ifndef STBI_NO_GIF" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 7081, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_HDR", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7086, + "column": 1, + "source_line": "#ifndef STBI_NO_HDR" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 7332, + "column": 1, + "source_line": "#endif // STBI_NO_HDR" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_BMP", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7334, + "column": 1, + "source_line": "#ifndef STBI_NO_BMP" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 7356, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_PSD", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7358, + "column": 1, + "source_line": "#ifndef STBI_NO_PSD" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 7420, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_PIC", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7422, + "column": 1, + "source_line": "#ifndef STBI_NO_PIC" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 7479, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_PNM", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7492, + "column": 1, + "source_line": "#ifndef STBI_NO_PNM" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 7630, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_JPEG", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7634, + "column": 4, + "source_line": " #ifndef STBI_NO_JPEG" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 7636, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_PNG", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7638, + "column": 4, + "source_line": " #ifndef STBI_NO_PNG" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 7640, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_GIF", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7642, + "column": 4, + "source_line": " #ifndef STBI_NO_GIF" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 7644, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_BMP", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7646, + "column": 4, + "source_line": " #ifndef STBI_NO_BMP" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 7648, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_PSD", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7650, + "column": 4, + "source_line": " #ifndef STBI_NO_PSD" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 7652, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_PIC", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7654, + "column": 4, + "source_line": " #ifndef STBI_NO_PIC" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 7656, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_PNM", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7658, + "column": 4, + "source_line": " #ifndef STBI_NO_PNM" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 7660, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_HDR", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7662, + "column": 4, + "source_line": " #ifndef STBI_NO_HDR" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 7664, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_TGA", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7667, + "column": 4, + "source_line": " #ifndef STBI_NO_TGA" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 7670, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_PNG", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7676, + "column": 4, + "source_line": " #ifndef STBI_NO_PNG" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 7678, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_PSD", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7680, + "column": 4, + "source_line": " #ifndef STBI_NO_PSD" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 7682, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_PNM", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7684, + "column": 4, + "source_line": " #ifndef STBI_NO_PNM" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 7686, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_NO_STDIO", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7690, + "column": 1, + "source_line": "#ifndef STBI_NO_STDIO" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 7732, + "column": 1, + "source_line": "#endif // !STBI_NO_STDIO" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 7762, + "column": 1, + "source_line": "#endif // STB_IMAGE_IMPLEMENTATION" + } + } + ], + "macro_dependencies": [ + { + "name": "STBI_THREAD_LOCAL", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image.h", + "line": 966, + "column": 1, + "source_line": "static" + }, + "source_text": "static\n \nSTBI_THREAD_LOCAL\n \nconst char *stbi__g_failure_reason" + }, + { + "name": "STBIDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image.h", + "line": 972, + "column": 1, + "source_line": "STBIDEF const char *stbi_failure_reason(void)" + }, + "source_text": "STBIDEF const char *stbi_failure_reason(void)" + }, + { + "name": "stbi__err", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image.h", + "line": 978, + "column": 1, + "source_line": "static int stbi__err(const char *str)" + }, + "source_text": "static int stbi__err(const char *str)" + }, + { + "name": "STBIDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1101, + "column": 1, + "source_line": "STBIDEF void stbi_image_free(void *retval_from_stbi_load)" + }, + "source_text": "STBIDEF void stbi_image_free(void *retval_from_stbi_load)" + }, + { + "name": "STBIDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1116, + "column": 1, + "source_line": "STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip)" + }, + "source_text": "STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip)" + }, + { + "name": "STBI_THREAD_LOCAL", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1124, + "column": 1, + "source_line": "static STBI_THREAD_LOCAL int stbi__vertically_flip_on_load_local, stbi__vertically_flip_on_load_set;" + }, + "source_text": "static STBI_THREAD_LOCAL int stbi__vertically_flip_on_load_local, stbi__vertically_flip_on_load_set" + }, + { + "name": "STBIDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1126, + "column": 1, + "source_line": "STBIDEF void stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_flip)" + }, + "source_text": "STBIDEF void stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_flip)" + }, + { + "name": "STBI_EXTERN", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1326, + "column": 1, + "source_line": "STBI_EXTERN __declspec(dllimport) int __stdcall MultiByteToWideChar(unsigned int cp, unsigned long flags, const char *str, int cbmb, wchar_t *widestr, int cchwide);" + }, + "source_text": "STBI_EXTERN __declspec(dllimport) int __stdcall MultiByteToWideChar(unsigned int cp, unsigned long flags, const char *str, int cbmb, wchar_t *widestr, int cchwide)" + }, + { + "name": "STBI_EXTERN", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1327, + "column": 1, + "source_line": "STBI_EXTERN __declspec(dllimport) int __stdcall WideCharToMultiByte(unsigned int cp, unsigned long flags, const wchar_t *widestr, int cchwide, char *str, int cbmb, const char *defchar, int *used_default);" + }, + "source_text": "STBI_EXTERN __declspec(dllimport) int __stdcall WideCharToMultiByte(unsigned int cp, unsigned long flags, const wchar_t *widestr, int cchwide, char *str, int cbmb, const char *defchar, int *used_default)" + }, + { + "name": "STBIDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1331, + "column": 1, + "source_line": "STBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input)" + }, + "source_text": "STBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input)" + }, + { + "name": "STBIDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1366, + "column": 1, + "source_line": "STBIDEF stbi_uc *stbi_load(char const *filename, int *x, int *y, int *comp, int req_comp)" + }, + "source_text": "STBIDEF stbi_uc *stbi_load(char const *filename, int *x, int *y, int *comp, int req_comp)" + }, + { + "name": "STBIDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1376, + "column": 1, + "source_line": "STBIDEF stbi_uc *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)" + }, + "source_text": "STBIDEF stbi_uc *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)" + }, + { + "name": "STBIDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1389, + "column": 1, + "source_line": "STBIDEF stbi__uint16 *stbi_load_from_file_16(FILE *f, int *x, int *y, int *comp, int req_comp)" + }, + "source_text": "STBIDEF stbi__uint16 *stbi_load_from_file_16(FILE *f, int *x, int *y, int *comp, int req_comp)" + }, + { + "name": "STBIDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1402, + "column": 1, + "source_line": "STBIDEF stbi_us *stbi_load_16(char const *filename, int *x, int *y, int *comp, int req_comp)" + }, + "source_text": "STBIDEF stbi_us *stbi_load_16(char const *filename, int *x, int *y, int *comp, int req_comp)" + }, + { + "name": "STBIDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1415, + "column": 1, + "source_line": "STBIDEF stbi_us *stbi_load_16_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels)" + }, + "source_text": "STBIDEF stbi_us *stbi_load_16_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels)" + }, + { + "name": "STBIDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1422, + "column": 1, + "source_line": "STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels)" + }, + "source_text": "STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels)" + }, + { + "name": "STBIDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1429, + "column": 1, + "source_line": "STBIDEF stbi_uc *stbi_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp)" + }, + "source_text": "STBIDEF stbi_uc *stbi_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp)" + }, + { + "name": "STBIDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1436, + "column": 1, + "source_line": "STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp)" + }, + "source_text": "STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp)" + }, + { + "name": "STBIDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1444, + "column": 1, + "source_line": "STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp)" + }, + "source_text": "STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp)" + }, + { + "name": "STBIDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1478, + "column": 1, + "source_line": "STBIDEF float *stbi_loadf_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp)" + }, + "source_text": "STBIDEF float *stbi_loadf_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp)" + }, + { + "name": "STBIDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1485, + "column": 1, + "source_line": "STBIDEF float *stbi_loadf_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp)" + }, + "source_text": "STBIDEF float *stbi_loadf_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp)" + }, + { + "name": "STBIDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1493, + "column": 1, + "source_line": "STBIDEF float *stbi_loadf(char const *filename, int *x, int *y, int *comp, int req_comp)" + }, + "source_text": "STBIDEF float *stbi_loadf(char const *filename, int *x, int *y, int *comp, int req_comp)" + }, + { + "name": "STBIDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1503, + "column": 1, + "source_line": "STBIDEF float *stbi_loadf_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)" + }, + "source_text": "STBIDEF float *stbi_loadf_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)" + }, + { + "name": "STBIDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1517, + "column": 1, + "source_line": "STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len)" + }, + "source_text": "STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len)" + }, + { + "name": "STBIDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1531, + "column": 1, + "source_line": "STBIDEF int stbi_is_hdr (char const *filename)" + }, + "source_text": "STBIDEF int stbi_is_hdr (char const *filename)" + }, + { + "name": "STBIDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1542, + "column": 1, + "source_line": "STBIDEF int stbi_is_hdr_from_file(FILE *f)" + }, + "source_text": "STBIDEF int stbi_is_hdr_from_file(FILE *f)" + }, + { + "name": "STBIDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1559, + "column": 1, + "source_line": "STBIDEF int stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user)" + }, + "source_text": "STBIDEF int stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user)" + }, + { + "name": "STBIDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1575, + "column": 1, + "source_line": "STBIDEF void stbi_ldr_to_hdr_gamma(float gamma) { stbi__l2h_gamma = gamma; }" + }, + "source_text": "STBIDEF void stbi_ldr_to_hdr_gamma(float gamma)" + }, + { + "name": "STBIDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1576, + "column": 1, + "source_line": "STBIDEF void stbi_ldr_to_hdr_scale(float scale) { stbi__l2h_scale = scale; }" + }, + "source_text": "STBIDEF void stbi_ldr_to_hdr_scale(float scale)" + }, + { + "name": "STBIDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1581, + "column": 1, + "source_line": "STBIDEF void stbi_hdr_to_ldr_gamma(float gamma) { stbi__h2l_gamma_i = 1/gamma; }" + }, + "source_text": "STBIDEF void stbi_hdr_to_ldr_gamma(float gamma)" + }, + { + "name": "STBIDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1582, + "column": 1, + "source_line": "STBIDEF void stbi_hdr_to_ldr_scale(float scale) { stbi__h2l_scale_i = 1/scale; }" + }, + "source_text": "STBIDEF void stbi_hdr_to_ldr_scale(float scale)" + }, + { + "name": "stbi_inline", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1614, + "column": 1, + "source_line": "stbi_inline static stbi_uc stbi__get8(stbi__context *s)" + }, + "source_text": "stbi_inline static stbi_uc stbi__get8(stbi__context *s)" + }, + { + "name": "stbi_inline", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1628, + "column": 1, + "source_line": "stbi_inline static int stbi__at_eof(stbi__context *s)" + }, + "source_text": "stbi_inline static int stbi__at_eof(stbi__context *s)" + }, + { + "name": "stbi_inline", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2097, + "column": 1, + "source_line": "stbi_inline static int stbi__jpeg_huff_decode(stbi__jpeg *j, stbi__huffman *h)" + }, + "source_text": "stbi_inline static int stbi__jpeg_huff_decode(stbi__jpeg *j, stbi__huffman *h)" + }, + { + "name": "stbi_inline", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2153, + "column": 1, + "source_line": "stbi_inline static int stbi__extend_receive(stbi__jpeg *j, int n)" + }, + "source_text": "stbi_inline static int stbi__extend_receive(stbi__jpeg *j, int n)" + }, + { + "name": "stbi_inline", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2169, + "column": 1, + "source_line": "stbi_inline static int stbi__jpeg_get_bits(stbi__jpeg *j, int n)" + }, + "source_text": "stbi_inline static int stbi__jpeg_get_bits(stbi__jpeg *j, int n)" + }, + { + "name": "stbi_inline", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2181, + "column": 1, + "source_line": "stbi_inline static int stbi__jpeg_get_bit(stbi__jpeg *j)" + }, + "source_text": "stbi_inline static int stbi__jpeg_get_bit(stbi__jpeg *j)" + }, + { + "name": "stbi_inline", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2416, + "column": 1, + "source_line": "stbi_inline static stbi_uc stbi__clamp(int x)" + }, + "source_text": "stbi_inline static stbi_uc stbi__clamp(int x)" + }, + { + "name": "stbi_inline", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4107, + "column": 1, + "source_line": "stbi_inline static int stbi__bitreverse16(int n)" + }, + "source_text": "stbi_inline static int stbi__bitreverse16(int n)" + }, + { + "name": "stbi_inline", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4116, + "column": 1, + "source_line": "stbi_inline static int stbi__bit_reverse(int v, int bits)" + }, + "source_text": "stbi_inline static int stbi__bit_reverse(int v, int bits)" + }, + { + "name": "stbi_inline", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4192, + "column": 1, + "source_line": "stbi_inline static int stbi__zeof(stbi__zbuf *z)" + }, + "source_text": "stbi_inline static int stbi__zeof(stbi__zbuf *z)" + }, + { + "name": "stbi_inline", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4197, + "column": 1, + "source_line": "stbi_inline static stbi_uc stbi__zget8(stbi__zbuf *z)" + }, + "source_text": "stbi_inline static stbi_uc stbi__zget8(stbi__zbuf *z)" + }, + { + "name": "stbi_inline", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4214, + "column": 1, + "source_line": "stbi_inline static unsigned int stbi__zreceive(stbi__zbuf *z, int n)" + }, + "source_text": "stbi_inline static unsigned int stbi__zreceive(stbi__zbuf *z, int n)" + }, + { + "name": "stbi_inline", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4243, + "column": 1, + "source_line": "stbi_inline static int stbi__zhuffman_decode(stbi__zbuf *a, stbi__zhuffman *z)" + }, + "source_text": "stbi_inline static int stbi__zhuffman_decode(stbi__zbuf *a, stbi__zhuffman *z)" + }, + { + "name": "STBIDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4520, + "column": 1, + "source_line": "STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen)" + }, + "source_text": "STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen)" + }, + { + "name": "STBIDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4536, + "column": 1, + "source_line": "STBIDEF char *stbi_zlib_decode_malloc(char const *buffer, int len, int *outlen)" + }, + "source_text": "STBIDEF char *stbi_zlib_decode_malloc(char const *buffer, int len, int *outlen)" + }, + { + "name": "STBIDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4541, + "column": 1, + "source_line": "STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header)" + }, + "source_text": "STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header)" + }, + { + "name": "STBIDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4557, + "column": 1, + "source_line": "STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, char const *ibuffer, int ilen)" + }, + "source_text": "STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, char const *ibuffer, int ilen)" + }, + { + "name": "STBIDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4568, + "column": 1, + "source_line": "STBIDEF char *stbi_zlib_decode_noheader_malloc(char const *buffer, int len, int *outlen)" + }, + "source_text": "STBIDEF char *stbi_zlib_decode_noheader_malloc(char const *buffer, int len, int *outlen)" + }, + { + "name": "STBIDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4584, + "column": 1, + "source_line": "STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen)" + }, + "source_text": "STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen)" + }, + { + "name": "STBIDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4996, + "column": 1, + "source_line": "STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply)" + }, + "source_text": "STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply)" + }, + { + "name": "STBIDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image.h", + "line": 5001, + "column": 1, + "source_line": "STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert)" + }, + "source_text": "STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert)" + }, + { + "name": "STBI_THREAD_LOCAL", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image.h", + "line": 5010, + "column": 1, + "source_line": "static STBI_THREAD_LOCAL int stbi__unpremultiply_on_load_local, stbi__unpremultiply_on_load_set;" + }, + "source_text": "static STBI_THREAD_LOCAL int stbi__unpremultiply_on_load_local, stbi__unpremultiply_on_load_set" + }, + { + "name": "STBI_THREAD_LOCAL", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image.h", + "line": 5011, + "column": 1, + "source_line": "static STBI_THREAD_LOCAL int stbi__de_iphone_flag_local, stbi__de_iphone_flag_set;" + }, + "source_text": "static STBI_THREAD_LOCAL int stbi__de_iphone_flag_local, stbi__de_iphone_flag_set" + }, + { + "name": "STBIDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image.h", + "line": 5013, + "column": 1, + "source_line": "STBIDEF void stbi_set_unpremultiply_on_load_thread(int flag_true_if_should_unpremultiply)" + }, + "source_text": "STBIDEF void stbi_set_unpremultiply_on_load_thread(int flag_true_if_should_unpremultiply)" + }, + { + "name": "STBIDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image.h", + "line": 5019, + "column": 1, + "source_line": "STBIDEF void stbi_convert_iphone_png_to_rgb_thread(int flag_true_if_should_convert)" + }, + "source_text": "STBIDEF void stbi_convert_iphone_png_to_rgb_thread(int flag_true_if_should_convert)" + }, + { + "name": "STBIDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7691, + "column": 1, + "source_line": "STBIDEF int stbi_info(char const *filename, int *x, int *y, int *comp)" + }, + "source_text": "STBIDEF int stbi_info(char const *filename, int *x, int *y, int *comp)" + }, + { + "name": "STBIDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7701, + "column": 1, + "source_line": "STBIDEF int stbi_info_from_file(FILE *f, int *x, int *y, int *comp)" + }, + "source_text": "STBIDEF int stbi_info_from_file(FILE *f, int *x, int *y, int *comp)" + }, + { + "name": "STBIDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7712, + "column": 1, + "source_line": "STBIDEF int stbi_is_16_bit(char const *filename)" + }, + "source_text": "STBIDEF int stbi_is_16_bit(char const *filename)" + }, + { + "name": "STBIDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7722, + "column": 1, + "source_line": "STBIDEF int stbi_is_16_bit_from_file(FILE *f)" + }, + "source_text": "STBIDEF int stbi_is_16_bit_from_file(FILE *f)" + }, + { + "name": "STBIDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7734, + "column": 1, + "source_line": "STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp)" + }, + "source_text": "STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp)" + }, + { + "name": "STBIDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7741, + "column": 1, + "source_line": "STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *c, void *user, int *x, int *y, int *comp)" + }, + "source_text": "STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *c, void *user, int *x, int *y, int *comp)" + }, + { + "name": "STBIDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7748, + "column": 1, + "source_line": "STBIDEF int stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len)" + }, + "source_text": "STBIDEF int stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len)" + }, + { + "name": "STBIDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7755, + "column": 1, + "source_line": "STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *c, void *user)" + }, + "source_text": "STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *c, void *user)" + } + ], + "diagnostics": [ + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBI_ASSERT' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 603, + "column": 1, + "source_line": "#define STBI_ASSERT(x) assert(x)" + }, + "unit_kind": "macro", + "unit_name": "STBI_ASSERT" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBI_NOTUSED' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 658, + "column": 1, + "source_line": "#define STBI_NOTUSED(v) (void)(v)" + }, + "unit_kind": "macro", + "unit_name": "STBI_NOTUSED" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBI_NOTUSED' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 660, + "column": 1, + "source_line": "#define STBI_NOTUSED(v) (void)sizeof(v)" + }, + "unit_kind": "macro", + "unit_name": "STBI_NOTUSED" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbi_lrot' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 668, + "column": 4, + "source_line": " #define stbi_lrot(x,y) _lrotl(x,y)" + }, + "unit_kind": "macro", + "unit_name": "stbi_lrot" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbi_lrot' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 670, + "column": 4, + "source_line": " #define stbi_lrot(x,y) (((x) << (y)) | ((x) >> (-(y) & 31)))" + }, + "unit_kind": "macro", + "unit_name": "stbi_lrot" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBI_MALLOC' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 682, + "column": 1, + "source_line": "#define STBI_MALLOC(sz) malloc(sz)" + }, + "unit_kind": "macro", + "unit_name": "STBI_MALLOC" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBI_REALLOC' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 683, + "column": 1, + "source_line": "#define STBI_REALLOC(p,newsz) realloc(p,newsz)" + }, + "unit_kind": "macro", + "unit_name": "STBI_REALLOC" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBI_FREE' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 684, + "column": 1, + "source_line": "#define STBI_FREE(p) free(p)" + }, + "unit_kind": "macro", + "unit_name": "STBI_FREE" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBI_REALLOC_SIZED' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 688, + "column": 1, + "source_line": "#define STBI_REALLOC_SIZED(p,oldsz,newsz) STBI_REALLOC(p,newsz)" + }, + "unit_kind": "macro", + "unit_name": "STBI_REALLOC_SIZED" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBI_SIMD_ALIGN' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 751, + "column": 1, + "source_line": "#define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name" + }, + "unit_kind": "macro", + "unit_name": "STBI_SIMD_ALIGN" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBI_SIMD_ALIGN' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 762, + "column": 1, + "source_line": "#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16)))" + }, + "unit_kind": "macro", + "unit_name": "STBI_SIMD_ALIGN" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBI_SIMD_ALIGN' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 785, + "column": 1, + "source_line": "#define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name" + }, + "unit_kind": "macro", + "unit_name": "STBI_SIMD_ALIGN" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBI_SIMD_ALIGN' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 787, + "column": 1, + "source_line": "#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16)))" + }, + "unit_kind": "macro", + "unit_name": "STBI_SIMD_ALIGN" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBI_SIMD_ALIGN' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 792, + "column": 1, + "source_line": "#define STBI_SIMD_ALIGN(type, name) type name" + }, + "unit_kind": "macro", + "unit_name": "STBI_SIMD_ALIGN" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbi__err' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1091, + "column": 4, + "source_line": " #define stbi__err(x,y) 0" + }, + "unit_kind": "macro", + "unit_name": "stbi__err" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbi__err' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1093, + "column": 4, + "source_line": " #define stbi__err(x,y) stbi__err(y)" + }, + "unit_kind": "macro", + "unit_name": "stbi__err" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbi__err' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1095, + "column": 4, + "source_line": " #define stbi__err(x,y) stbi__err(x)" + }, + "unit_kind": "macro", + "unit_name": "stbi__err" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbi__errpf' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1098, + "column": 1, + "source_line": "#define stbi__errpf(x,y) ((float *)(size_t) (stbi__err(x,y)?NULL:NULL))" + }, + "unit_kind": "macro", + "unit_name": "stbi__errpf" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbi__errpuc' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1099, + "column": 1, + "source_line": "#define stbi__errpuc(x,y) ((unsigned char *)(size_t) (stbi__err(x,y)?NULL:NULL))" + }, + "unit_kind": "macro", + "unit_name": "stbi__errpuc" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBI__BYTECAST' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1730, + "column": 1, + "source_line": "#define STBI__BYTECAST(x) ((stbi_uc) ((x) & 255)) // truncate int to byte without warnings" + }, + "unit_kind": "macro", + "unit_name": "STBI__BYTECAST" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBI__COMBO' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1773, + "column": 7, + "source_line": " #define STBI__COMBO(a,b) ((a)*8+(b))" + }, + "unit_kind": "macro", + "unit_name": "STBI__COMBO" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBI__CASE' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1774, + "column": 7, + "source_line": " #define STBI__CASE(a,b) case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b)" + }, + "unit_kind": "macro", + "unit_name": "STBI__CASE" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBI__COMBO' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1830, + "column": 7, + "source_line": " #define STBI__COMBO(a,b) ((a)*8+(b))" + }, + "unit_kind": "macro", + "unit_name": "STBI__COMBO" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBI__CASE' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1831, + "column": 7, + "source_line": " #define STBI__CASE(a,b) case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b)" + }, + "unit_kind": "macro", + "unit_name": "STBI__CASE" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbi__float2int' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1883, + "column": 1, + "source_line": "#define stbi__float2int(x) ((int) (x))" + }, + "unit_kind": "macro", + "unit_name": "stbi__float2int" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbi__f2f' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 2426, + "column": 1, + "source_line": "#define stbi__f2f(x) ((int) (((x) * 4096 + 0.5)))" + }, + "unit_kind": "macro", + "unit_name": "stbi__f2f" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbi__fsh' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 2427, + "column": 1, + "source_line": "#define stbi__fsh(x) ((x) * 4096)" + }, + "unit_kind": "macro", + "unit_name": "stbi__fsh" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBI__IDCT_1D' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 2430, + "column": 1, + "source_line": "#define STBI__IDCT_1D(s0,s1,s2,s3,s4,s5,s6,s7) \\" + }, + "unit_kind": "macro", + "unit_name": "STBI__IDCT_1D" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'dct_const' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 2537, + "column": 4, + "source_line": " #define dct_const(x,y) _mm_setr_epi16((x),(y),(x),(y),(x),(y),(x),(y))" + }, + "unit_kind": "macro", + "unit_name": "dct_const" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'dct_rot' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 2541, + "column": 4, + "source_line": " #define dct_rot(out0,out1, x,y,c0,c1) \\" + }, + "unit_kind": "macro", + "unit_name": "dct_rot" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'dct_widen' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 2550, + "column": 4, + "source_line": " #define dct_widen(out, in) \\" + }, + "unit_kind": "macro", + "unit_name": "dct_widen" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'dct_wadd' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 2555, + "column": 4, + "source_line": " #define dct_wadd(out, a, b) \\" + }, + "unit_kind": "macro", + "unit_name": "dct_wadd" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'dct_wsub' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 2560, + "column": 4, + "source_line": " #define dct_wsub(out, a, b) \\" + }, + "unit_kind": "macro", + "unit_name": "dct_wsub" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'dct_bfly32o' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 2565, + "column": 4, + "source_line": " #define dct_bfly32o(out0, out1, a,b,bias,s) \\" + }, + "unit_kind": "macro", + "unit_name": "dct_bfly32o" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'dct_interleave8' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 2576, + "column": 4, + "source_line": " #define dct_interleave8(a, b) \\" + }, + "unit_kind": "macro", + "unit_name": "dct_interleave8" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'dct_interleave16' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 2582, + "column": 4, + "source_line": " #define dct_interleave16(a, b) \\" + }, + "unit_kind": "macro", + "unit_name": "dct_interleave16" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'dct_pass' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 2587, + "column": 4, + "source_line": " #define dct_pass(bias,shift) \\" + }, + "unit_kind": "macro", + "unit_name": "dct_pass" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'dct_long_mul' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 2728, + "column": 1, + "source_line": "#define dct_long_mul(out, inq, coeff) \\" + }, + "unit_kind": "macro", + "unit_name": "dct_long_mul" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'dct_long_mac' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 2732, + "column": 1, + "source_line": "#define dct_long_mac(out, acc, inq, coeff) \\" + }, + "unit_kind": "macro", + "unit_name": "dct_long_mac" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'dct_widen' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 2736, + "column": 1, + "source_line": "#define dct_widen(out, inq) \\" + }, + "unit_kind": "macro", + "unit_name": "dct_widen" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'dct_wadd' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 2741, + "column": 1, + "source_line": "#define dct_wadd(out, a, b) \\" + }, + "unit_kind": "macro", + "unit_name": "dct_wadd" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'dct_wsub' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 2746, + "column": 1, + "source_line": "#define dct_wsub(out, a, b) \\" + }, + "unit_kind": "macro", + "unit_name": "dct_wsub" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'dct_bfly32o' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 2751, + "column": 1, + "source_line": "#define dct_bfly32o(out0,out1, a,b,shiftop,s) \\" + }, + "unit_kind": "macro", + "unit_name": "dct_bfly32o" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'dct_pass' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 2759, + "column": 1, + "source_line": "#define dct_pass(shiftop, shift) \\" + }, + "unit_kind": "macro", + "unit_name": "dct_pass" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'dct_trn16' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 2819, + "column": 1, + "source_line": "#define dct_trn16(x, y) { int16x8x2_t t = vtrnq_s16(x, y); x = t.val[0]; y = t.val[1]; }" + }, + "unit_kind": "macro", + "unit_name": "dct_trn16" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'dct_trn32' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 2820, + "column": 1, + "source_line": "#define dct_trn32(x, y) { int32x4x2_t t = vtrnq_s32(vreinterpretq_s32_s16(x), vreinterpretq_s32_s16(y)); x = vreinterpretq_s16_s32(t.val[0]); y = vreinterpretq_s16_s32(t.val[1]); }" + }, + "unit_kind": "macro", + "unit_name": "dct_trn32" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'dct_trn64' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 2821, + "column": 1, + "source_line": "#define dct_trn64(x, y) { int16x8_t x0 = x; int16x8_t y0 = y; x = vcombine_s16(vget_low_s16(x0), vget_low_s16(y0)); y = vcombine_s16(vget_high_s16(x0), vget_high_s16(y0)); }" + }, + "unit_kind": "macro", + "unit_name": "dct_trn64" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'dct_trn8_8' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 2864, + "column": 1, + "source_line": "#define dct_trn8_8(x, y) { uint8x8x2_t t = vtrn_u8(x, y); x = t.val[0]; y = t.val[1]; }" + }, + "unit_kind": "macro", + "unit_name": "dct_trn8_8" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'dct_trn8_16' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 2865, + "column": 1, + "source_line": "#define dct_trn8_16(x, y) { uint16x4x2_t t = vtrn_u16(vreinterpret_u16_u8(x), vreinterpret_u16_u8(y)); x = vreinterpret_u8_u16(t.val[0]); y = vreinterpret_u8_u16(t.val[1]); }" + }, + "unit_kind": "macro", + "unit_name": "dct_trn8_16" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'dct_trn8_32' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 2866, + "column": 1, + "source_line": "#define dct_trn8_32(x, y) { uint32x2x2_t t = vtrn_u32(vreinterpret_u32_u8(x), vreinterpret_u32_u8(y)); x = vreinterpret_u8_u32(t.val[0]); y = vreinterpret_u8_u32(t.val[1]); }" + }, + "unit_kind": "macro", + "unit_name": "dct_trn8_32" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBI__RESTART' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 2932, + "column": 1, + "source_line": "#define STBI__RESTART(x) ((x) >= 0xd0 && (x) <= 0xd7)" + }, + "unit_kind": "macro", + "unit_name": "STBI__RESTART" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbi__DNL' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 3357, + "column": 1, + "source_line": "#define stbi__DNL(x) ((x) == 0xdc)" + }, + "unit_kind": "macro", + "unit_name": "stbi__DNL" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbi__SOI' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 3358, + "column": 1, + "source_line": "#define stbi__SOI(x) ((x) == 0xd8)" + }, + "unit_kind": "macro", + "unit_name": "stbi__SOI" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbi__EOI' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 3359, + "column": 1, + "source_line": "#define stbi__EOI(x) ((x) == 0xd9)" + }, + "unit_kind": "macro", + "unit_name": "stbi__EOI" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbi__SOF' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 3360, + "column": 1, + "source_line": "#define stbi__SOF(x) ((x) == 0xc0 || (x) == 0xc1 || (x) == 0xc2)" + }, + "unit_kind": "macro", + "unit_name": "stbi__SOF" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbi__SOS' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 3361, + "column": 1, + "source_line": "#define stbi__SOS(x) ((x) == 0xda)" + }, + "unit_kind": "macro", + "unit_name": "stbi__SOS" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbi__SOF_progressive' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 3363, + "column": 1, + "source_line": "#define stbi__SOF_progressive(x) ((x) == 0xc2)" + }, + "unit_kind": "macro", + "unit_name": "stbi__SOF_progressive" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbi__div4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 3454, + "column": 1, + "source_line": "#define stbi__div4(x) ((stbi_uc) ((x) >> 2))" + }, + "unit_kind": "macro", + "unit_name": "stbi__div4" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbi__div16' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 3503, + "column": 1, + "source_line": "#define stbi__div16(x) ((stbi_uc) ((x) >> 4))" + }, + "unit_kind": "macro", + "unit_name": "stbi__div16" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbi__float2fixed' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 3659, + "column": 1, + "source_line": "#define stbi__float2fixed(x) (((int) ((x) * 4096.0f + 0.5f)) << 8)" + }, + "unit_kind": "macro", + "unit_name": "stbi__float2fixed" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBI__PNG_TYPE' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 5076, + "column": 1, + "source_line": "#define STBI__PNG_TYPE(a,b,c,d) (((unsigned) (a) << 24) + ((unsigned) (b) << 16) + ((unsigned) (c) << 8) + (unsigned) (d))" + }, + "unit_kind": "macro", + "unit_name": "STBI__PNG_TYPE" + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '\"C\"'.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 391, + "column": 1, + "source_line": "extern \"C\" {" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 870, + "column": 1, + "source_line": "static stbi_io_callbacks stbi__stdio_callbacks =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBI_THREAD_LOCAL'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 966, + "column": 1, + "source_line": "static" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBI_THREAD_LOCAL" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 972, + "column": 1, + "source_line": "STBIDEF const char *stbi_failure_reason(void)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'stbi__err'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 978, + "column": 1, + "source_line": "static int stbi__err(const char *str)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbi__err" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1101, + "column": 1, + "source_line": "STBIDEF void stbi_image_free(void *retval_from_stbi_load)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1116, + "column": 1, + "source_line": "STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBI_THREAD_LOCAL'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1124, + "column": 1, + "source_line": "static STBI_THREAD_LOCAL int stbi__vertically_flip_on_load_local, stbi__vertically_flip_on_load_set;" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBI_THREAD_LOCAL" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1126, + "column": 1, + "source_line": "STBIDEF void stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_flip)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBI_EXTERN'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1326, + "column": 1, + "source_line": "STBI_EXTERN __declspec(dllimport) int __stdcall MultiByteToWideChar(unsigned int cp, unsigned long flags, const char *str, int cbmb, wchar_t *widestr, int cchwide);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBI_EXTERN" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBI_EXTERN'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1327, + "column": 1, + "source_line": "STBI_EXTERN __declspec(dllimport) int __stdcall WideCharToMultiByte(unsigned int cp, unsigned long flags, const wchar_t *widestr, int cchwide, char *str, int cbmb, const char *defchar, int *used_default);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBI_EXTERN" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1331, + "column": 1, + "source_line": "STBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1366, + "column": 1, + "source_line": "STBIDEF stbi_uc *stbi_load(char const *filename, int *x, int *y, int *comp, int req_comp)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1376, + "column": 1, + "source_line": "STBIDEF stbi_uc *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1389, + "column": 1, + "source_line": "STBIDEF stbi__uint16 *stbi_load_from_file_16(FILE *f, int *x, int *y, int *comp, int req_comp)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1402, + "column": 1, + "source_line": "STBIDEF stbi_us *stbi_load_16(char const *filename, int *x, int *y, int *comp, int req_comp)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1415, + "column": 1, + "source_line": "STBIDEF stbi_us *stbi_load_16_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1422, + "column": 1, + "source_line": "STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1429, + "column": 1, + "source_line": "STBIDEF stbi_uc *stbi_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1436, + "column": 1, + "source_line": "STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1444, + "column": 1, + "source_line": "STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1478, + "column": 1, + "source_line": "STBIDEF float *stbi_loadf_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1485, + "column": 1, + "source_line": "STBIDEF float *stbi_loadf_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1493, + "column": 1, + "source_line": "STBIDEF float *stbi_loadf(char const *filename, int *x, int *y, int *comp, int req_comp)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1503, + "column": 1, + "source_line": "STBIDEF float *stbi_loadf_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1517, + "column": 1, + "source_line": "STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1531, + "column": 1, + "source_line": "STBIDEF int stbi_is_hdr (char const *filename)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1542, + "column": 1, + "source_line": "STBIDEF int stbi_is_hdr_from_file(FILE *f)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1559, + "column": 1, + "source_line": "STBIDEF int stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1575, + "column": 1, + "source_line": "STBIDEF void stbi_ldr_to_hdr_gamma(float gamma) { stbi__l2h_gamma = gamma; }" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1576, + "column": 1, + "source_line": "STBIDEF void stbi_ldr_to_hdr_scale(float scale) { stbi__l2h_scale = scale; }" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1581, + "column": 1, + "source_line": "STBIDEF void stbi_hdr_to_ldr_gamma(float gamma) { stbi__h2l_gamma_i = 1/gamma; }" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1582, + "column": 1, + "source_line": "STBIDEF void stbi_hdr_to_ldr_scale(float scale) { stbi__h2l_scale_i = 1/scale; }" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbi_inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1614, + "column": 1, + "source_line": "stbi_inline static stbi_uc stbi__get8(stbi__context *s)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbi_inline" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbi_inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1628, + "column": 1, + "source_line": "stbi_inline static int stbi__at_eof(stbi__context *s)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbi_inline" + }, + { + "code": "C_UNSUPPORTED_FIELD_DECLARATION", + "message": "Nested aggregate field definitions are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1963, + "column": 4, + "source_line": " struct" + }, + "unit_kind": "struct_field", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 2094, + "column": 1, + "source_line": "static const stbi__uint32 stbi__bmask[17]={0,1,3,7,15,31,63,127,255,511,1023,2047,4095,8191,16383,32767,65535};" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbi_inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 2097, + "column": 1, + "source_line": "stbi_inline static int stbi__jpeg_huff_decode(stbi__jpeg *j, stbi__huffman *h)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbi_inline" + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 2149, + "column": 1, + "source_line": "static const int stbi__jbias[16] = {0,-1,-3,-7,-15,-31,-63,-127,-255,-511,-1023,-2047,-4095,-8191,-16383,-32767};" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbi_inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 2153, + "column": 1, + "source_line": "stbi_inline static int stbi__extend_receive(stbi__jpeg *j, int n)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbi_inline" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbi_inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 2169, + "column": 1, + "source_line": "stbi_inline static int stbi__jpeg_get_bits(stbi__jpeg *j, int n)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbi_inline" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbi_inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 2181, + "column": 1, + "source_line": "stbi_inline static int stbi__jpeg_get_bit(stbi__jpeg *j)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbi_inline" + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 2194, + "column": 1, + "source_line": "static const stbi_uc stbi__jpeg_dezigzag[64+15] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbi_inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 2416, + "column": 1, + "source_line": "stbi_inline static stbi_uc stbi__clamp(int x)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbi_inline" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbi_inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 4107, + "column": 1, + "source_line": "stbi_inline static int stbi__bitreverse16(int n)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbi_inline" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbi_inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 4116, + "column": 1, + "source_line": "stbi_inline static int stbi__bit_reverse(int v, int bits)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbi_inline" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbi_inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 4192, + "column": 1, + "source_line": "stbi_inline static int stbi__zeof(stbi__zbuf *z)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbi_inline" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbi_inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 4197, + "column": 1, + "source_line": "stbi_inline static stbi_uc stbi__zget8(stbi__zbuf *z)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbi_inline" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbi_inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 4214, + "column": 1, + "source_line": "stbi_inline static unsigned int stbi__zreceive(stbi__zbuf *z, int n)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbi_inline" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbi_inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 4243, + "column": 1, + "source_line": "stbi_inline static int stbi__zhuffman_decode(stbi__zbuf *a, stbi__zhuffman *z)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbi_inline" + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 4295, + "column": 1, + "source_line": "static const int stbi__zlength_base[31] = {" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 4300, + "column": 1, + "source_line": "static const int stbi__zlength_extra[31]=" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 4303, + "column": 1, + "source_line": "static const int stbi__zdist_base[32] = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193," + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 4306, + "column": 1, + "source_line": "static const int stbi__zdist_extra[32] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 4452, + "column": 1, + "source_line": "static const stbi_uc stbi__zdefault_length[STBI__ZNSYMS] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 4464, + "column": 1, + "source_line": "static const stbi_uc stbi__zdefault_distance[32] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 4520, + "column": 1, + "source_line": "STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 4536, + "column": 1, + "source_line": "STBIDEF char *stbi_zlib_decode_malloc(char const *buffer, int len, int *outlen)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 4541, + "column": 1, + "source_line": "STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 4557, + "column": 1, + "source_line": "STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, char const *ibuffer, int ilen)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 4568, + "column": 1, + "source_line": "STBIDEF char *stbi_zlib_decode_noheader_malloc(char const *buffer, int len, int *outlen)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 4584, + "column": 1, + "source_line": "STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 4648, + "column": 1, + "source_line": "static stbi_uc first_row_filter[5] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 4670, + "column": 1, + "source_line": "static const stbi_uc stbi__depth_scale_table[9] = { 0, 0xff, 0x55, 0, 0x11, 0,0,0, 0x01 };" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 4996, + "column": 1, + "source_line": "STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 5001, + "column": 1, + "source_line": "STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBI_THREAD_LOCAL'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 5010, + "column": 1, + "source_line": "static STBI_THREAD_LOCAL int stbi__unpremultiply_on_load_local, stbi__unpremultiply_on_load_set;" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBI_THREAD_LOCAL" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBI_THREAD_LOCAL'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 5011, + "column": 1, + "source_line": "static STBI_THREAD_LOCAL int stbi__de_iphone_flag_local, stbi__de_iphone_flag_set;" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBI_THREAD_LOCAL" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 5013, + "column": 1, + "source_line": "STBIDEF void stbi_set_unpremultiply_on_load_thread(int flag_true_if_should_unpremultiply)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 5019, + "column": 1, + "source_line": "STBIDEF void stbi_convert_iphone_png_to_rgb_thread(int flag_true_if_should_convert)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 7691, + "column": 1, + "source_line": "STBIDEF int stbi_info(char const *filename, int *x, int *y, int *comp)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 7701, + "column": 1, + "source_line": "STBIDEF int stbi_info_from_file(FILE *f, int *x, int *y, int *comp)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 7712, + "column": 1, + "source_line": "STBIDEF int stbi_is_16_bit(char const *filename)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 7722, + "column": 1, + "source_line": "STBIDEF int stbi_is_16_bit_from_file(FILE *f)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 7734, + "column": 1, + "source_line": "STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 7741, + "column": 1, + "source_line": "STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *c, void *user, int *x, int *y, int *comp)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 7748, + "column": 1, + "source_line": "STBIDEF int stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 7755, + "column": 1, + "source_line": "STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *c, void *user)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_CONFLICTING_TYPEDEF", + "message": "Conflicting typedef declarations for 'stbi__uint16'.", + "severity": "error", + "location": { + "filename": "stb/stb_image.h", + "line": 648, + "column": 1, + "source_line": "typedef uint16_t stbi__uint16;" + }, + "unit_kind": "typedef", + "unit_name": "stbi__uint16" + }, + { + "code": "C_CONFLICTING_TYPEDEF", + "message": "Conflicting typedef declarations for 'stbi__int16'.", + "severity": "error", + "location": { + "filename": "stb/stb_image.h", + "line": 649, + "column": 1, + "source_line": "typedef int16_t stbi__int16;" + }, + "unit_kind": "typedef", + "unit_name": "stbi__int16" + }, + { + "code": "C_CONFLICTING_TYPEDEF", + "message": "Conflicting typedef declarations for 'stbi__uint32'.", + "severity": "error", + "location": { + "filename": "stb/stb_image.h", + "line": 650, + "column": 1, + "source_line": "typedef uint32_t stbi__uint32;" + }, + "unit_kind": "typedef", + "unit_name": "stbi__uint32" + }, + { + "code": "C_CONFLICTING_TYPEDEF", + "message": "Conflicting typedef declarations for 'stbi__int32'.", + "severity": "error", + "location": { + "filename": "stb/stb_image.h", + "line": 651, + "column": 1, + "source_line": "typedef int32_t stbi__int32;" + }, + "unit_kind": "typedef", + "unit_name": "stbi__int32" + }, + { + "code": "C_DUPLICATE_FUNCTION_DEFINITION", + "message": "Duplicate definition for function 'stbi__cpuid3'.", + "severity": "error", + "location": { + "filename": "stb/stb_image.h", + "line": 739, + "column": 1, + "source_line": "static int stbi__cpuid3(void)" + }, + "unit_kind": "function", + "unit_name": "stbi__cpuid3" + }, + { + "code": "C_DUPLICATE_FUNCTION_DEFINITION", + "message": "Duplicate definition for function 'stbi__sse2_available'.", + "severity": "error", + "location": { + "filename": "stb/stb_image.h", + "line": 765, + "column": 1, + "source_line": "static int stbi__sse2_available(void)" + }, + "unit_kind": "function", + "unit_name": "stbi__sse2_available" + }, + { + "code": "C_DUPLICATE_FUNCTION_DEFINITION", + "message": "Duplicate definition for function 'stbi__idct_simd'.", + "severity": "error", + "location": { + "filename": "stb/stb_image.h", + "line": 2711, + "column": 1, + "source_line": "static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64])" + }, + "unit_kind": "function", + "unit_name": "stbi__idct_simd" + } + ] + } + }, + "functions": { + "stbi__cpuid3": { + "name": "stbi__cpuid3", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 732, + "column": 1, + "source_line": "static int stbi__cpuid3(void)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 732, + "column": 1, + "source_line": "static int stbi__cpuid3(void)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 737, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__sse2_available": { + "name": "stbi__sse2_available", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 754, + "column": 1, + "source_line": "static int stbi__sse2_available(void)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 754, + "column": 1, + "source_line": "static int stbi__sse2_available(void)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 758, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__refill_buffer": { + "name": "stbi__refill_buffer", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1597, + "column": 1, + "source_line": "static void stbi__refill_buffer(stbi__context *s)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 1597, + "column": 1, + "source_line": "static void stbi__refill_buffer(stbi__context *s)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 1612, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_image.h", + "line": 823, + "column": 1, + "source_line": "static void stbi__refill_buffer(stbi__context *s);" + } + ] + }, + "stbi__start_mem": { + "name": "stbi__start_mem", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc const *buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc const *buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 826, + "column": 1, + "source_line": "static void stbi__start_mem(stbi__context *s, stbi_uc const *buffer, int len)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 826, + "column": 1, + "source_line": "static void stbi__start_mem(stbi__context *s, stbi_uc const *buffer, int len)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 833, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__start_callbacks": { + "name": "stbi__start_callbacks", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_io_callbacks *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_io_callbacks" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_io_callbacks *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_io_callbacks" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "user", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *user", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *user", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 836, + "column": 1, + "source_line": "static void stbi__start_callbacks(stbi__context *s, stbi_io_callbacks *c, void *user)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 836, + "column": 1, + "source_line": "static void stbi__start_callbacks(stbi__context *s, stbi_io_callbacks *c, void *user)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 846, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__stdio_read": { + "name": "stbi__stdio_read", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "user", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *user", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *user", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "size", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int size" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int size" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 850, + "column": 1, + "source_line": "static int stbi__stdio_read(void *user, char *data, int size)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 850, + "column": 1, + "source_line": "static int stbi__stdio_read(void *user, char *data, int size)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 853, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__stdio_skip": { + "name": "stbi__stdio_skip", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "user", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *user", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *user", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 855, + "column": 1, + "source_line": "static void stbi__stdio_skip(void *user, int n)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 855, + "column": 1, + "source_line": "static void stbi__stdio_skip(void *user, int n)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 863, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__stdio_eof": { + "name": "stbi__stdio_eof", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "user", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *user", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *user", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 865, + "column": 1, + "source_line": "static int stbi__stdio_eof(void *user)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 865, + "column": 1, + "source_line": "static int stbi__stdio_eof(void *user)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 868, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__start_file": { + "name": "stbi__start_file", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "FILE *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "FILE" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "FILE *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "FILE" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 877, + "column": 1, + "source_line": "static void stbi__start_file(stbi__context *s, FILE *f)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 877, + "column": 1, + "source_line": "static void stbi__start_file(stbi__context *s, FILE *f)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 880, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__rewind": { + "name": "stbi__rewind", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 886, + "column": 1, + "source_line": "static void stbi__rewind(stbi__context *s)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 886, + "column": 1, + "source_line": "static void stbi__rewind(stbi__context *s)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 893, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__jpeg_test": { + "name": "stbi__jpeg_test", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4042, + "column": 1, + "source_line": "static int stbi__jpeg_test(stbi__context *s)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 4042, + "column": 1, + "source_line": "static int stbi__jpeg_test(stbi__context *s)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 4054, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_image.h", + "line": 909, + "column": 1, + "source_line": "static int stbi__jpeg_test(stbi__context *s);" + } + ] + }, + "stbi__jpeg_load": { + "name": "stbi__jpeg_load", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "req_comp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ri", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__result_info *ri", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__result_info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__result_info *ri", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__result_info" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4028, + "column": 1, + "source_line": "static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 4028, + "column": 1, + "source_line": "static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 4040, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_image.h", + "line": 910, + "column": 1, + "source_line": "static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);" + } + ] + }, + "stbi__jpeg_info": { + "name": "stbi__jpeg_info", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4068, + "column": 1, + "source_line": "static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 4068, + "column": 1, + "source_line": "static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 4078, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_image.h", + "line": 911, + "column": 1, + "source_line": "static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp);" + } + ] + }, + "stbi__png_test": { + "name": "stbi__png_test", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 5302, + "column": 1, + "source_line": "static int stbi__png_test(stbi__context *s)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 5302, + "column": 1, + "source_line": "static int stbi__png_test(stbi__context *s)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 5308, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_image.h", + "line": 915, + "column": 1, + "source_line": "static int stbi__png_test(stbi__context *s);" + } + ] + }, + "stbi__png_load": { + "name": "stbi__png_load", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "req_comp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ri", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__result_info *ri", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__result_info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__result_info *ri", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__result_info" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 5295, + "column": 1, + "source_line": "static void *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 5295, + "column": 1, + "source_line": "static void *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 5300, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_image.h", + "line": 916, + "column": 1, + "source_line": "static void *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);" + } + ] + }, + "stbi__png_info": { + "name": "stbi__png_info", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 5322, + "column": 1, + "source_line": "static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 5322, + "column": 1, + "source_line": "static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 5327, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_image.h", + "line": 917, + "column": 1, + "source_line": "static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp);" + } + ] + }, + "stbi__png_is16": { + "name": "stbi__png_is16", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 5329, + "column": 1, + "source_line": "static int stbi__png_is16(stbi__context *s)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 5329, + "column": 1, + "source_line": "static int stbi__png_is16(stbi__context *s)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 5340, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_image.h", + "line": 918, + "column": 1, + "source_line": "static int stbi__png_is16(stbi__context *s);" + } + ] + }, + "stbi__bmp_test": { + "name": "stbi__bmp_test", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 5361, + "column": 1, + "source_line": "static int stbi__bmp_test(stbi__context *s)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 5361, + "column": 1, + "source_line": "static int stbi__bmp_test(stbi__context *s)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 5366, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_image.h", + "line": 922, + "column": 1, + "source_line": "static int stbi__bmp_test(stbi__context *s);" + } + ] + }, + "stbi__bmp_load": { + "name": "stbi__bmp_load", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "req_comp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ri", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__result_info *ri", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__result_info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__result_info *ri", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__result_info" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 5531, + "column": 1, + "source_line": "static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 5531, + "column": 1, + "source_line": "static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 5732, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_image.h", + "line": 923, + "column": 1, + "source_line": "static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);" + } + ] + }, + "stbi__bmp_info": { + "name": "stbi__bmp_info", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7335, + "column": 1, + "source_line": "static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 7335, + "column": 1, + "source_line": "static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 7355, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_image.h", + "line": 924, + "column": 1, + "source_line": "static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp);" + } + ] + }, + "stbi__tga_test": { + "name": "stbi__tga_test", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 5820, + "column": 1, + "source_line": "static int stbi__tga_test(stbi__context *s)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 5820, + "column": 1, + "source_line": "static int stbi__tga_test(stbi__context *s)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 5849, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_image.h", + "line": 928, + "column": 1, + "source_line": "static int stbi__tga_test(stbi__context *s);" + } + ] + }, + "stbi__tga_load": { + "name": "stbi__tga_load", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "req_comp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ri", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__result_info *ri", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__result_info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__result_info *ri", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__result_info" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 5871, + "column": 1, + "source_line": "static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 5871, + "column": 1, + "source_line": "static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 6074, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_image.h", + "line": 929, + "column": 1, + "source_line": "static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);" + } + ] + }, + "stbi__tga_info": { + "name": "stbi__tga_info", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 5755, + "column": 1, + "source_line": "static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 5755, + "column": 1, + "source_line": "static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 5818, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_image.h", + "line": 930, + "column": 1, + "source_line": "static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp);" + } + ] + }, + "stbi__psd_test": { + "name": "stbi__psd_test", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 6081, + "column": 1, + "source_line": "static int stbi__psd_test(stbi__context *s)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 6081, + "column": 1, + "source_line": "static int stbi__psd_test(stbi__context *s)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 6086, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_image.h", + "line": 934, + "column": 1, + "source_line": "static int stbi__psd_test(stbi__context *s);" + } + ] + }, + "stbi__psd_load": { + "name": "stbi__psd_load", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "req_comp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ri", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__result_info *ri", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__result_info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__result_info *ri", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__result_info" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "bpc", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int bpc" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int bpc" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 6126, + "column": 1, + "source_line": "static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 6126, + "column": 1, + "source_line": "static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 6325, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_image.h", + "line": 935, + "column": 1, + "source_line": "static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc);" + } + ] + }, + "stbi__psd_info": { + "name": "stbi__psd_info", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7359, + "column": 1, + "source_line": "static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 7359, + "column": 1, + "source_line": "static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 7392, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_image.h", + "line": 936, + "column": 1, + "source_line": "static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp);" + } + ] + }, + "stbi__psd_is16": { + "name": "stbi__psd_is16", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7394, + "column": 1, + "source_line": "static int stbi__psd_is16(stbi__context *s)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 7394, + "column": 1, + "source_line": "static int stbi__psd_is16(stbi__context *s)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 7419, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_image.h", + "line": 937, + "column": 1, + "source_line": "static int stbi__psd_is16(stbi__context *s);" + } + ] + }, + "stbi__hdr_test": { + "name": "stbi__hdr_test", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context * s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context * s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7097, + "column": 1, + "source_line": "static int stbi__hdr_test(stbi__context* s)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 7097, + "column": 1, + "source_line": "static int stbi__hdr_test(stbi__context* s)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 7106, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_image.h", + "line": 941, + "column": 1, + "source_line": "static int stbi__hdr_test(stbi__context *s);" + } + ] + }, + "stbi__hdr_load": { + "name": "stbi__hdr_load", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "req_comp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ri", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__result_info *ri", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__result_info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__result_info *ri", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__result_info" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7158, + "column": 1, + "source_line": "static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 7158, + "column": 1, + "source_line": "static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 7287, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_image.h", + "line": 942, + "column": 1, + "source_line": "static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);" + } + ] + }, + "stbi__hdr_info": { + "name": "stbi__hdr_info", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7289, + "column": 1, + "source_line": "static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 7289, + "column": 1, + "source_line": "static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 7331, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_image.h", + "line": 943, + "column": 1, + "source_line": "static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp);" + } + ] + }, + "stbi__pic_test": { + "name": "stbi__pic_test", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 6541, + "column": 1, + "source_line": "static int stbi__pic_test(stbi__context *s)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 6541, + "column": 1, + "source_line": "static int stbi__pic_test(stbi__context *s)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 6546, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_image.h", + "line": 947, + "column": 1, + "source_line": "static int stbi__pic_test(stbi__context *s);" + } + ] + }, + "stbi__pic_load": { + "name": "stbi__pic_load", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "px", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *px", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *px", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "py", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *py", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *py", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "req_comp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ri", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__result_info *ri", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__result_info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__result_info *ri", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__result_info" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 6500, + "column": 1, + "source_line": "static void *stbi__pic_load(stbi__context *s,int *px,int *py,int *comp,int req_comp, stbi__result_info *ri)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 6500, + "column": 1, + "source_line": "static void *stbi__pic_load(stbi__context *s,int *px,int *py,int *comp,int req_comp, stbi__result_info *ri)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 6539, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_image.h", + "line": 948, + "column": 1, + "source_line": "static void *stbi__pic_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);" + } + ] + }, + "stbi__pic_info": { + "name": "stbi__pic_info", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7423, + "column": 1, + "source_line": "static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 7423, + "column": 1, + "source_line": "static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 7478, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_image.h", + "line": 949, + "column": 1, + "source_line": "static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp);" + } + ] + }, + "stbi__gif_test": { + "name": "stbi__gif_test", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 6590, + "column": 1, + "source_line": "static int stbi__gif_test(stbi__context *s)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 6590, + "column": 1, + "source_line": "static int stbi__gif_test(stbi__context *s)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 6595, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_image.h", + "line": 953, + "column": 1, + "source_line": "static int stbi__gif_test(stbi__context *s);" + } + ] + }, + "stbi__gif_load": { + "name": "stbi__gif_load", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "req_comp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ri", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__result_info *ri", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__result_info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__result_info *ri", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__result_info" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7048, + "column": 1, + "source_line": "static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 7048, + "column": 1, + "source_line": "static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 7075, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_image.h", + "line": 954, + "column": 1, + "source_line": "static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);" + } + ] + }, + "stbi__load_gif_main": { + "name": "stbi__load_gif_main", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "delays", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int **delays", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int **delays", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "z", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "req_comp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 6963, + "column": 1, + "source_line": "static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, int req_comp)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 6963, + "column": 1, + "source_line": "static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, int req_comp)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 7046, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_image.h", + "line": 955, + "column": 1, + "source_line": "static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, int req_comp);" + } + ] + }, + "stbi__gif_info": { + "name": "stbi__gif_info", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7077, + "column": 1, + "source_line": "static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 7077, + "column": 1, + "source_line": "static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 7080, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_image.h", + "line": 956, + "column": 1, + "source_line": "static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp);" + } + ] + }, + "stbi__pnm_test": { + "name": "stbi__pnm_test", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7494, + "column": 1, + "source_line": "static int stbi__pnm_test(stbi__context *s)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 7494, + "column": 1, + "source_line": "static int stbi__pnm_test(stbi__context *s)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 7504, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_image.h", + "line": 960, + "column": 1, + "source_line": "static int stbi__pnm_test(stbi__context *s);" + } + ] + }, + "stbi__pnm_load": { + "name": "stbi__pnm_load", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "req_comp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ri", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__result_info *ri", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__result_info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__result_info *ri", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__result_info" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7506, + "column": 1, + "source_line": "static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 7506, + "column": 1, + "source_line": "static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 7541, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_image.h", + "line": 961, + "column": 1, + "source_line": "static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);" + } + ] + }, + "stbi__pnm_info": { + "name": "stbi__pnm_info", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7581, + "column": 1, + "source_line": "static int stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 7581, + "column": 1, + "source_line": "static int stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 7622, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_image.h", + "line": 962, + "column": 1, + "source_line": "static int stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp);" + } + ] + }, + "stbi__pnm_is16": { + "name": "stbi__pnm_is16", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7624, + "column": 1, + "source_line": "static int stbi__pnm_is16(stbi__context *s)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 7624, + "column": 1, + "source_line": "static int stbi__pnm_is16(stbi__context *s)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 7629, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_image.h", + "line": 963, + "column": 1, + "source_line": "static int stbi__pnm_is16(stbi__context *s);" + } + ] + }, + "stbi__malloc": { + "name": "stbi__malloc", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "parameters": [ + { + "name": "size", + "type": { + "reference": "size_t" + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 985, + "column": 1, + "source_line": "static void *stbi__malloc(size_t size)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 985, + "column": 1, + "source_line": "static void *stbi__malloc(size_t size)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 988, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__addsizes_valid": { + "name": "stbi__addsizes_valid", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1002, + "column": 1, + "source_line": "static int stbi__addsizes_valid(int a, int b)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 1002, + "column": 1, + "source_line": "static int stbi__addsizes_valid(int a, int b)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 1010, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__mul2sizes_valid": { + "name": "stbi__mul2sizes_valid", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1014, + "column": 1, + "source_line": "static int stbi__mul2sizes_valid(int a, int b)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 1014, + "column": 1, + "source_line": "static int stbi__mul2sizes_valid(int a, int b)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 1020, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__mad2sizes_valid": { + "name": "stbi__mad2sizes_valid", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "add", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int add" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int add" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1024, + "column": 1, + "source_line": "static int stbi__mad2sizes_valid(int a, int b, int add)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 1024, + "column": 1, + "source_line": "static int stbi__mad2sizes_valid(int a, int b, int add)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 1027, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__mad3sizes_valid": { + "name": "stbi__mad3sizes_valid", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "add", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int add" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int add" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1031, + "column": 1, + "source_line": "static int stbi__mad3sizes_valid(int a, int b, int c, int add)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 1031, + "column": 1, + "source_line": "static int stbi__mad3sizes_valid(int a, int b, int c, int add)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 1035, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__mad4sizes_valid": { + "name": "stbi__mad4sizes_valid", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "d", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int d" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int d" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "add", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int add" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int add" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1039, + "column": 1, + "source_line": "static int stbi__mad4sizes_valid(int a, int b, int c, int d, int add)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 1039, + "column": 1, + "source_line": "static int stbi__mad4sizes_valid(int a, int b, int c, int d, int add)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 1043, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__malloc_mad2": { + "name": "stbi__malloc_mad2", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "add", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int add" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int add" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1048, + "column": 1, + "source_line": "static void *stbi__malloc_mad2(int a, int b, int add)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 1048, + "column": 1, + "source_line": "static void *stbi__malloc_mad2(int a, int b, int add)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 1052, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__malloc_mad3": { + "name": "stbi__malloc_mad3", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "add", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int add" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int add" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1055, + "column": 1, + "source_line": "static void *stbi__malloc_mad3(int a, int b, int c, int add)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 1055, + "column": 1, + "source_line": "static void *stbi__malloc_mad3(int a, int b, int c, int add)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 1059, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__malloc_mad4": { + "name": "stbi__malloc_mad4", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "d", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int d" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int d" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "add", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int add" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int add" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1062, + "column": 1, + "source_line": "static void *stbi__malloc_mad4(int a, int b, int c, int d, int add)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 1062, + "column": 1, + "source_line": "static void *stbi__malloc_mad4(int a, int b, int c, int d, int add)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 1066, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__addints_valid": { + "name": "stbi__addints_valid", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1070, + "column": 1, + "source_line": "static int stbi__addints_valid(int a, int b)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 1070, + "column": 1, + "source_line": "static int stbi__addints_valid(int a, int b)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 1075, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__mul2shorts_valid": { + "name": "stbi__mul2shorts_valid", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1078, + "column": 1, + "source_line": "static int stbi__mul2shorts_valid(int a, int b)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 1078, + "column": 1, + "source_line": "static int stbi__mul2shorts_valid(int a, int b)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 1084, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__ldr_to_hdr": { + "name": "stbi__ldr_to_hdr", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "parameters": [ + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int comp" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int comp" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1858, + "column": 1, + "source_line": "static float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 1858, + "column": 1, + "source_line": "static float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 1879, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_image.h", + "line": 1107, + "column": 1, + "source_line": "static float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp);" + } + ] + }, + "stbi__hdr_to_ldr": { + "name": "stbi__hdr_to_ldr", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "parameters": [ + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int comp" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int comp" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1884, + "column": 1, + "source_line": "static stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 1884, + "column": 1, + "source_line": "static stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 1909, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_image.h", + "line": 1111, + "column": 1, + "source_line": "static stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp);" + } + ] + }, + "stbi__load_main": { + "name": "stbi__load_main", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "req_comp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ri", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__result_info *ri", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__result_info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__result_info *ri", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__result_info" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "bpc", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int bpc" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int bpc" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1137, + "column": 1, + "source_line": "static void *stbi__load_main(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 1137, + "column": 1, + "source_line": "static void *stbi__load_main(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 1188, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__convert_16_to_8": { + "name": "stbi__convert_16_to_8", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "parameters": [ + { + "name": "orig", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__uint16 *orig", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__uint16" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__uint16 *orig", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__uint16" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "w", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "h", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "channels", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int channels" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int channels" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1190, + "column": 1, + "source_line": "static stbi_uc *stbi__convert_16_to_8(stbi__uint16 *orig, int w, int h, int channels)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 1190, + "column": 1, + "source_line": "static stbi_uc *stbi__convert_16_to_8(stbi__uint16 *orig, int w, int h, int channels)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 1204, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__convert_8_to_16": { + "name": "stbi__convert_8_to_16", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__uint16", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__uint16" + } + ] + }, + "parameters": [ + { + "name": "orig", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *orig", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *orig", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "w", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "h", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "channels", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int channels" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int channels" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1206, + "column": 1, + "source_line": "static stbi__uint16 *stbi__convert_8_to_16(stbi_uc *orig, int w, int h, int channels)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 1206, + "column": 1, + "source_line": "static stbi__uint16 *stbi__convert_8_to_16(stbi_uc *orig, int w, int h, int channels)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 1220, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__vertical_flip": { + "name": "stbi__vertical_flip", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "image", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *image", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *image", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "w", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "h", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "bytes_per_pixel", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int bytes_per_pixel" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int bytes_per_pixel" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1222, + "column": 1, + "source_line": "static void stbi__vertical_flip(void *image, int w, int h, int bytes_per_pixel)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 1222, + "column": 1, + "source_line": "static void stbi__vertical_flip(void *image, int w, int h, int bytes_per_pixel)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 1244, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__vertical_flip_slices": { + "name": "stbi__vertical_flip_slices", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "image", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *image", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *image", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "w", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "h", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "z", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int z" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int z" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "bytes_per_pixel", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int bytes_per_pixel" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int bytes_per_pixel" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1247, + "column": 1, + "source_line": "static void stbi__vertical_flip_slices(void *image, int w, int h, int z, int bytes_per_pixel)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 1247, + "column": 1, + "source_line": "static void stbi__vertical_flip_slices(void *image, int w, int h, int z, int bytes_per_pixel)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 1257, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__load_and_postprocess_8bit": { + "name": "stbi__load_and_postprocess_8bit", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "req_comp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1260, + "column": 1, + "source_line": "static unsigned char *stbi__load_and_postprocess_8bit(stbi__context *s, int *x, int *y, int *comp, int req_comp)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 1260, + "column": 1, + "source_line": "static unsigned char *stbi__load_and_postprocess_8bit(stbi__context *s, int *x, int *y, int *comp, int req_comp)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 1284, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__load_and_postprocess_16bit": { + "name": "stbi__load_and_postprocess_16bit", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__uint16", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__uint16" + } + ] + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "req_comp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1286, + "column": 1, + "source_line": "static stbi__uint16 *stbi__load_and_postprocess_16bit(stbi__context *s, int *x, int *y, int *comp, int req_comp)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 1286, + "column": 1, + "source_line": "static stbi__uint16 *stbi__load_and_postprocess_16bit(stbi__context *s, int *x, int *y, int *comp, int req_comp)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 1311, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__float_postprocess": { + "name": "stbi__float_postprocess", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "result", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *result", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *result", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "req_comp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1314, + "column": 1, + "source_line": "static void stbi__float_postprocess(float *result, int *x, int *y, int *comp, int req_comp)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 1314, + "column": 1, + "source_line": "static void stbi__float_postprocess(float *result, int *x, int *y, int *comp, int req_comp)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 1320, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__fopen": { + "name": "stbi__fopen", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "FILE", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "FILE" + } + ] + }, + "parameters": [ + { + "name": "filename", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char const *filename", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char const *filename", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mode", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char const *mode", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char const *mode", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1337, + "column": 1, + "source_line": "static FILE *stbi__fopen(char const *filename, char const *mode)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 1337, + "column": 1, + "source_line": "static FILE *stbi__fopen(char const *filename, char const *mode)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 1363, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__loadf_main": { + "name": "stbi__loadf_main", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "req_comp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1460, + "column": 1, + "source_line": "static float *stbi__loadf_main(stbi__context *s, int *x, int *y, int *comp, int req_comp)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 1460, + "column": 1, + "source_line": "static float *stbi__loadf_main(stbi__context *s, int *x, int *y, int *comp, int req_comp)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 1476, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__skip": { + "name": "stbi__skip", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1644, + "column": 1, + "source_line": "static void stbi__skip(stbi__context *s, int n)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 1644, + "column": 1, + "source_line": "static void stbi__skip(stbi__context *s, int n)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 1660, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__getn": { + "name": "stbi__getn", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1666, + "column": 1, + "source_line": "static int stbi__getn(stbi__context *s, stbi_uc *buffer, int n)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 1666, + "column": 1, + "source_line": "static int stbi__getn(stbi__context *s, stbi_uc *buffer, int n)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 1688, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__get16be": { + "name": "stbi__get16be", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1694, + "column": 1, + "source_line": "static int stbi__get16be(stbi__context *s)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 1694, + "column": 1, + "source_line": "static int stbi__get16be(stbi__context *s)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 1698, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__get32be": { + "name": "stbi__get32be", + "result_type": { + "reference": "stbi__uint32" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1704, + "column": 1, + "source_line": "static stbi__uint32 stbi__get32be(stbi__context *s)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 1704, + "column": 1, + "source_line": "static stbi__uint32 stbi__get32be(stbi__context *s)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 1708, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__get16le": { + "name": "stbi__get16le", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1714, + "column": 1, + "source_line": "static int stbi__get16le(stbi__context *s)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 1714, + "column": 1, + "source_line": "static int stbi__get16le(stbi__context *s)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 1718, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__get32le": { + "name": "stbi__get32le", + "result_type": { + "reference": "stbi__uint32" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1722, + "column": 1, + "source_line": "static stbi__uint32 stbi__get32le(stbi__context *s)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 1722, + "column": 1, + "source_line": "static stbi__uint32 stbi__get32le(stbi__context *s)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 1727, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__compute_y": { + "name": "stbi__compute_y", + "result_type": { + "reference": "stbi_uc" + }, + "parameters": [ + { + "name": "r", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int r" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int r" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "g", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int g" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int g" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1746, + "column": 1, + "source_line": "static stbi_uc stbi__compute_y(int r, int g, int b)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 1746, + "column": 1, + "source_line": "static stbi_uc stbi__compute_y(int r, int g, int b)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 1749, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__convert_format": { + "name": "stbi__convert_format", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "parameters": [ + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "img_n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int img_n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int img_n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "req_comp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int x" + }, + "declared_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int y" + }, + "declared_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int y" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1755, + "column": 1, + "source_line": "static unsigned char *stbi__convert_format(unsigned char *data, int img_n, int req_comp, unsigned int x, unsigned int y)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 1755, + "column": 1, + "source_line": "static unsigned char *stbi__convert_format(unsigned char *data, int img_n, int req_comp, unsigned int x, unsigned int y)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 1797, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__compute_y_16": { + "name": "stbi__compute_y_16", + "result_type": { + "reference": "stbi__uint16" + }, + "parameters": [ + { + "name": "r", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int r" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int r" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "g", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int g" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int g" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1803, + "column": 1, + "source_line": "static stbi__uint16 stbi__compute_y_16(int r, int g, int b)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 1803, + "column": 1, + "source_line": "static stbi__uint16 stbi__compute_y_16(int r, int g, int b)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 1806, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__convert_format16": { + "name": "stbi__convert_format16", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__uint16", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__uint16" + } + ] + }, + "parameters": [ + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__uint16 *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__uint16" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__uint16 *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__uint16" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "img_n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int img_n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int img_n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "req_comp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int x" + }, + "declared_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int y" + }, + "declared_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int y" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1812, + "column": 1, + "source_line": "static stbi__uint16 *stbi__convert_format16(stbi__uint16 *data, int img_n, int req_comp, unsigned int x, unsigned int y)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 1812, + "column": 1, + "source_line": "static stbi__uint16 *stbi__convert_format16(stbi__uint16 *data, int img_n, int req_comp, unsigned int x, unsigned int y)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 1854, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__build_huffman": { + "name": "stbi__build_huffman", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "h", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__huffman *h", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__huffman" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__huffman *h", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__huffman" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "count", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *count", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *count", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2003, + "column": 1, + "source_line": "static int stbi__build_huffman(stbi__huffman *h, int *count)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 2003, + "column": 1, + "source_line": "static int stbi__build_huffman(stbi__huffman *h, int *count)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 2046, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__build_fast_ac": { + "name": "stbi__build_fast_ac", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "fast_ac", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__int16 *fast_ac", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__int16" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__int16 *fast_ac", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__int16" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "h", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__huffman *h", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__huffman" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__huffman *h", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__huffman" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2050, + "column": 1, + "source_line": "static void stbi__build_fast_ac(stbi__int16 *fast_ac, stbi__huffman *h)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 2050, + "column": 1, + "source_line": "static void stbi__build_fast_ac(stbi__int16 *fast_ac, stbi__huffman *h)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 2073, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__grow_buffer_unsafe": { + "name": "stbi__grow_buffer_unsafe", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "j", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *j", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *j", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2075, + "column": 1, + "source_line": "static void stbi__grow_buffer_unsafe(stbi__jpeg *j)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 2075, + "column": 1, + "source_line": "static void stbi__grow_buffer_unsafe(stbi__jpeg *j)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 2091, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__jpeg_decode_block": { + "name": "stbi__jpeg_decode_block", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "j", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *j", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *j", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short data[64]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short data[64]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "64", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "hdc", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__huffman *hdc", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__huffman" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__huffman *hdc", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__huffman" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "hac", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__huffman *hac", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__huffman" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__huffman *hac", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__huffman" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "fac", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__int16 *fac", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__int16" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__int16 *fac", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__int16" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dequant", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__uint16 *dequant", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__uint16" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__uint16 *dequant", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__uint16" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2210, + "column": 1, + "source_line": "static int stbi__jpeg_decode_block(stbi__jpeg *j, short data[64], stbi__huffman *hdc, stbi__huffman *hac, stbi__int16 *fac, int b, stbi__uint16 *dequant)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 2210, + "column": 1, + "source_line": "static int stbi__jpeg_decode_block(stbi__jpeg *j, short data[64], stbi__huffman *hdc, stbi__huffman *hac, stbi__int16 *fac, int b, stbi__uint16 *dequant)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 2263, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__jpeg_decode_block_prog_dc": { + "name": "stbi__jpeg_decode_block_prog_dc", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "j", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *j", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *j", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short data[64]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short data[64]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "64", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "hdc", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__huffman *hdc", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__huffman" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__huffman *hdc", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__huffman" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2265, + "column": 1, + "source_line": "static int stbi__jpeg_decode_block_prog_dc(stbi__jpeg *j, short data[64], stbi__huffman *hdc, int b)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 2265, + "column": 1, + "source_line": "static int stbi__jpeg_decode_block_prog_dc(stbi__jpeg *j, short data[64], stbi__huffman *hdc, int b)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 2291, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__jpeg_decode_block_prog_ac": { + "name": "stbi__jpeg_decode_block_prog_ac", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "j", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *j", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *j", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short data[64]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short data[64]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "64", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "hac", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__huffman *hac", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__huffman" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__huffman *hac", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__huffman" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "fac", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__int16 *fac", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__int16" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__int16 *fac", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__int16" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2295, + "column": 1, + "source_line": "static int stbi__jpeg_decode_block_prog_ac(stbi__jpeg *j, short data[64], stbi__huffman *hac, stbi__int16 *fac)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 2295, + "column": 1, + "source_line": "static int stbi__jpeg_decode_block_prog_ac(stbi__jpeg *j, short data[64], stbi__huffman *hac, stbi__int16 *fac)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 2413, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__idct_block": { + "name": "stbi__idct_block", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "out", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *out", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *out", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "out_stride", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int out_stride" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int out_stride" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short data[64]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short data[64]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "64", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2467, + "column": 1, + "source_line": "static void stbi__idct_block(stbi_uc *out, int out_stride, short data[64])" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 2467, + "column": 1, + "source_line": "static void stbi__idct_block(stbi_uc *out, int out_stride, short data[64])" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 2524, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__idct_simd": { + "name": "stbi__idct_simd", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "out", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *out", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *out", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "out_stride", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int out_stride" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int out_stride" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short data[64]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short data[64]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "64", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2530, + "column": 1, + "source_line": "static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64])" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 2530, + "column": 1, + "source_line": "static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64])" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 2703, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__get_marker": { + "name": "stbi__get_marker", + "result_type": { + "reference": "stbi_uc" + }, + "parameters": [ + { + "name": "j", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *j", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *j", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2919, + "column": 1, + "source_line": "static stbi_uc stbi__get_marker(stbi__jpeg *j)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 2919, + "column": 1, + "source_line": "static stbi_uc stbi__get_marker(stbi__jpeg *j)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 2928, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__jpeg_reset": { + "name": "stbi__jpeg_reset", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "j", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *j", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *j", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2936, + "column": 1, + "source_line": "static void stbi__jpeg_reset(stbi__jpeg *j)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 2936, + "column": 1, + "source_line": "static void stbi__jpeg_reset(stbi__jpeg *j)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 2947, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__parse_entropy_coded_data": { + "name": "stbi__parse_entropy_coded_data", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "z", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2949, + "column": 1, + "source_line": "static int stbi__parse_entropy_coded_data(stbi__jpeg *z)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 2949, + "column": 1, + "source_line": "static int stbi__parse_entropy_coded_data(stbi__jpeg *z)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 3071, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__jpeg_dequantize": { + "name": "stbi__jpeg_dequantize", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dequant", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__uint16 *dequant", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__uint16" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__uint16 *dequant", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__uint16" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 3073, + "column": 1, + "source_line": "static void stbi__jpeg_dequantize(short *data, stbi__uint16 *dequant)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 3073, + "column": 1, + "source_line": "static void stbi__jpeg_dequantize(short *data, stbi__uint16 *dequant)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 3078, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__jpeg_finish": { + "name": "stbi__jpeg_finish", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "z", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 3080, + "column": 1, + "source_line": "static void stbi__jpeg_finish(stbi__jpeg *z)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 3080, + "column": 1, + "source_line": "static void stbi__jpeg_finish(stbi__jpeg *z)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 3097, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__process_marker": { + "name": "stbi__process_marker", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "z", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "m", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int m" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int m" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 3099, + "column": 1, + "source_line": "static int stbi__process_marker(stbi__jpeg *z, int m)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 3099, + "column": 1, + "source_line": "static int stbi__process_marker(stbi__jpeg *z, int m)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 3200, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__process_scan_header": { + "name": "stbi__process_scan_header", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "z", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 3203, + "column": 1, + "source_line": "static int stbi__process_scan_header(stbi__jpeg *z)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 3203, + "column": 1, + "source_line": "static int stbi__process_scan_header(stbi__jpeg *z)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 3240, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__free_jpeg_components": { + "name": "stbi__free_jpeg_components", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "z", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ncomp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ncomp" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ncomp" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "why", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int why" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int why" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 3242, + "column": 1, + "source_line": "static int stbi__free_jpeg_components(stbi__jpeg *z, int ncomp, int why)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 3242, + "column": 1, + "source_line": "static int stbi__free_jpeg_components(stbi__jpeg *z, int ncomp, int why)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 3262, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__process_frame_header": { + "name": "stbi__process_frame_header", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "z", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "scan", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int scan" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int scan" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 3264, + "column": 1, + "source_line": "static int stbi__process_frame_header(stbi__jpeg *z, int scan)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 3264, + "column": 1, + "source_line": "static int stbi__process_frame_header(stbi__jpeg *z, int scan)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 3354, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__decode_jpeg_header": { + "name": "stbi__decode_jpeg_header", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "z", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "scan", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int scan" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int scan" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 3365, + "column": 1, + "source_line": "static int stbi__decode_jpeg_header(stbi__jpeg *z, int scan)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 3365, + "column": 1, + "source_line": "static int stbi__decode_jpeg_header(stbi__jpeg *z, int scan)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 3387, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__skip_jpeg_junk_at_end": { + "name": "stbi__skip_jpeg_junk_at_end", + "result_type": { + "reference": "stbi_uc" + }, + "parameters": [ + { + "name": "j", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *j", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *j", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 3389, + "column": 1, + "source_line": "static stbi_uc stbi__skip_jpeg_junk_at_end(stbi__jpeg *j)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 3389, + "column": 1, + "source_line": "static stbi_uc stbi__skip_jpeg_junk_at_end(stbi__jpeg *j)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 3409, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__decode_jpeg_image": { + "name": "stbi__decode_jpeg_image", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "j", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *j", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *j", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 3412, + "column": 1, + "source_line": "static int stbi__decode_jpeg_image(stbi__jpeg *j)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 3412, + "column": 1, + "source_line": "static int stbi__decode_jpeg_image(stbi__jpeg *j)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 3447, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "resample_row_1": { + "name": "resample_row_1", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "parameters": [ + { + "name": "out", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *out", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *out", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "in_near", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *in_near", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *in_near", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "in_far", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *in_far", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *in_far", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "w", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "hs", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int hs" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int hs" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 3456, + "column": 1, + "source_line": "static stbi_uc *resample_row_1(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 3456, + "column": 1, + "source_line": "static stbi_uc *resample_row_1(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 3463, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__resample_row_v_2": { + "name": "stbi__resample_row_v_2", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "parameters": [ + { + "name": "out", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *out", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *out", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "in_near", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *in_near", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *in_near", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "in_far", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *in_far", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *in_far", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "w", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "hs", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int hs" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int hs" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 3465, + "column": 1, + "source_line": "static stbi_uc* stbi__resample_row_v_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 3465, + "column": 1, + "source_line": "static stbi_uc* stbi__resample_row_v_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 3473, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__resample_row_h_2": { + "name": "stbi__resample_row_h_2", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "parameters": [ + { + "name": "out", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *out", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *out", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "in_near", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *in_near", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *in_near", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "in_far", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *in_far", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *in_far", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "w", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "hs", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int hs" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int hs" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 3475, + "column": 1, + "source_line": "static stbi_uc* stbi__resample_row_h_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 3475, + "column": 1, + "source_line": "static stbi_uc* stbi__resample_row_h_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 3501, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__resample_row_hv_2": { + "name": "stbi__resample_row_hv_2", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "parameters": [ + { + "name": "out", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *out", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *out", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "in_near", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *in_near", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *in_near", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "in_far", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *in_far", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *in_far", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "w", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "hs", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int hs" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int hs" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 3505, + "column": 1, + "source_line": "static stbi_uc *stbi__resample_row_hv_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 3505, + "column": 1, + "source_line": "static stbi_uc *stbi__resample_row_hv_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 3527, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__resample_row_hv_2_simd": { + "name": "stbi__resample_row_hv_2_simd", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "parameters": [ + { + "name": "out", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *out", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *out", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "in_near", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *in_near", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *in_near", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "in_far", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *in_far", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *in_far", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "w", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "hs", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int hs" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int hs" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 3530, + "column": 1, + "source_line": "static stbi_uc *stbi__resample_row_hv_2_simd(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 3530, + "column": 1, + "source_line": "static stbi_uc *stbi__resample_row_hv_2_simd(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 3643, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__resample_row_generic": { + "name": "stbi__resample_row_generic", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "parameters": [ + { + "name": "out", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *out", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *out", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "in_near", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *in_near", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *in_near", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "in_far", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *in_far", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *in_far", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "w", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "hs", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int hs" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int hs" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 3646, + "column": 1, + "source_line": "static stbi_uc *stbi__resample_row_generic(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 3646, + "column": 1, + "source_line": "static stbi_uc *stbi__resample_row_generic(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 3655, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__YCbCr_to_RGB_row": { + "name": "stbi__YCbCr_to_RGB_row", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "out", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *out", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *out", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stbi_uc *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stbi_uc *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "pcb", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stbi_uc *pcb", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stbi_uc *pcb", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "pcr", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stbi_uc *pcr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stbi_uc *pcr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "count", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int count" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int count" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "step", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int step" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int step" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 3660, + "column": 1, + "source_line": "static void stbi__YCbCr_to_RGB_row(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 3660, + "column": 1, + "source_line": "static void stbi__YCbCr_to_RGB_row(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 3683, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__YCbCr_to_RGB_simd": { + "name": "stbi__YCbCr_to_RGB_simd", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "out", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *out", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *out", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc const *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc const *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "pcb", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc const *pcb", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc const *pcb", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "pcr", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc const *pcr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc const *pcr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "count", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int count" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int count" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "step", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int step" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int step" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 3686, + "column": 1, + "source_line": "static void stbi__YCbCr_to_RGB_simd(stbi_uc *out, stbi_uc const *y, stbi_uc const *pcb, stbi_uc const *pcr, int count, int step)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 3686, + "column": 1, + "source_line": "static void stbi__YCbCr_to_RGB_simd(stbi_uc *out, stbi_uc const *y, stbi_uc const *pcb, stbi_uc const *pcr, int count, int step)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 3817, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__setup_jpeg": { + "name": "stbi__setup_jpeg", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "j", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *j", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *j", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 3821, + "column": 1, + "source_line": "static void stbi__setup_jpeg(stbi__jpeg *j)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 3821, + "column": 1, + "source_line": "static void stbi__setup_jpeg(stbi__jpeg *j)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 3840, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__cleanup_jpeg": { + "name": "stbi__cleanup_jpeg", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "j", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *j", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *j", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 3843, + "column": 1, + "source_line": "static void stbi__cleanup_jpeg(stbi__jpeg *j)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 3843, + "column": 1, + "source_line": "static void stbi__cleanup_jpeg(stbi__jpeg *j)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 3846, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__blinn_8x8": { + "name": "stbi__blinn_8x8", + "result_type": { + "reference": "stbi_uc" + }, + "parameters": [ + { + "name": "x", + "type": { + "reference": "stbi_uc" + }, + "declared_type": { + "reference": "stbi_uc" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "reference": "stbi_uc" + }, + "declared_type": { + "reference": "stbi_uc" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 3859, + "column": 1, + "source_line": "static stbi_uc stbi__blinn_8x8(stbi_uc x, stbi_uc y)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 3859, + "column": 1, + "source_line": "static stbi_uc stbi__blinn_8x8(stbi_uc x, stbi_uc y)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 3863, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "load_jpeg_image": { + "name": "load_jpeg_image", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "parameters": [ + { + "name": "z", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "out_x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *out_x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *out_x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "out_y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *out_y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *out_y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "req_comp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 3865, + "column": 1, + "source_line": "static stbi_uc *load_jpeg_image(stbi__jpeg *z, int *out_x, int *out_y, int *comp, int req_comp)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 3865, + "column": 1, + "source_line": "static stbi_uc *load_jpeg_image(stbi__jpeg *z, int *out_x, int *out_y, int *comp, int req_comp)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 4026, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__jpeg_info_raw": { + "name": "stbi__jpeg_info_raw", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "j", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *j", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__jpeg *j", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__jpeg" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4056, + "column": 1, + "source_line": "static int stbi__jpeg_info_raw(stbi__jpeg *j, int *x, int *y, int *comp)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 4056, + "column": 1, + "source_line": "static int stbi__jpeg_info_raw(stbi__jpeg *j, int *x, int *y, int *comp)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 4066, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__zbuild_huffman": { + "name": "stbi__zbuild_huffman", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "z", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__zhuffman *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__zhuffman" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__zhuffman *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__zhuffman" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "sizelist", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stbi_uc *sizelist", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stbi_uc *sizelist", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "num", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4124, + "column": 1, + "source_line": "static int stbi__zbuild_huffman(stbi__zhuffman *z, const stbi_uc *sizelist, int num)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 4124, + "column": 1, + "source_line": "static int stbi__zbuild_huffman(stbi__zhuffman *z, const stbi_uc *sizelist, int num)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 4169, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__fill_bits": { + "name": "stbi__fill_bits", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "z", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__zbuf *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__zbuf" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__zbuf *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__zbuf" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4202, + "column": 1, + "source_line": "static void stbi__fill_bits(stbi__zbuf *z)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 4202, + "column": 1, + "source_line": "static void stbi__fill_bits(stbi__zbuf *z)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 4212, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__zhuffman_decode_slowpath": { + "name": "stbi__zhuffman_decode_slowpath", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__zbuf *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__zbuf" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__zbuf *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__zbuf" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "z", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__zhuffman *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__zhuffman" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__zhuffman *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__zhuffman" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4224, + "column": 1, + "source_line": "static int stbi__zhuffman_decode_slowpath(stbi__zbuf *a, stbi__zhuffman *z)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 4224, + "column": 1, + "source_line": "static int stbi__zhuffman_decode_slowpath(stbi__zbuf *a, stbi__zhuffman *z)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 4241, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__zexpand": { + "name": "stbi__zexpand", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "z", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__zbuf *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__zbuf" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__zbuf *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__zbuf" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "zout", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *zout", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *zout", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4273, + "column": 1, + "source_line": "static int stbi__zexpand(stbi__zbuf *z, char *zout, int n) // need to make room for n bytes" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 4273, + "column": 1, + "source_line": "static int stbi__zexpand(stbi__zbuf *z, char *zout, int n) // need to make room for n bytes" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 4293, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__parse_huffman_block": { + "name": "stbi__parse_huffman_block", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__zbuf *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__zbuf" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__zbuf *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__zbuf" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4309, + "column": 1, + "source_line": "static int stbi__parse_huffman_block(stbi__zbuf *a)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 4309, + "column": 1, + "source_line": "static int stbi__parse_huffman_block(stbi__zbuf *a)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 4357, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__compute_huffman_codes": { + "name": "stbi__compute_huffman_codes", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__zbuf *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__zbuf" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__zbuf *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__zbuf" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4359, + "column": 1, + "source_line": "static int stbi__compute_huffman_codes(stbi__zbuf *a)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 4359, + "column": 1, + "source_line": "static int stbi__compute_huffman_codes(stbi__zbuf *a)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 4407, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__parse_uncompressed_block": { + "name": "stbi__parse_uncompressed_block", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__zbuf *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__zbuf" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__zbuf *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__zbuf" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4409, + "column": 1, + "source_line": "static int stbi__parse_uncompressed_block(stbi__zbuf *a)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 4409, + "column": 1, + "source_line": "static int stbi__parse_uncompressed_block(stbi__zbuf *a)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 4436, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__parse_zlib_header": { + "name": "stbi__parse_zlib_header", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__zbuf *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__zbuf" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__zbuf *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__zbuf" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4438, + "column": 1, + "source_line": "static int stbi__parse_zlib_header(stbi__zbuf *a)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 4438, + "column": 1, + "source_line": "static int stbi__parse_zlib_header(stbi__zbuf *a)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 4450, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__parse_zlib": { + "name": "stbi__parse_zlib", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__zbuf *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__zbuf" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__zbuf *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__zbuf" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "parse_header", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int parse_header" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int parse_header" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4481, + "column": 1, + "source_line": "static int stbi__parse_zlib(stbi__zbuf *a, int parse_header)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 4481, + "column": 1, + "source_line": "static int stbi__parse_zlib(stbi__zbuf *a, int parse_header)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 4508, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__do_zlib": { + "name": "stbi__do_zlib", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__zbuf *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__zbuf" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__zbuf *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__zbuf" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "obuf", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *obuf", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *obuf", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "olen", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int olen" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int olen" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "exp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int exp" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int exp" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "parse_header", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int parse_header" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int parse_header" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4510, + "column": 1, + "source_line": "static int stbi__do_zlib(stbi__zbuf *a, char *obuf, int olen, int exp, int parse_header)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 4510, + "column": 1, + "source_line": "static int stbi__do_zlib(stbi__zbuf *a, char *obuf, int olen, int exp, int parse_header)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 4518, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__get_chunk_header": { + "name": "stbi__get_chunk_header", + "result_type": { + "reference": "stbi__pngchunk" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4613, + "column": 1, + "source_line": "static stbi__pngchunk stbi__get_chunk_header(stbi__context *s)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 4613, + "column": 1, + "source_line": "static stbi__pngchunk stbi__get_chunk_header(stbi__context *s)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 4619, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__check_png_header": { + "name": "stbi__check_png_header", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4621, + "column": 1, + "source_line": "static int stbi__check_png_header(stbi__context *s)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 4621, + "column": 1, + "source_line": "static int stbi__check_png_header(stbi__context *s)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 4628, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__paeth": { + "name": "stbi__paeth", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4657, + "column": 1, + "source_line": "static int stbi__paeth(int a, int b, int c)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 4657, + "column": 1, + "source_line": "static int stbi__paeth(int a, int b, int c)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 4668, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__create_png_alpha_expand8": { + "name": "stbi__create_png_alpha_expand8", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "dest", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *dest", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *dest", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "src", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *src", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *src", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "reference": "stbi__uint32" + }, + "declared_type": { + "reference": "stbi__uint32" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "img_n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int img_n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int img_n" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4675, + "column": 1, + "source_line": "static void stbi__create_png_alpha_expand8(stbi_uc *dest, stbi_uc *src, stbi__uint32 x, int img_n)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 4675, + "column": 1, + "source_line": "static void stbi__create_png_alpha_expand8(stbi_uc *dest, stbi_uc *src, stbi__uint32 x, int img_n)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 4693, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__create_png_image_raw": { + "name": "stbi__create_png_image_raw", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__png *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__png" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__png *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__png" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "raw", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *raw", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *raw", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "raw_len", + "type": { + "reference": "stbi__uint32" + }, + "declared_type": { + "reference": "stbi__uint32" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "out_n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int out_n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int out_n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "reference": "stbi__uint32" + }, + "declared_type": { + "reference": "stbi__uint32" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "reference": "stbi__uint32" + }, + "declared_type": { + "reference": "stbi__uint32" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "depth", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int depth" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int depth" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "color", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int color" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int color" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4696, + "column": 1, + "source_line": "static int stbi__create_png_image_raw(stbi__png *a, stbi_uc *raw, stbi__uint32 raw_len, int out_n, stbi__uint32 x, stbi__uint32 y, int depth, int color)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 4696, + "column": 1, + "source_line": "static int stbi__create_png_image_raw(stbi__png *a, stbi_uc *raw, stbi__uint32 raw_len, int out_n, stbi__uint32 x, stbi__uint32 y, int depth, int color)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 4859, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__create_png_image": { + "name": "stbi__create_png_image", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__png *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__png" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__png *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__png" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "image_data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *image_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *image_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "image_data_len", + "type": { + "reference": "stbi__uint32" + }, + "declared_type": { + "reference": "stbi__uint32" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "out_n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int out_n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int out_n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "depth", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int depth" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int depth" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "color", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int color" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int color" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "interlaced", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int interlaced" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int interlaced" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4861, + "column": 1, + "source_line": "static int stbi__create_png_image(stbi__png *a, stbi_uc *image_data, stbi__uint32 image_data_len, int out_n, int depth, int color, int interlaced)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 4861, + "column": 1, + "source_line": "static int stbi__create_png_image(stbi__png *a, stbi_uc *image_data, stbi__uint32 image_data_len, int out_n, int depth, int color, int interlaced)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 4904, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__compute_transparency": { + "name": "stbi__compute_transparency", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "z", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__png *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__png" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__png *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__png" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "tc", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc tc[3]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc tc[3]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "3", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "out_n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int out_n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int out_n" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4906, + "column": 1, + "source_line": "static int stbi__compute_transparency(stbi__png *z, stbi_uc tc[3], int out_n)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 4906, + "column": 1, + "source_line": "static int stbi__compute_transparency(stbi__png *z, stbi_uc tc[3], int out_n)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 4929, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__compute_transparency16": { + "name": "stbi__compute_transparency16", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "z", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__png *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__png" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__png *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__png" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "tc", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__uint16 tc[3]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__uint16" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__uint16 tc[3]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "3", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "reference": "stbi__uint16" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "out_n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int out_n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int out_n" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4931, + "column": 1, + "source_line": "static int stbi__compute_transparency16(stbi__png *z, stbi__uint16 tc[3], int out_n)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 4931, + "column": 1, + "source_line": "static int stbi__compute_transparency16(stbi__png *z, stbi__uint16 tc[3], int out_n)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 4954, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__expand_png_palette": { + "name": "stbi__expand_png_palette", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__png *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__png" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__png *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__png" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "palette", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *palette", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *palette", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "pal_img_n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int pal_img_n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int pal_img_n" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4956, + "column": 1, + "source_line": "static int stbi__expand_png_palette(stbi__png *a, stbi_uc *palette, int len, int pal_img_n)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 4956, + "column": 1, + "source_line": "static int stbi__expand_png_palette(stbi__png *a, stbi_uc *palette, int len, int pal_img_n)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 4991, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__de_iphone": { + "name": "stbi__de_iphone", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "z", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__png *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__png" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__png *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__png" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 5033, + "column": 1, + "source_line": "static void stbi__de_iphone(stbi__png *z)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 5033, + "column": 1, + "source_line": "static void stbi__de_iphone(stbi__png *z)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 5074, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__parse_png_file": { + "name": "stbi__parse_png_file", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "z", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__png *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__png" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__png *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__png" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "scan", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int scan" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int scan" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "req_comp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 5078, + "column": 1, + "source_line": "static int stbi__parse_png_file(stbi__png *z, int scan, int req_comp)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 5078, + "column": 1, + "source_line": "static int stbi__parse_png_file(stbi__png *z, int scan, int req_comp)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 5261, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__do_png": { + "name": "stbi__do_png", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__png *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__png" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__png *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__png" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *n", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *n", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "req_comp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ri", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__result_info *ri", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__result_info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__result_info *ri", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__result_info" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 5263, + "column": 1, + "source_line": "static void *stbi__do_png(stbi__png *p, int *x, int *y, int *n, int req_comp, stbi__result_info *ri)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 5263, + "column": 1, + "source_line": "static void *stbi__do_png(stbi__png *p, int *x, int *y, int *n, int req_comp, stbi__result_info *ri)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 5293, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__png_info_raw": { + "name": "stbi__png_info_raw", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__png *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__png" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__png *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__png" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 5310, + "column": 1, + "source_line": "static int stbi__png_info_raw(stbi__png *p, int *x, int *y, int *comp)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 5310, + "column": 1, + "source_line": "static int stbi__png_info_raw(stbi__png *p, int *x, int *y, int *comp)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 5320, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__bmp_test_raw": { + "name": "stbi__bmp_test_raw", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 5346, + "column": 1, + "source_line": "static int stbi__bmp_test_raw(stbi__context *s)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 5346, + "column": 1, + "source_line": "static int stbi__bmp_test_raw(stbi__context *s)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 5359, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__high_bit": { + "name": "stbi__high_bit", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "z", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int z" + }, + "declared_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int z" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 5370, + "column": 1, + "source_line": "static int stbi__high_bit(unsigned int z)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 5370, + "column": 1, + "source_line": "static int stbi__high_bit(unsigned int z)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 5380, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__bitcount": { + "name": "stbi__bitcount", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int a" + }, + "declared_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int a" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 5382, + "column": 1, + "source_line": "static int stbi__bitcount(unsigned int a)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 5382, + "column": 1, + "source_line": "static int stbi__bitcount(unsigned int a)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 5390, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__shiftsigned": { + "name": "stbi__shiftsigned", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "v", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int v" + }, + "declared_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int v" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "shift", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int shift" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int shift" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "bits", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int bits" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int bits" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 5395, + "column": 1, + "source_line": "static int stbi__shiftsigned(unsigned int v, int shift, int bits)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 5395, + "column": 1, + "source_line": "static int stbi__shiftsigned(unsigned int v, int shift, int bits)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 5413, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__bmp_set_mask_defaults": { + "name": "stbi__bmp_set_mask_defaults", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__bmp_data *info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__bmp_data" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__bmp_data *info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__bmp_data" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "compress", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int compress" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int compress" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 5422, + "column": 1, + "source_line": "static int stbi__bmp_set_mask_defaults(stbi__bmp_data *info, int compress)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 5422, + "column": 1, + "source_line": "static int stbi__bmp_set_mask_defaults(stbi__bmp_data *info, int compress)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 5446, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__bmp_parse_header": { + "name": "stbi__bmp_parse_header", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__bmp_data *info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__bmp_data" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__bmp_data *info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__bmp_data" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 5448, + "column": 1, + "source_line": "static void *stbi__bmp_parse_header(stbi__context *s, stbi__bmp_data *info)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 5448, + "column": 1, + "source_line": "static void *stbi__bmp_parse_header(stbi__context *s, stbi__bmp_data *info)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 5528, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__tga_get_comp": { + "name": "stbi__tga_get_comp", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "bits_per_pixel", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int bits_per_pixel" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int bits_per_pixel" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "is_grey", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int is_grey" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int is_grey" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "is_rgb16", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int * is_rgb16", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int * is_rgb16", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 5739, + "column": 1, + "source_line": "static int stbi__tga_get_comp(int bits_per_pixel, int is_grey, int* is_rgb16)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 5739, + "column": 1, + "source_line": "static int stbi__tga_get_comp(int bits_per_pixel, int is_grey, int* is_rgb16)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 5753, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__tga_read_rgb16": { + "name": "stbi__tga_read_rgb16", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "out", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc * out", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc * out", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 5852, + "column": 1, + "source_line": "static void stbi__tga_read_rgb16(stbi__context *s, stbi_uc* out)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 5852, + "column": 1, + "source_line": "static void stbi__tga_read_rgb16(stbi__context *s, stbi_uc* out)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 5869, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__psd_decode_rle": { + "name": "stbi__psd_decode_rle", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "pixelCount", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int pixelCount" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int pixelCount" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 6088, + "column": 1, + "source_line": "static int stbi__psd_decode_rle(stbi__context *s, stbi_uc *p, int pixelCount)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 6088, + "column": 1, + "source_line": "static int stbi__psd_decode_rle(stbi__context *s, stbi_uc *p, int pixelCount)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 6124, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__pic_is4": { + "name": "stbi__pic_is4", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 6336, + "column": 1, + "source_line": "static int stbi__pic_is4(stbi__context *s,const char *str)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 6336, + "column": 1, + "source_line": "static int stbi__pic_is4(stbi__context *s,const char *str)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 6344, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__pic_test_core": { + "name": "stbi__pic_test_core", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 6346, + "column": 1, + "source_line": "static int stbi__pic_test_core(stbi__context *s)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 6346, + "column": 1, + "source_line": "static int stbi__pic_test_core(stbi__context *s)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 6360, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__readval": { + "name": "stbi__readval", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "channel", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int channel" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int channel" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dest", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *dest", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *dest", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 6367, + "column": 1, + "source_line": "static stbi_uc *stbi__readval(stbi__context *s, int channel, stbi_uc *dest)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 6367, + "column": 1, + "source_line": "static stbi_uc *stbi__readval(stbi__context *s, int channel, stbi_uc *dest)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 6379, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__copyval": { + "name": "stbi__copyval", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "channel", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int channel" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int channel" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dest", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *dest", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *dest", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "src", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stbi_uc *src", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stbi_uc *src", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 6381, + "column": 1, + "source_line": "static void stbi__copyval(int channel,stbi_uc *dest,const stbi_uc *src)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 6381, + "column": 1, + "source_line": "static void stbi__copyval(int channel,stbi_uc *dest,const stbi_uc *src)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 6388, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__pic_load_core": { + "name": "stbi__pic_load_core", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "width", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "height", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int height" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int height" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "result", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *result", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *result", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 6390, + "column": 1, + "source_line": "static stbi_uc *stbi__pic_load_core(stbi__context *s,int width,int height,int *comp, stbi_uc *result)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 6390, + "column": 1, + "source_line": "static stbi_uc *stbi__pic_load_core(stbi__context *s,int width,int height,int *comp, stbi_uc *result)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 6498, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__gif_test_raw": { + "name": "stbi__gif_test_raw", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 6580, + "column": 1, + "source_line": "static int stbi__gif_test_raw(stbi__context *s)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 6580, + "column": 1, + "source_line": "static int stbi__gif_test_raw(stbi__context *s)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 6588, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__gif_parse_colortable": { + "name": "stbi__gif_parse_colortable", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "pal", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc pal[256][4]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "4", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc pal[256][4]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "256", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "4", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "num_entries", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_entries" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_entries" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "transp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int transp" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int transp" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 6597, + "column": 1, + "source_line": "static void stbi__gif_parse_colortable(stbi__context *s, stbi_uc pal[256][4], int num_entries, int transp)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 6597, + "column": 1, + "source_line": "static void stbi__gif_parse_colortable(stbi__context *s, stbi_uc pal[256][4], int num_entries, int transp)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 6606, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__gif_header": { + "name": "stbi__gif_header", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "g", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__gif *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__gif" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__gif *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__gif" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "is_info", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int is_info" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int is_info" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 6608, + "column": 1, + "source_line": "static int stbi__gif_header(stbi__context *s, stbi__gif *g, int *comp, int is_info)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 6608, + "column": 1, + "source_line": "static int stbi__gif_header(stbi__context *s, stbi__gif *g, int *comp, int is_info)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 6637, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__gif_info_raw": { + "name": "stbi__gif_info_raw", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 6639, + "column": 1, + "source_line": "static int stbi__gif_info_raw(stbi__context *s, int *x, int *y, int *comp)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 6639, + "column": 1, + "source_line": "static int stbi__gif_info_raw(stbi__context *s, int *x, int *y, int *comp)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 6652, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__out_gif_code": { + "name": "stbi__out_gif_code", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "g", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__gif *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__gif" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__gif *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__gif" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "code", + "type": { + "reference": "stbi__uint16" + }, + "declared_type": { + "reference": "stbi__uint16" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 6654, + "column": 1, + "source_line": "static void stbi__out_gif_code(stbi__gif *g, stbi__uint16 code)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 6654, + "column": 1, + "source_line": "static void stbi__out_gif_code(stbi__gif *g, stbi__uint16 code)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 6689, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__process_gif_raster": { + "name": "stbi__process_gif_raster", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "g", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__gif *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__gif" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__gif *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__gif" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 6691, + "column": 1, + "source_line": "static stbi_uc *stbi__process_gif_raster(stbi__context *s, stbi__gif *g)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 6691, + "column": 1, + "source_line": "static stbi_uc *stbi__process_gif_raster(stbi__context *s, stbi__gif *g)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 6774, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__gif_load_next": { + "name": "stbi__gif_load_next", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "g", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__gif *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__gif" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__gif *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__gif" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "req_comp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "two_back", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *two_back", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *two_back", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 6778, + "column": 1, + "source_line": "static stbi_uc *stbi__gif_load_next(stbi__context *s, stbi__gif *g, int *comp, int req_comp, stbi_uc *two_back)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 6778, + "column": 1, + "source_line": "static stbi_uc *stbi__gif_load_next(stbi__context *s, stbi__gif *g, int *comp, int req_comp, stbi_uc *two_back)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 6950, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__load_gif_main_outofmem": { + "name": "stbi__load_gif_main_outofmem", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "parameters": [ + { + "name": "g", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__gif *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__gif" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__gif *g", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__gif" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "out", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *out", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *out", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "delays", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int **delays", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int **delays", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 6952, + "column": 1, + "source_line": "static void *stbi__load_gif_main_outofmem(stbi__gif *g, stbi_uc *out, int **delays)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 6952, + "column": 1, + "source_line": "static void *stbi__load_gif_main_outofmem(stbi__gif *g, stbi_uc *out, int **delays)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 6961, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__hdr_test_core": { + "name": "stbi__hdr_test_core", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "signature", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *signature", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *signature", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7087, + "column": 1, + "source_line": "static int stbi__hdr_test_core(stbi__context *s, const char *signature)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 7087, + "column": 1, + "source_line": "static int stbi__hdr_test_core(stbi__context *s, const char *signature)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 7095, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__hdr_gettoken": { + "name": "stbi__hdr_gettoken", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "parameters": [ + { + "name": "z", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7109, + "column": 1, + "source_line": "static char *stbi__hdr_gettoken(stbi__context *z, char *buffer)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 7109, + "column": 1, + "source_line": "static char *stbi__hdr_gettoken(stbi__context *z, char *buffer)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 7129, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__hdr_convert": { + "name": "stbi__hdr_convert", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "output", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *output", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *output", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "input", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *input", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_uc *input", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_uc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "req_comp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int req_comp" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7131, + "column": 1, + "source_line": "static void stbi__hdr_convert(float *output, stbi_uc *input, int req_comp)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 7131, + "column": 1, + "source_line": "static void stbi__hdr_convert(float *output, stbi_uc *input, int req_comp)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 7156, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__pnm_isspace": { + "name": "stbi__pnm_isspace", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "c", + "type": { + "model": "CChar", + "qualifiers": [], + "source_text": "char c" + }, + "declared_type": { + "model": "CChar", + "qualifiers": [], + "source_text": "char c" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7543, + "column": 1, + "source_line": "static int stbi__pnm_isspace(char c)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 7543, + "column": 1, + "source_line": "static int stbi__pnm_isspace(char c)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 7546, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__pnm_skip_whitespace": { + "name": "stbi__pnm_skip_whitespace", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7548, + "column": 1, + "source_line": "static void stbi__pnm_skip_whitespace(stbi__context *s, char *c)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 7548, + "column": 1, + "source_line": "static void stbi__pnm_skip_whitespace(stbi__context *s, char *c)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 7560, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__pnm_isdigit": { + "name": "stbi__pnm_isdigit", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "c", + "type": { + "model": "CChar", + "qualifiers": [], + "source_text": "char c" + }, + "declared_type": { + "model": "CChar", + "qualifiers": [], + "source_text": "char c" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7562, + "column": 1, + "source_line": "static int stbi__pnm_isdigit(char c)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 7562, + "column": 1, + "source_line": "static int stbi__pnm_isdigit(char c)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 7565, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__pnm_getinteger": { + "name": "stbi__pnm_getinteger", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7567, + "column": 1, + "source_line": "static int stbi__pnm_getinteger(stbi__context *s, char *c)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 7567, + "column": 1, + "source_line": "static int stbi__pnm_getinteger(stbi__context *s, char *c)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 7579, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__info_main": { + "name": "stbi__info_main", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *comp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7632, + "column": 1, + "source_line": "static int stbi__info_main(stbi__context *s, int *x, int *y, int *comp)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 7632, + "column": 1, + "source_line": "static int stbi__info_main(stbi__context *s, int *x, int *y, int *comp)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 7672, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__is_16_main": { + "name": "stbi__is_16_main", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__context" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7674, + "column": 1, + "source_line": "static int stbi__is_16_main(stbi__context *s)" + }, + "start": { + "filename": "stb/stb_image.h", + "line": 7674, + "column": 1, + "source_line": "static int stbi__is_16_main(stbi__context *s)" + }, + "end": { + "filename": "stb/stb_image.h", + "line": 7688, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + } + }, + "structs": {}, + "unions": {}, + "enums": {}, + "typedefs": { + "stbi_uc": { + "reference": "stbi_uc" + }, + "stbi_us": { + "reference": "stbi_us" + }, + "stbi__uint16": { + "reference": "stbi__uint16" + }, + "stbi__int16": { + "reference": "stbi__int16" + }, + "stbi__uint32": { + "reference": "stbi__uint32" + }, + "stbi__int32": { + "reference": "stbi__int32" + }, + "validate_uint32": { + "reference": "validate_uint32" + }, + "stbi__context": { + "reference": "stbi__context" + }, + "stbi__result_info": { + "reference": "stbi__result_info" + }, + "stbi__huffman": { + "reference": "stbi__huffman" + }, + "stbi__jpeg": { + "reference": "stbi__jpeg" + }, + "resample_row_func": { + "reference": "resample_row_func" + }, + "stbi__resample": { + "reference": "stbi__resample" + }, + "stbi__zhuffman": { + "reference": "stbi__zhuffman" + }, + "stbi__zbuf": { + "reference": "stbi__zbuf" + }, + "stbi__pngchunk": { + "reference": "stbi__pngchunk" + }, + "stbi__png": { + "reference": "stbi__png" + }, + "stbi__bmp_data": { + "reference": "stbi__bmp_data" + }, + "stbi__pic_packet": { + "reference": "stbi__pic_packet" + }, + "stbi__gif_lzw": { + "reference": "stbi__gif_lzw" + }, + "stbi__gif": { + "reference": "stbi__gif" + } + }, + "variables": { + "stbi__vertically_flip_on_load_global": { + "name": "stbi__vertically_flip_on_load_global", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "static int stbi__vertically_flip_on_load_global" + }, + "storage": [ + "static" + ], + "initializer": { + "source_text": "0" + }, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1114, + "column": 1, + "source_line": "static int stbi__vertically_flip_on_load_global = 0;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + "stbi__l2h_gamma": { + "name": "stbi__l2h_gamma", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "static float stbi__l2h_gamma" + }, + "storage": [ + "static" + ], + "initializer": { + "source_text": "2.2f" + }, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1573, + "column": 1, + "source_line": "static float stbi__l2h_gamma=2.2f, stbi__l2h_scale=1.0f;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + "stbi__l2h_scale": { + "name": "stbi__l2h_scale", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "static float stbi__l2h_scale" + }, + "storage": [ + "static" + ], + "initializer": { + "source_text": "1.0f" + }, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1573, + "column": 1, + "source_line": "static float stbi__l2h_gamma=2.2f, stbi__l2h_scale=1.0f;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + "stbi__h2l_gamma_i": { + "name": "stbi__h2l_gamma_i", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "static float stbi__h2l_gamma_i" + }, + "storage": [ + "static" + ], + "initializer": { + "source_text": "1.0f/2.2f" + }, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1579, + "column": 1, + "source_line": "static float stbi__h2l_gamma_i=1.0f/2.2f, stbi__h2l_scale_i=1.0f;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + "stbi__h2l_scale_i": { + "name": "stbi__h2l_scale_i", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "static float stbi__h2l_scale_i" + }, + "storage": [ + "static" + ], + "initializer": { + "source_text": "1.0f" + }, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1579, + "column": 1, + "source_line": "static float stbi__h2l_gamma_i=1.0f/2.2f, stbi__h2l_scale_i=1.0f;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + "stbi__unpremultiply_on_load_global": { + "name": "stbi__unpremultiply_on_load_global", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "static int stbi__unpremultiply_on_load_global" + }, + "storage": [ + "static" + ], + "initializer": { + "source_text": "0" + }, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 4993, + "column": 1, + "source_line": "static int stbi__unpremultiply_on_load_global = 0;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + "stbi__de_iphone_flag_global": { + "name": "stbi__de_iphone_flag_global", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "static int stbi__de_iphone_flag_global" + }, + "storage": [ + "static" + ], + "initializer": { + "source_text": "0" + }, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 4994, + "column": 1, + "source_line": "static int stbi__de_iphone_flag_global = 0;" + }, + "callback_policy": null, + "declaration_locations": [] + } + }, + "macros": { + "STBI_INCLUDE_STB_IMAGE_H": { + "name": "STBI_INCLUDE_STB_IMAGE_H", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 130, + "column": 1, + "source_line": "#define STBI_INCLUDE_STB_IMAGE_H" + } + }, + "STBI_VERSION": { + "name": "STBI_VERSION", + "value": "1", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 374, + "column": 1, + "source_line": "#define STBI_VERSION 1" + } + }, + "STBIDEF": { + "name": "STBIDEF", + "value": "extern", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 398, + "column": 1, + "source_line": "#define STBIDEF extern" + } + }, + "STBI_NO_JPEG": { + "name": "STBI_NO_JPEG", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 554, + "column": 4, + "source_line": " #define STBI_NO_JPEG" + } + }, + "STBI_NO_PNG": { + "name": "STBI_NO_PNG", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 557, + "column": 4, + "source_line": " #define STBI_NO_PNG" + } + }, + "STBI_NO_BMP": { + "name": "STBI_NO_BMP", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 560, + "column": 4, + "source_line": " #define STBI_NO_BMP" + } + }, + "STBI_NO_PSD": { + "name": "STBI_NO_PSD", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 563, + "column": 4, + "source_line": " #define STBI_NO_PSD" + } + }, + "STBI_NO_TGA": { + "name": "STBI_NO_TGA", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 566, + "column": 4, + "source_line": " #define STBI_NO_TGA" + } + }, + "STBI_NO_GIF": { + "name": "STBI_NO_GIF", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 569, + "column": 4, + "source_line": " #define STBI_NO_GIF" + } + }, + "STBI_NO_HDR": { + "name": "STBI_NO_HDR", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 572, + "column": 4, + "source_line": " #define STBI_NO_HDR" + } + }, + "STBI_NO_PIC": { + "name": "STBI_NO_PIC", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 575, + "column": 4, + "source_line": " #define STBI_NO_PIC" + } + }, + "STBI_NO_PNM": { + "name": "STBI_NO_PNM", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 578, + "column": 4, + "source_line": " #define STBI_NO_PNM" + } + }, + "STBI_NO_ZLIB": { + "name": "STBI_NO_ZLIB", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 583, + "column": 1, + "source_line": "#define STBI_NO_ZLIB" + } + }, + "STBI_ASSERT": { + "name": "STBI_ASSERT", + "value": "assert(x)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 603, + "column": 1, + "source_line": "#define STBI_ASSERT(x) assert(x)" + } + }, + "STBI_EXTERN": { + "name": "STBI_EXTERN", + "value": "extern", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 609, + "column": 1, + "source_line": "#define STBI_EXTERN extern" + } + }, + "stbi_inline": { + "name": "stbi_inline", + "value": "__forceinline", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 620, + "column": 4, + "source_line": " #define stbi_inline __forceinline" + } + }, + "STBI_THREAD_LOCAL": { + "name": "STBI_THREAD_LOCAL", + "value": "__thread", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 636, + "column": 9, + "source_line": " #define STBI_THREAD_LOCAL __thread" + } + }, + "STBI_NOTUSED": { + "name": "STBI_NOTUSED", + "value": "(void)sizeof(v)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 660, + "column": 1, + "source_line": "#define STBI_NOTUSED(v) (void)sizeof(v)" + } + }, + "STBI_HAS_LROTL": { + "name": "STBI_HAS_LROTL", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 664, + "column": 1, + "source_line": "#define STBI_HAS_LROTL" + } + }, + "stbi_lrot": { + "name": "stbi_lrot", + "value": "(((x) << (y)) | ((x) >> (-(y) & 31)))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 670, + "column": 4, + "source_line": " #define stbi_lrot(x,y) (((x) << (y)) | ((x) >> (-(y) & 31)))" + } + }, + "STBI_MALLOC": { + "name": "STBI_MALLOC", + "value": "malloc(sz)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 682, + "column": 1, + "source_line": "#define STBI_MALLOC(sz) malloc(sz)" + } + }, + "STBI_REALLOC": { + "name": "STBI_REALLOC", + "value": "realloc(p,newsz)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 683, + "column": 1, + "source_line": "#define STBI_REALLOC(p,newsz) realloc(p,newsz)" + } + }, + "STBI_FREE": { + "name": "STBI_FREE", + "value": "free(p)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 684, + "column": 1, + "source_line": "#define STBI_FREE(p) free(p)" + } + }, + "STBI_REALLOC_SIZED": { + "name": "STBI_REALLOC_SIZED", + "value": "STBI_REALLOC(p,newsz)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 688, + "column": 1, + "source_line": "#define STBI_REALLOC_SIZED(p,oldsz,newsz) STBI_REALLOC(p,newsz)" + } + }, + "STBI__X64_TARGET": { + "name": "STBI__X64_TARGET", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 693, + "column": 1, + "source_line": "#define STBI__X64_TARGET" + } + }, + "STBI__X86_TARGET": { + "name": "STBI__X86_TARGET", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 695, + "column": 1, + "source_line": "#define STBI__X86_TARGET" + } + }, + "STBI_NO_SIMD": { + "name": "STBI_NO_SIMD", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 721, + "column": 1, + "source_line": "#define STBI_NO_SIMD" + } + }, + "STBI_SSE2": { + "name": "STBI_SSE2", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 725, + "column": 1, + "source_line": "#define STBI_SSE2" + } + }, + "STBI_SIMD_ALIGN": { + "name": "STBI_SIMD_ALIGN", + "value": "type name", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 792, + "column": 1, + "source_line": "#define STBI_SIMD_ALIGN(type, name) type name" + } + }, + "STBI_NEON": { + "name": "STBI_NEON", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image.h", + "line": 779, + "column": 1, + "source_line": "#undef STBI_NEON" + } + }, + "STBI_MAX_DIMENSIONS": { + "name": "STBI_MAX_DIMENSIONS", + "value": "(1 << 24)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 796, + "column": 1, + "source_line": "#define STBI_MAX_DIMENSIONS (1 << 24)" + } + }, + "stbi__err": { + "name": "stbi__err", + "value": "stbi__err(x)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1095, + "column": 4, + "source_line": " #define stbi__err(x,y) stbi__err(x)" + } + }, + "stbi__errpf": { + "name": "stbi__errpf", + "value": "((float *)(size_t) (stbi__err(x,y)?NULL:NULL))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1098, + "column": 1, + "source_line": "#define stbi__errpf(x,y) ((float *)(size_t) (stbi__err(x,y)?NULL:NULL))" + } + }, + "stbi__errpuc": { + "name": "stbi__errpuc", + "value": "((unsigned char *)(size_t) (stbi__err(x,y)?NULL:NULL))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1099, + "column": 1, + "source_line": "#define stbi__errpuc(x,y) ((unsigned char *)(size_t) (stbi__err(x,y)?NULL:NULL))" + } + }, + "stbi__vertically_flip_on_load": { + "name": "stbi__vertically_flip_on_load", + "value": "(stbi__vertically_flip_on_load_set ? stbi__vertically_flip_on_load_local : stbi__vertically_flip_on_load_global)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1132, + "column": 1, + "source_line": "#define stbi__vertically_flip_on_load (stbi__vertically_flip_on_load_set \\" + } + }, + "STBI__BYTECAST": { + "name": "STBI__BYTECAST", + "value": "((stbi_uc) ((x) & 255))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1730, + "column": 1, + "source_line": "#define STBI__BYTECAST(x) ((stbi_uc) ((x) & 255)) // truncate int to byte without warnings" + } + }, + "STBI__COMBO": { + "name": "STBI__COMBO", + "value": "((a)*8+(b))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1830, + "column": 7, + "source_line": " #define STBI__COMBO(a,b) ((a)*8+(b))" + } + }, + "STBI__CASE": { + "name": "STBI__CASE", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1849, + "column": 7, + "source_line": " #undef STBI__CASE" + } + }, + "stbi__float2int": { + "name": "stbi__float2int", + "value": "((int) (x))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1883, + "column": 1, + "source_line": "#define stbi__float2int(x) ((int) (x))" + } + }, + "FAST_BITS": { + "name": "FAST_BITS", + "value": "9", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1936, + "column": 1, + "source_line": "#define FAST_BITS 9 // larger handles more cases; smaller stomps less cache" + } + }, + "stbi__f2f": { + "name": "stbi__f2f", + "value": "((int) (((x) * 4096 + 0.5)))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2426, + "column": 1, + "source_line": "#define stbi__f2f(x) ((int) (((x) * 4096 + 0.5)))" + } + }, + "stbi__fsh": { + "name": "stbi__fsh", + "value": "((x) * 4096)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2427, + "column": 1, + "source_line": "#define stbi__fsh(x) ((x) * 4096)" + } + }, + "STBI__IDCT_1D": { + "name": "STBI__IDCT_1D", + "value": "int t0,t1,t2,t3,p1,p2,p3,p4,p5,x0,x1,x2,x3; p2 = s2; p3 = s6; p1 = (p2+p3) * stbi__f2f(0.5411961f); t2 = p1 + p3*stbi__f2f(-1.847759065f); t3 = p1 + p2*stbi__f2f( 0.765366865f); p2 = s0; p3 = s4; t0 = stbi__fsh(p2+p3); t1 = stbi__fsh(p2-p3); x0 = t0+t3; x3 = t0-t3; x1 = t1+t2; x2 = t1-t2; t0 = s7; t1 = s5; t2 = s3; t3 = s1; p3 = t0+t2; p4 = t1+t3; p1 = t0+t3; p2 = t1+t2; p5 = (p3+p4)*stbi__f2f( 1.175875602f); t0 = t0*stbi__f2f( 0.298631336f); t1 = t1*stbi__f2f( 2.053119869f); t2 = t2*stbi__f2f( 3.072711026f); t3 = t3*stbi__f2f( 1.501321110f); p1 = p5 + p1*stbi__f2f(-0.899976223f); p2 = p5 + p2*stbi__f2f(-2.562915447f); p3 = p3*stbi__f2f(-1.961570560f); p4 = p4*stbi__f2f(-0.390180644f); t3 += p1+p4; t2 += p2+p3; t1 += p2+p4; t0 += p1+p3;", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2430, + "column": 1, + "source_line": "#define STBI__IDCT_1D(s0,s1,s2,s3,s4,s5,s6,s7) \\" + } + }, + "dct_const": { + "name": "dct_const", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2694, + "column": 1, + "source_line": "#undef dct_const" + } + }, + "dct_rot": { + "name": "dct_rot", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2695, + "column": 1, + "source_line": "#undef dct_rot" + } + }, + "dct_widen": { + "name": "dct_widen", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2906, + "column": 1, + "source_line": "#undef dct_widen" + } + }, + "dct_wadd": { + "name": "dct_wadd", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2907, + "column": 1, + "source_line": "#undef dct_wadd" + } + }, + "dct_wsub": { + "name": "dct_wsub", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2908, + "column": 1, + "source_line": "#undef dct_wsub" + } + }, + "dct_bfly32o": { + "name": "dct_bfly32o", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2909, + "column": 1, + "source_line": "#undef dct_bfly32o" + } + }, + "dct_interleave8": { + "name": "dct_interleave8", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2700, + "column": 1, + "source_line": "#undef dct_interleave8" + } + }, + "dct_interleave16": { + "name": "dct_interleave16", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2701, + "column": 1, + "source_line": "#undef dct_interleave16" + } + }, + "dct_pass": { + "name": "dct_pass", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2910, + "column": 1, + "source_line": "#undef dct_pass" + } + }, + "dct_long_mul": { + "name": "dct_long_mul", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2904, + "column": 1, + "source_line": "#undef dct_long_mul" + } + }, + "dct_long_mac": { + "name": "dct_long_mac", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2905, + "column": 1, + "source_line": "#undef dct_long_mac" + } + }, + "dct_trn16": { + "name": "dct_trn16", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2841, + "column": 1, + "source_line": "#undef dct_trn16" + } + }, + "dct_trn32": { + "name": "dct_trn32", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2842, + "column": 1, + "source_line": "#undef dct_trn32" + } + }, + "dct_trn64": { + "name": "dct_trn64", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2843, + "column": 1, + "source_line": "#undef dct_trn64" + } + }, + "dct_trn8_8": { + "name": "dct_trn8_8", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2899, + "column": 1, + "source_line": "#undef dct_trn8_8" + } + }, + "dct_trn8_16": { + "name": "dct_trn8_16", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2900, + "column": 1, + "source_line": "#undef dct_trn8_16" + } + }, + "dct_trn8_32": { + "name": "dct_trn8_32", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2901, + "column": 1, + "source_line": "#undef dct_trn8_32" + } + }, + "STBI__MARKER_none": { + "name": "STBI__MARKER_none", + "value": "0xff", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2915, + "column": 1, + "source_line": "#define STBI__MARKER_none 0xff" + } + }, + "STBI__RESTART": { + "name": "STBI__RESTART", + "value": "((x) >= 0xd0 && (x) <= 0xd7)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 2932, + "column": 1, + "source_line": "#define STBI__RESTART(x) ((x) >= 0xd0 && (x) <= 0xd7)" + } + }, + "stbi__DNL": { + "name": "stbi__DNL", + "value": "((x) == 0xdc)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 3357, + "column": 1, + "source_line": "#define stbi__DNL(x) ((x) == 0xdc)" + } + }, + "stbi__SOI": { + "name": "stbi__SOI", + "value": "((x) == 0xd8)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 3358, + "column": 1, + "source_line": "#define stbi__SOI(x) ((x) == 0xd8)" + } + }, + "stbi__EOI": { + "name": "stbi__EOI", + "value": "((x) == 0xd9)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 3359, + "column": 1, + "source_line": "#define stbi__EOI(x) ((x) == 0xd9)" + } + }, + "stbi__SOF": { + "name": "stbi__SOF", + "value": "((x) == 0xc0 || (x) == 0xc1 || (x) == 0xc2)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 3360, + "column": 1, + "source_line": "#define stbi__SOF(x) ((x) == 0xc0 || (x) == 0xc1 || (x) == 0xc2)" + } + }, + "stbi__SOS": { + "name": "stbi__SOS", + "value": "((x) == 0xda)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 3361, + "column": 1, + "source_line": "#define stbi__SOS(x) ((x) == 0xda)" + } + }, + "stbi__SOF_progressive": { + "name": "stbi__SOF_progressive", + "value": "((x) == 0xc2)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 3363, + "column": 1, + "source_line": "#define stbi__SOF_progressive(x) ((x) == 0xc2)" + } + }, + "stbi__div4": { + "name": "stbi__div4", + "value": "((stbi_uc) ((x) >> 2))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 3454, + "column": 1, + "source_line": "#define stbi__div4(x) ((stbi_uc) ((x) >> 2))" + } + }, + "stbi__div16": { + "name": "stbi__div16", + "value": "((stbi_uc) ((x) >> 4))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 3503, + "column": 1, + "source_line": "#define stbi__div16(x) ((stbi_uc) ((x) >> 4))" + } + }, + "stbi__float2fixed": { + "name": "stbi__float2fixed", + "value": "(((int) ((x) * 4096.0f + 0.5f)) << 8)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 3659, + "column": 1, + "source_line": "#define stbi__float2fixed(x) (((int) ((x) * 4096.0f + 0.5f)) << 8)" + } + }, + "STBI__ZFAST_BITS": { + "name": "STBI__ZFAST_BITS", + "value": "9", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4091, + "column": 1, + "source_line": "#define STBI__ZFAST_BITS 9 // accelerate all cases in default tables" + } + }, + "STBI__ZFAST_MASK": { + "name": "STBI__ZFAST_MASK", + "value": "((1 << STBI__ZFAST_BITS) - 1)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4092, + "column": 1, + "source_line": "#define STBI__ZFAST_MASK ((1 << STBI__ZFAST_BITS) - 1)" + } + }, + "STBI__ZNSYMS": { + "name": "STBI__ZNSYMS", + "value": "288", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4093, + "column": 1, + "source_line": "#define STBI__ZNSYMS 288 // number of symbols in literal/length alphabet" + } + }, + "stbi__unpremultiply_on_load": { + "name": "stbi__unpremultiply_on_load", + "value": "(stbi__unpremultiply_on_load_set ? stbi__unpremultiply_on_load_local : stbi__unpremultiply_on_load_global)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 5025, + "column": 1, + "source_line": "#define stbi__unpremultiply_on_load (stbi__unpremultiply_on_load_set \\" + } + }, + "stbi__de_iphone_flag": { + "name": "stbi__de_iphone_flag", + "value": "(stbi__de_iphone_flag_set ? stbi__de_iphone_flag_local : stbi__de_iphone_flag_global)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 5028, + "column": 1, + "source_line": "#define stbi__de_iphone_flag (stbi__de_iphone_flag_set \\" + } + }, + "STBI__PNG_TYPE": { + "name": "STBI__PNG_TYPE", + "value": "(((unsigned) (a) << 24) + ((unsigned) (b) << 16) + ((unsigned) (c) << 8) + (unsigned) (d))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 5076, + "column": 1, + "source_line": "#define STBI__PNG_TYPE(a,b,c,d) (((unsigned) (a) << 24) + ((unsigned) (b) << 16) + ((unsigned) (c) << 8) + (unsigned) (d))" + } + }, + "STBI__HDR_BUFLEN": { + "name": "STBI__HDR_BUFLEN", + "value": "1024", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image.h", + "line": 7108, + "column": 1, + "source_line": "#define STBI__HDR_BUFLEN 1024" + } + } + }, + "includes": { + "stb/stb_image.h:stdio.h": { + "target": "stdio.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 598, + "column": 1, + "source_line": "#include " + } + }, + "stb/stb_image.h:stdlib.h": { + "target": "stdlib.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 589, + "column": 1, + "source_line": "#include " + } + }, + "stb/stb_image.h:stdarg.h": { + "target": "stdarg.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 587, + "column": 1, + "source_line": "#include " + } + }, + "stb/stb_image.h:stddef.h": { + "target": "stddef.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 588, + "column": 1, + "source_line": "#include // ptrdiff_t on osx" + } + }, + "stb/stb_image.h:string.h": { + "target": "string.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 590, + "column": 1, + "source_line": "#include " + } + }, + "stb/stb_image.h:limits.h": { + "target": "limits.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 591, + "column": 1, + "source_line": "#include " + } + }, + "stb/stb_image.h:math.h": { + "target": "math.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 594, + "column": 1, + "source_line": "#include // ldexp, pow" + } + }, + "stb/stb_image.h:assert.h": { + "target": "assert.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 602, + "column": 1, + "source_line": "#include " + } + }, + "stb/stb_image.h:stdint.h": { + "target": "stdint.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 647, + "column": 1, + "source_line": "#include " + } + }, + "stb/stb_image.h:emmintrin.h": { + "target": "emmintrin.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 726, + "column": 1, + "source_line": "#include " + } + }, + "stb/stb_image.h:intrin.h": { + "target": "intrin.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 731, + "column": 1, + "source_line": "#include // __cpuid" + } + }, + "stb/stb_image.h:arm_neon.h": { + "target": "arm_neon.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 783, + "column": 1, + "source_line": "#include " + } + } + }, + "functions_by_file": { + "stb/stb_image.h": [ + "stbi__cpuid3", + "stbi__sse2_available", + "stbi__refill_buffer", + "stbi__start_mem", + "stbi__start_callbacks", + "stbi__stdio_read", + "stbi__stdio_skip", + "stbi__stdio_eof", + "stbi__start_file", + "stbi__rewind", + "stbi__jpeg_test", + "stbi__jpeg_load", + "stbi__jpeg_info", + "stbi__png_test", + "stbi__png_load", + "stbi__png_info", + "stbi__png_is16", + "stbi__bmp_test", + "stbi__bmp_load", + "stbi__bmp_info", + "stbi__tga_test", + "stbi__tga_load", + "stbi__tga_info", + "stbi__psd_test", + "stbi__psd_load", + "stbi__psd_info", + "stbi__psd_is16", + "stbi__hdr_test", + "stbi__hdr_load", + "stbi__hdr_info", + "stbi__pic_test", + "stbi__pic_load", + "stbi__pic_info", + "stbi__gif_test", + "stbi__gif_load", + "stbi__load_gif_main", + "stbi__gif_info", + "stbi__pnm_test", + "stbi__pnm_load", + "stbi__pnm_info", + "stbi__pnm_is16", + "stbi__malloc", + "stbi__addsizes_valid", + "stbi__mul2sizes_valid", + "stbi__mad2sizes_valid", + "stbi__mad3sizes_valid", + "stbi__mad4sizes_valid", + "stbi__malloc_mad2", + "stbi__malloc_mad3", + "stbi__malloc_mad4", + "stbi__addints_valid", + "stbi__mul2shorts_valid", + "stbi__ldr_to_hdr", + "stbi__hdr_to_ldr", + "stbi__load_main", + "stbi__convert_16_to_8", + "stbi__convert_8_to_16", + "stbi__vertical_flip", + "stbi__vertical_flip_slices", + "stbi__load_and_postprocess_8bit", + "stbi__load_and_postprocess_16bit", + "stbi__float_postprocess", + "stbi__fopen", + "stbi__loadf_main", + "stbi__skip", + "stbi__getn", + "stbi__get16be", + "stbi__get32be", + "stbi__get16le", + "stbi__get32le", + "stbi__compute_y", + "stbi__convert_format", + "stbi__compute_y_16", + "stbi__convert_format16", + "stbi__build_huffman", + "stbi__build_fast_ac", + "stbi__grow_buffer_unsafe", + "stbi__jpeg_decode_block", + "stbi__jpeg_decode_block_prog_dc", + "stbi__jpeg_decode_block_prog_ac", + "stbi__idct_block", + "stbi__idct_simd", + "stbi__get_marker", + "stbi__jpeg_reset", + "stbi__parse_entropy_coded_data", + "stbi__jpeg_dequantize", + "stbi__jpeg_finish", + "stbi__process_marker", + "stbi__process_scan_header", + "stbi__free_jpeg_components", + "stbi__process_frame_header", + "stbi__decode_jpeg_header", + "stbi__skip_jpeg_junk_at_end", + "stbi__decode_jpeg_image", + "resample_row_1", + "stbi__resample_row_v_2", + "stbi__resample_row_h_2", + "stbi__resample_row_hv_2", + "stbi__resample_row_hv_2_simd", + "stbi__resample_row_generic", + "stbi__YCbCr_to_RGB_row", + "stbi__YCbCr_to_RGB_simd", + "stbi__setup_jpeg", + "stbi__cleanup_jpeg", + "stbi__blinn_8x8", + "load_jpeg_image", + "stbi__jpeg_info_raw", + "stbi__zbuild_huffman", + "stbi__fill_bits", + "stbi__zhuffman_decode_slowpath", + "stbi__zexpand", + "stbi__parse_huffman_block", + "stbi__compute_huffman_codes", + "stbi__parse_uncompressed_block", + "stbi__parse_zlib_header", + "stbi__parse_zlib", + "stbi__do_zlib", + "stbi__get_chunk_header", + "stbi__check_png_header", + "stbi__paeth", + "stbi__create_png_alpha_expand8", + "stbi__create_png_image_raw", + "stbi__create_png_image", + "stbi__compute_transparency", + "stbi__compute_transparency16", + "stbi__expand_png_palette", + "stbi__de_iphone", + "stbi__parse_png_file", + "stbi__do_png", + "stbi__png_info_raw", + "stbi__bmp_test_raw", + "stbi__high_bit", + "stbi__bitcount", + "stbi__shiftsigned", + "stbi__bmp_set_mask_defaults", + "stbi__bmp_parse_header", + "stbi__tga_get_comp", + "stbi__tga_read_rgb16", + "stbi__psd_decode_rle", + "stbi__pic_is4", + "stbi__pic_test_core", + "stbi__readval", + "stbi__copyval", + "stbi__pic_load_core", + "stbi__gif_test_raw", + "stbi__gif_parse_colortable", + "stbi__gif_header", + "stbi__gif_info_raw", + "stbi__out_gif_code", + "stbi__process_gif_raster", + "stbi__gif_load_next", + "stbi__load_gif_main_outofmem", + "stbi__hdr_test_core", + "stbi__hdr_gettoken", + "stbi__hdr_convert", + "stbi__pnm_isspace", + "stbi__pnm_skip_whitespace", + "stbi__pnm_isdigit", + "stbi__pnm_getinteger", + "stbi__info_main", + "stbi__is_16_main" + ] + }, + "enum_constants": { + "STBI_default": { + "name": "STBI_default", + "value": "0", + "source_location": { + "filename": "stb/stb_image.h", + "line": 376, + "column": 1, + "source_line": "enum" + } + }, + "STBI_grey": { + "name": "STBI_grey", + "value": "1", + "source_location": { + "filename": "stb/stb_image.h", + "line": 376, + "column": 1, + "source_line": "enum" + } + }, + "STBI_grey_alpha": { + "name": "STBI_grey_alpha", + "value": "2", + "source_location": { + "filename": "stb/stb_image.h", + "line": 376, + "column": 1, + "source_line": "enum" + } + }, + "STBI_rgb": { + "name": "STBI_rgb", + "value": "3", + "source_location": { + "filename": "stb/stb_image.h", + "line": 376, + "column": 1, + "source_line": "enum" + } + }, + "STBI_rgb_alpha": { + "name": "STBI_rgb_alpha", + "value": "4", + "source_location": { + "filename": "stb/stb_image.h", + "line": 376, + "column": 1, + "source_line": "enum" + } + }, + "STBI_ORDER_RGB": { + "name": "STBI_ORDER_RGB", + "value": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 895, + "column": 1, + "source_line": "enum" + } + }, + "STBI_ORDER_BGR": { + "name": "STBI_ORDER_BGR", + "value": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 895, + "column": 1, + "source_line": "enum" + } + }, + "STBI__SCAN_load": { + "name": "STBI__SCAN_load", + "value": "0", + "source_location": { + "filename": "stb/stb_image.h", + "line": 1590, + "column": 1, + "source_line": "enum" + } + }, + "STBI__SCAN_type": { + "name": "STBI__SCAN_type", + "value": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1590, + "column": 1, + "source_line": "enum" + } + }, + "STBI__SCAN_header": { + "name": "STBI__SCAN_header", + "value": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 1590, + "column": 1, + "source_line": "enum" + } + }, + "STBI__F_none": { + "name": "STBI__F_none", + "value": "0", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4638, + "column": 1, + "source_line": "enum {" + } + }, + "STBI__F_sub": { + "name": "STBI__F_sub", + "value": "1", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4638, + "column": 1, + "source_line": "enum {" + } + }, + "STBI__F_up": { + "name": "STBI__F_up", + "value": "2", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4638, + "column": 1, + "source_line": "enum {" + } + }, + "STBI__F_avg": { + "name": "STBI__F_avg", + "value": "3", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4638, + "column": 1, + "source_line": "enum {" + } + }, + "STBI__F_paeth": { + "name": "STBI__F_paeth", + "value": "4", + "source_location": { + "filename": "stb/stb_image.h", + "line": 4638, + "column": 1, + "source_line": "enum {" + } + }, + "STBI__F_avg_first": { + "name": "STBI__F_avg_first", + "value": null, + "source_location": { + "filename": "stb/stb_image.h", + "line": 4638, + "column": 1, + "source_line": "enum {" + } + } + }, + "include_graph": { + "stb/stb_image.h": [] + }, + "system_includes": { + "stb/stb_image.h": [ + "arm_neon.h", + "assert.h", + "emmintrin.h", + "intrin.h", + "limits.h", + "math.h", + "stdarg.h", + "stddef.h", + "stdint.h", + "stdio.h", + "stdlib.h", + "string.h" + ] + }, + "unresolved_includes": { + "stb/stb_image.h": [] + }, + "header_source_pairs": { + "stb/stb_image.h": [] + }, + "diagnostics": [ + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBI_ASSERT' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 603, + "column": 1, + "source_line": "#define STBI_ASSERT(x) assert(x)" + }, + "unit_kind": "macro", + "unit_name": "STBI_ASSERT" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBI_NOTUSED' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 658, + "column": 1, + "source_line": "#define STBI_NOTUSED(v) (void)(v)" + }, + "unit_kind": "macro", + "unit_name": "STBI_NOTUSED" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBI_NOTUSED' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 660, + "column": 1, + "source_line": "#define STBI_NOTUSED(v) (void)sizeof(v)" + }, + "unit_kind": "macro", + "unit_name": "STBI_NOTUSED" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbi_lrot' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 668, + "column": 4, + "source_line": " #define stbi_lrot(x,y) _lrotl(x,y)" + }, + "unit_kind": "macro", + "unit_name": "stbi_lrot" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbi_lrot' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 670, + "column": 4, + "source_line": " #define stbi_lrot(x,y) (((x) << (y)) | ((x) >> (-(y) & 31)))" + }, + "unit_kind": "macro", + "unit_name": "stbi_lrot" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBI_MALLOC' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 682, + "column": 1, + "source_line": "#define STBI_MALLOC(sz) malloc(sz)" + }, + "unit_kind": "macro", + "unit_name": "STBI_MALLOC" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBI_REALLOC' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 683, + "column": 1, + "source_line": "#define STBI_REALLOC(p,newsz) realloc(p,newsz)" + }, + "unit_kind": "macro", + "unit_name": "STBI_REALLOC" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBI_FREE' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 684, + "column": 1, + "source_line": "#define STBI_FREE(p) free(p)" + }, + "unit_kind": "macro", + "unit_name": "STBI_FREE" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBI_REALLOC_SIZED' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 688, + "column": 1, + "source_line": "#define STBI_REALLOC_SIZED(p,oldsz,newsz) STBI_REALLOC(p,newsz)" + }, + "unit_kind": "macro", + "unit_name": "STBI_REALLOC_SIZED" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBI_SIMD_ALIGN' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 751, + "column": 1, + "source_line": "#define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name" + }, + "unit_kind": "macro", + "unit_name": "STBI_SIMD_ALIGN" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBI_SIMD_ALIGN' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 762, + "column": 1, + "source_line": "#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16)))" + }, + "unit_kind": "macro", + "unit_name": "STBI_SIMD_ALIGN" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBI_SIMD_ALIGN' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 785, + "column": 1, + "source_line": "#define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name" + }, + "unit_kind": "macro", + "unit_name": "STBI_SIMD_ALIGN" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBI_SIMD_ALIGN' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 787, + "column": 1, + "source_line": "#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16)))" + }, + "unit_kind": "macro", + "unit_name": "STBI_SIMD_ALIGN" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBI_SIMD_ALIGN' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 792, + "column": 1, + "source_line": "#define STBI_SIMD_ALIGN(type, name) type name" + }, + "unit_kind": "macro", + "unit_name": "STBI_SIMD_ALIGN" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbi__err' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1091, + "column": 4, + "source_line": " #define stbi__err(x,y) 0" + }, + "unit_kind": "macro", + "unit_name": "stbi__err" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbi__err' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1093, + "column": 4, + "source_line": " #define stbi__err(x,y) stbi__err(y)" + }, + "unit_kind": "macro", + "unit_name": "stbi__err" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbi__err' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1095, + "column": 4, + "source_line": " #define stbi__err(x,y) stbi__err(x)" + }, + "unit_kind": "macro", + "unit_name": "stbi__err" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbi__errpf' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1098, + "column": 1, + "source_line": "#define stbi__errpf(x,y) ((float *)(size_t) (stbi__err(x,y)?NULL:NULL))" + }, + "unit_kind": "macro", + "unit_name": "stbi__errpf" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbi__errpuc' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1099, + "column": 1, + "source_line": "#define stbi__errpuc(x,y) ((unsigned char *)(size_t) (stbi__err(x,y)?NULL:NULL))" + }, + "unit_kind": "macro", + "unit_name": "stbi__errpuc" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBI__BYTECAST' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1730, + "column": 1, + "source_line": "#define STBI__BYTECAST(x) ((stbi_uc) ((x) & 255)) // truncate int to byte without warnings" + }, + "unit_kind": "macro", + "unit_name": "STBI__BYTECAST" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBI__COMBO' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1773, + "column": 7, + "source_line": " #define STBI__COMBO(a,b) ((a)*8+(b))" + }, + "unit_kind": "macro", + "unit_name": "STBI__COMBO" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBI__CASE' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1774, + "column": 7, + "source_line": " #define STBI__CASE(a,b) case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b)" + }, + "unit_kind": "macro", + "unit_name": "STBI__CASE" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBI__COMBO' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1830, + "column": 7, + "source_line": " #define STBI__COMBO(a,b) ((a)*8+(b))" + }, + "unit_kind": "macro", + "unit_name": "STBI__COMBO" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBI__CASE' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1831, + "column": 7, + "source_line": " #define STBI__CASE(a,b) case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b)" + }, + "unit_kind": "macro", + "unit_name": "STBI__CASE" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbi__float2int' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1883, + "column": 1, + "source_line": "#define stbi__float2int(x) ((int) (x))" + }, + "unit_kind": "macro", + "unit_name": "stbi__float2int" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbi__f2f' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 2426, + "column": 1, + "source_line": "#define stbi__f2f(x) ((int) (((x) * 4096 + 0.5)))" + }, + "unit_kind": "macro", + "unit_name": "stbi__f2f" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbi__fsh' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 2427, + "column": 1, + "source_line": "#define stbi__fsh(x) ((x) * 4096)" + }, + "unit_kind": "macro", + "unit_name": "stbi__fsh" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBI__IDCT_1D' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 2430, + "column": 1, + "source_line": "#define STBI__IDCT_1D(s0,s1,s2,s3,s4,s5,s6,s7) \\" + }, + "unit_kind": "macro", + "unit_name": "STBI__IDCT_1D" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'dct_const' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 2537, + "column": 4, + "source_line": " #define dct_const(x,y) _mm_setr_epi16((x),(y),(x),(y),(x),(y),(x),(y))" + }, + "unit_kind": "macro", + "unit_name": "dct_const" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'dct_rot' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 2541, + "column": 4, + "source_line": " #define dct_rot(out0,out1, x,y,c0,c1) \\" + }, + "unit_kind": "macro", + "unit_name": "dct_rot" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'dct_widen' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 2550, + "column": 4, + "source_line": " #define dct_widen(out, in) \\" + }, + "unit_kind": "macro", + "unit_name": "dct_widen" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'dct_wadd' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 2555, + "column": 4, + "source_line": " #define dct_wadd(out, a, b) \\" + }, + "unit_kind": "macro", + "unit_name": "dct_wadd" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'dct_wsub' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 2560, + "column": 4, + "source_line": " #define dct_wsub(out, a, b) \\" + }, + "unit_kind": "macro", + "unit_name": "dct_wsub" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'dct_bfly32o' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 2565, + "column": 4, + "source_line": " #define dct_bfly32o(out0, out1, a,b,bias,s) \\" + }, + "unit_kind": "macro", + "unit_name": "dct_bfly32o" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'dct_interleave8' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 2576, + "column": 4, + "source_line": " #define dct_interleave8(a, b) \\" + }, + "unit_kind": "macro", + "unit_name": "dct_interleave8" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'dct_interleave16' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 2582, + "column": 4, + "source_line": " #define dct_interleave16(a, b) \\" + }, + "unit_kind": "macro", + "unit_name": "dct_interleave16" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'dct_pass' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 2587, + "column": 4, + "source_line": " #define dct_pass(bias,shift) \\" + }, + "unit_kind": "macro", + "unit_name": "dct_pass" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'dct_long_mul' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 2728, + "column": 1, + "source_line": "#define dct_long_mul(out, inq, coeff) \\" + }, + "unit_kind": "macro", + "unit_name": "dct_long_mul" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'dct_long_mac' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 2732, + "column": 1, + "source_line": "#define dct_long_mac(out, acc, inq, coeff) \\" + }, + "unit_kind": "macro", + "unit_name": "dct_long_mac" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'dct_widen' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 2736, + "column": 1, + "source_line": "#define dct_widen(out, inq) \\" + }, + "unit_kind": "macro", + "unit_name": "dct_widen" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'dct_wadd' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 2741, + "column": 1, + "source_line": "#define dct_wadd(out, a, b) \\" + }, + "unit_kind": "macro", + "unit_name": "dct_wadd" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'dct_wsub' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 2746, + "column": 1, + "source_line": "#define dct_wsub(out, a, b) \\" + }, + "unit_kind": "macro", + "unit_name": "dct_wsub" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'dct_bfly32o' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 2751, + "column": 1, + "source_line": "#define dct_bfly32o(out0,out1, a,b,shiftop,s) \\" + }, + "unit_kind": "macro", + "unit_name": "dct_bfly32o" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'dct_pass' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 2759, + "column": 1, + "source_line": "#define dct_pass(shiftop, shift) \\" + }, + "unit_kind": "macro", + "unit_name": "dct_pass" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'dct_trn16' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 2819, + "column": 1, + "source_line": "#define dct_trn16(x, y) { int16x8x2_t t = vtrnq_s16(x, y); x = t.val[0]; y = t.val[1]; }" + }, + "unit_kind": "macro", + "unit_name": "dct_trn16" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'dct_trn32' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 2820, + "column": 1, + "source_line": "#define dct_trn32(x, y) { int32x4x2_t t = vtrnq_s32(vreinterpretq_s32_s16(x), vreinterpretq_s32_s16(y)); x = vreinterpretq_s16_s32(t.val[0]); y = vreinterpretq_s16_s32(t.val[1]); }" + }, + "unit_kind": "macro", + "unit_name": "dct_trn32" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'dct_trn64' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 2821, + "column": 1, + "source_line": "#define dct_trn64(x, y) { int16x8_t x0 = x; int16x8_t y0 = y; x = vcombine_s16(vget_low_s16(x0), vget_low_s16(y0)); y = vcombine_s16(vget_high_s16(x0), vget_high_s16(y0)); }" + }, + "unit_kind": "macro", + "unit_name": "dct_trn64" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'dct_trn8_8' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 2864, + "column": 1, + "source_line": "#define dct_trn8_8(x, y) { uint8x8x2_t t = vtrn_u8(x, y); x = t.val[0]; y = t.val[1]; }" + }, + "unit_kind": "macro", + "unit_name": "dct_trn8_8" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'dct_trn8_16' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 2865, + "column": 1, + "source_line": "#define dct_trn8_16(x, y) { uint16x4x2_t t = vtrn_u16(vreinterpret_u16_u8(x), vreinterpret_u16_u8(y)); x = vreinterpret_u8_u16(t.val[0]); y = vreinterpret_u8_u16(t.val[1]); }" + }, + "unit_kind": "macro", + "unit_name": "dct_trn8_16" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'dct_trn8_32' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 2866, + "column": 1, + "source_line": "#define dct_trn8_32(x, y) { uint32x2x2_t t = vtrn_u32(vreinterpret_u32_u8(x), vreinterpret_u32_u8(y)); x = vreinterpret_u8_u32(t.val[0]); y = vreinterpret_u8_u32(t.val[1]); }" + }, + "unit_kind": "macro", + "unit_name": "dct_trn8_32" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBI__RESTART' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 2932, + "column": 1, + "source_line": "#define STBI__RESTART(x) ((x) >= 0xd0 && (x) <= 0xd7)" + }, + "unit_kind": "macro", + "unit_name": "STBI__RESTART" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbi__DNL' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 3357, + "column": 1, + "source_line": "#define stbi__DNL(x) ((x) == 0xdc)" + }, + "unit_kind": "macro", + "unit_name": "stbi__DNL" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbi__SOI' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 3358, + "column": 1, + "source_line": "#define stbi__SOI(x) ((x) == 0xd8)" + }, + "unit_kind": "macro", + "unit_name": "stbi__SOI" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbi__EOI' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 3359, + "column": 1, + "source_line": "#define stbi__EOI(x) ((x) == 0xd9)" + }, + "unit_kind": "macro", + "unit_name": "stbi__EOI" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbi__SOF' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 3360, + "column": 1, + "source_line": "#define stbi__SOF(x) ((x) == 0xc0 || (x) == 0xc1 || (x) == 0xc2)" + }, + "unit_kind": "macro", + "unit_name": "stbi__SOF" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbi__SOS' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 3361, + "column": 1, + "source_line": "#define stbi__SOS(x) ((x) == 0xda)" + }, + "unit_kind": "macro", + "unit_name": "stbi__SOS" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbi__SOF_progressive' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 3363, + "column": 1, + "source_line": "#define stbi__SOF_progressive(x) ((x) == 0xc2)" + }, + "unit_kind": "macro", + "unit_name": "stbi__SOF_progressive" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbi__div4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 3454, + "column": 1, + "source_line": "#define stbi__div4(x) ((stbi_uc) ((x) >> 2))" + }, + "unit_kind": "macro", + "unit_name": "stbi__div4" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbi__div16' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 3503, + "column": 1, + "source_line": "#define stbi__div16(x) ((stbi_uc) ((x) >> 4))" + }, + "unit_kind": "macro", + "unit_name": "stbi__div16" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbi__float2fixed' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 3659, + "column": 1, + "source_line": "#define stbi__float2fixed(x) (((int) ((x) * 4096.0f + 0.5f)) << 8)" + }, + "unit_kind": "macro", + "unit_name": "stbi__float2fixed" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBI__PNG_TYPE' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 5076, + "column": 1, + "source_line": "#define STBI__PNG_TYPE(a,b,c,d) (((unsigned) (a) << 24) + ((unsigned) (b) << 16) + ((unsigned) (c) << 8) + (unsigned) (d))" + }, + "unit_kind": "macro", + "unit_name": "STBI__PNG_TYPE" + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '\"C\"'.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 391, + "column": 1, + "source_line": "extern \"C\" {" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 870, + "column": 1, + "source_line": "static stbi_io_callbacks stbi__stdio_callbacks =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBI_THREAD_LOCAL'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 966, + "column": 1, + "source_line": "static" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBI_THREAD_LOCAL" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 972, + "column": 1, + "source_line": "STBIDEF const char *stbi_failure_reason(void)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'stbi__err'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 978, + "column": 1, + "source_line": "static int stbi__err(const char *str)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbi__err" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1101, + "column": 1, + "source_line": "STBIDEF void stbi_image_free(void *retval_from_stbi_load)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1116, + "column": 1, + "source_line": "STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBI_THREAD_LOCAL'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1124, + "column": 1, + "source_line": "static STBI_THREAD_LOCAL int stbi__vertically_flip_on_load_local, stbi__vertically_flip_on_load_set;" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBI_THREAD_LOCAL" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1126, + "column": 1, + "source_line": "STBIDEF void stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_flip)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBI_EXTERN'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1326, + "column": 1, + "source_line": "STBI_EXTERN __declspec(dllimport) int __stdcall MultiByteToWideChar(unsigned int cp, unsigned long flags, const char *str, int cbmb, wchar_t *widestr, int cchwide);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBI_EXTERN" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBI_EXTERN'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1327, + "column": 1, + "source_line": "STBI_EXTERN __declspec(dllimport) int __stdcall WideCharToMultiByte(unsigned int cp, unsigned long flags, const wchar_t *widestr, int cchwide, char *str, int cbmb, const char *defchar, int *used_default);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBI_EXTERN" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1331, + "column": 1, + "source_line": "STBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1366, + "column": 1, + "source_line": "STBIDEF stbi_uc *stbi_load(char const *filename, int *x, int *y, int *comp, int req_comp)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1376, + "column": 1, + "source_line": "STBIDEF stbi_uc *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1389, + "column": 1, + "source_line": "STBIDEF stbi__uint16 *stbi_load_from_file_16(FILE *f, int *x, int *y, int *comp, int req_comp)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1402, + "column": 1, + "source_line": "STBIDEF stbi_us *stbi_load_16(char const *filename, int *x, int *y, int *comp, int req_comp)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1415, + "column": 1, + "source_line": "STBIDEF stbi_us *stbi_load_16_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1422, + "column": 1, + "source_line": "STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1429, + "column": 1, + "source_line": "STBIDEF stbi_uc *stbi_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1436, + "column": 1, + "source_line": "STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1444, + "column": 1, + "source_line": "STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1478, + "column": 1, + "source_line": "STBIDEF float *stbi_loadf_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1485, + "column": 1, + "source_line": "STBIDEF float *stbi_loadf_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1493, + "column": 1, + "source_line": "STBIDEF float *stbi_loadf(char const *filename, int *x, int *y, int *comp, int req_comp)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1503, + "column": 1, + "source_line": "STBIDEF float *stbi_loadf_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1517, + "column": 1, + "source_line": "STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1531, + "column": 1, + "source_line": "STBIDEF int stbi_is_hdr (char const *filename)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1542, + "column": 1, + "source_line": "STBIDEF int stbi_is_hdr_from_file(FILE *f)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1559, + "column": 1, + "source_line": "STBIDEF int stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1575, + "column": 1, + "source_line": "STBIDEF void stbi_ldr_to_hdr_gamma(float gamma) { stbi__l2h_gamma = gamma; }" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1576, + "column": 1, + "source_line": "STBIDEF void stbi_ldr_to_hdr_scale(float scale) { stbi__l2h_scale = scale; }" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1581, + "column": 1, + "source_line": "STBIDEF void stbi_hdr_to_ldr_gamma(float gamma) { stbi__h2l_gamma_i = 1/gamma; }" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1582, + "column": 1, + "source_line": "STBIDEF void stbi_hdr_to_ldr_scale(float scale) { stbi__h2l_scale_i = 1/scale; }" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbi_inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1614, + "column": 1, + "source_line": "stbi_inline static stbi_uc stbi__get8(stbi__context *s)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbi_inline" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbi_inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1628, + "column": 1, + "source_line": "stbi_inline static int stbi__at_eof(stbi__context *s)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbi_inline" + }, + { + "code": "C_UNSUPPORTED_FIELD_DECLARATION", + "message": "Nested aggregate field definitions are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 1963, + "column": 4, + "source_line": " struct" + }, + "unit_kind": "struct_field", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 2094, + "column": 1, + "source_line": "static const stbi__uint32 stbi__bmask[17]={0,1,3,7,15,31,63,127,255,511,1023,2047,4095,8191,16383,32767,65535};" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbi_inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 2097, + "column": 1, + "source_line": "stbi_inline static int stbi__jpeg_huff_decode(stbi__jpeg *j, stbi__huffman *h)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbi_inline" + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 2149, + "column": 1, + "source_line": "static const int stbi__jbias[16] = {0,-1,-3,-7,-15,-31,-63,-127,-255,-511,-1023,-2047,-4095,-8191,-16383,-32767};" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbi_inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 2153, + "column": 1, + "source_line": "stbi_inline static int stbi__extend_receive(stbi__jpeg *j, int n)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbi_inline" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbi_inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 2169, + "column": 1, + "source_line": "stbi_inline static int stbi__jpeg_get_bits(stbi__jpeg *j, int n)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbi_inline" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbi_inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 2181, + "column": 1, + "source_line": "stbi_inline static int stbi__jpeg_get_bit(stbi__jpeg *j)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbi_inline" + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 2194, + "column": 1, + "source_line": "static const stbi_uc stbi__jpeg_dezigzag[64+15] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbi_inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 2416, + "column": 1, + "source_line": "stbi_inline static stbi_uc stbi__clamp(int x)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbi_inline" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbi_inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 4107, + "column": 1, + "source_line": "stbi_inline static int stbi__bitreverse16(int n)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbi_inline" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbi_inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 4116, + "column": 1, + "source_line": "stbi_inline static int stbi__bit_reverse(int v, int bits)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbi_inline" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbi_inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 4192, + "column": 1, + "source_line": "stbi_inline static int stbi__zeof(stbi__zbuf *z)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbi_inline" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbi_inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 4197, + "column": 1, + "source_line": "stbi_inline static stbi_uc stbi__zget8(stbi__zbuf *z)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbi_inline" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbi_inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 4214, + "column": 1, + "source_line": "stbi_inline static unsigned int stbi__zreceive(stbi__zbuf *z, int n)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbi_inline" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbi_inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 4243, + "column": 1, + "source_line": "stbi_inline static int stbi__zhuffman_decode(stbi__zbuf *a, stbi__zhuffman *z)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbi_inline" + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 4295, + "column": 1, + "source_line": "static const int stbi__zlength_base[31] = {" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 4300, + "column": 1, + "source_line": "static const int stbi__zlength_extra[31]=" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 4303, + "column": 1, + "source_line": "static const int stbi__zdist_base[32] = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193," + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 4306, + "column": 1, + "source_line": "static const int stbi__zdist_extra[32] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 4452, + "column": 1, + "source_line": "static const stbi_uc stbi__zdefault_length[STBI__ZNSYMS] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 4464, + "column": 1, + "source_line": "static const stbi_uc stbi__zdefault_distance[32] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 4520, + "column": 1, + "source_line": "STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 4536, + "column": 1, + "source_line": "STBIDEF char *stbi_zlib_decode_malloc(char const *buffer, int len, int *outlen)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 4541, + "column": 1, + "source_line": "STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 4557, + "column": 1, + "source_line": "STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, char const *ibuffer, int ilen)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 4568, + "column": 1, + "source_line": "STBIDEF char *stbi_zlib_decode_noheader_malloc(char const *buffer, int len, int *outlen)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 4584, + "column": 1, + "source_line": "STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 4648, + "column": 1, + "source_line": "static stbi_uc first_row_filter[5] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 4670, + "column": 1, + "source_line": "static const stbi_uc stbi__depth_scale_table[9] = { 0, 0xff, 0x55, 0, 0x11, 0,0,0, 0x01 };" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 4996, + "column": 1, + "source_line": "STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 5001, + "column": 1, + "source_line": "STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBI_THREAD_LOCAL'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 5010, + "column": 1, + "source_line": "static STBI_THREAD_LOCAL int stbi__unpremultiply_on_load_local, stbi__unpremultiply_on_load_set;" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBI_THREAD_LOCAL" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBI_THREAD_LOCAL'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 5011, + "column": 1, + "source_line": "static STBI_THREAD_LOCAL int stbi__de_iphone_flag_local, stbi__de_iphone_flag_set;" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBI_THREAD_LOCAL" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 5013, + "column": 1, + "source_line": "STBIDEF void stbi_set_unpremultiply_on_load_thread(int flag_true_if_should_unpremultiply)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 5019, + "column": 1, + "source_line": "STBIDEF void stbi_convert_iphone_png_to_rgb_thread(int flag_true_if_should_convert)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 7691, + "column": 1, + "source_line": "STBIDEF int stbi_info(char const *filename, int *x, int *y, int *comp)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 7701, + "column": 1, + "source_line": "STBIDEF int stbi_info_from_file(FILE *f, int *x, int *y, int *comp)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 7712, + "column": 1, + "source_line": "STBIDEF int stbi_is_16_bit(char const *filename)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 7722, + "column": 1, + "source_line": "STBIDEF int stbi_is_16_bit_from_file(FILE *f)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 7734, + "column": 1, + "source_line": "STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 7741, + "column": 1, + "source_line": "STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *c, void *user, int *x, int *y, int *comp)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 7748, + "column": 1, + "source_line": "STBIDEF int stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image.h", + "line": 7755, + "column": 1, + "source_line": "STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *c, void *user)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIDEF" + }, + { + "code": "C_CONFLICTING_TYPEDEF", + "message": "Conflicting typedef declarations for 'stbi__uint16'.", + "severity": "error", + "location": { + "filename": "stb/stb_image.h", + "line": 648, + "column": 1, + "source_line": "typedef uint16_t stbi__uint16;" + }, + "unit_kind": "typedef", + "unit_name": "stbi__uint16" + }, + { + "code": "C_CONFLICTING_TYPEDEF", + "message": "Conflicting typedef declarations for 'stbi__int16'.", + "severity": "error", + "location": { + "filename": "stb/stb_image.h", + "line": 649, + "column": 1, + "source_line": "typedef int16_t stbi__int16;" + }, + "unit_kind": "typedef", + "unit_name": "stbi__int16" + }, + { + "code": "C_CONFLICTING_TYPEDEF", + "message": "Conflicting typedef declarations for 'stbi__uint32'.", + "severity": "error", + "location": { + "filename": "stb/stb_image.h", + "line": 650, + "column": 1, + "source_line": "typedef uint32_t stbi__uint32;" + }, + "unit_kind": "typedef", + "unit_name": "stbi__uint32" + }, + { + "code": "C_CONFLICTING_TYPEDEF", + "message": "Conflicting typedef declarations for 'stbi__int32'.", + "severity": "error", + "location": { + "filename": "stb/stb_image.h", + "line": 651, + "column": 1, + "source_line": "typedef int32_t stbi__int32;" + }, + "unit_kind": "typedef", + "unit_name": "stbi__int32" + }, + { + "code": "C_DUPLICATE_FUNCTION_DEFINITION", + "message": "Duplicate definition for function 'stbi__cpuid3'.", + "severity": "error", + "location": { + "filename": "stb/stb_image.h", + "line": 739, + "column": 1, + "source_line": "static int stbi__cpuid3(void)" + }, + "unit_kind": "function", + "unit_name": "stbi__cpuid3" + }, + { + "code": "C_DUPLICATE_FUNCTION_DEFINITION", + "message": "Duplicate definition for function 'stbi__sse2_available'.", + "severity": "error", + "location": { + "filename": "stb/stb_image.h", + "line": 765, + "column": 1, + "source_line": "static int stbi__sse2_available(void)" + }, + "unit_kind": "function", + "unit_name": "stbi__sse2_available" + }, + { + "code": "C_DUPLICATE_FUNCTION_DEFINITION", + "message": "Duplicate definition for function 'stbi__idct_simd'.", + "severity": "error", + "location": { + "filename": "stb/stb_image.h", + "line": 2711, + "column": 1, + "source_line": "static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64])" + }, + "unit_kind": "function", + "unit_name": "stbi__idct_simd" + } + ] +} diff --git a/tests/parser/c/fixtures/stb/stb_image_resize2.json b/tests/parser/c/fixtures/stb/stb_image_resize2.json new file mode 100644 index 000000000..7dbaa2772 --- /dev/null +++ b/tests/parser/c/fixtures/stb/stb_image_resize2.json @@ -0,0 +1,63302 @@ +{ + "files": { + "stb/stb_image_resize2.h": { + "filename": "stb/stb_image_resize2.h", + "language": "c", + "parser_status": "partial", + "preprocessing": "raw", + "functions": [ + { + "name": "stbir_simd_memcpy", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "dest", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * dest", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * dest", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "src", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void const * src", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [ + "const" + ], + "source_text": "const void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void const * src", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [ + "const" + ], + "source_text": "const void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "bytes", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t bytes", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2592, + "column": 1, + "source_line": "static void stbir_simd_memcpy( void * dest, void const * src, size_t bytes )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 2592, + "column": 1, + "source_line": "static void stbir_simd_memcpy( void * dest, void const * src, size_t bytes )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 2680, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbir_overlapping_memcpy", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "dest", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * dest", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * dest", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "src", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void const * src", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [ + "const" + ], + "source_text": "const void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void const * src", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [ + "const" + ], + "source_text": "const void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "bytes", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t bytes", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2685, + "column": 1, + "source_line": "static void stbir_overlapping_memcpy( void * dest, void const * src, size_t bytes )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 2685, + "column": 1, + "source_line": "static void stbir_overlapping_memcpy( void * dest, void const * src, size_t bytes )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 2714, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbir__filter_trapezoid", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "scale", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float scale" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float scale" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "user_data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2890, + "column": 1, + "source_line": "static float stbir__filter_trapezoid(float x, float scale, void * user_data)" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 2890, + "column": 1, + "source_line": "static float stbir__filter_trapezoid(float x, float scale, void * user_data)" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 2909, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbir__support_trapezoid", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "scale", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float scale" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float scale" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "user_data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2911, + "column": 1, + "source_line": "static float stbir__support_trapezoid(float scale, void * user_data)" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 2911, + "column": 1, + "source_line": "static float stbir__support_trapezoid(float scale, void * user_data)" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 2915, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbir__filter_triangle", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "s", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float s" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float s" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "user_data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2917, + "column": 1, + "source_line": "static float stbir__filter_triangle(float x, float s, void * user_data)" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 2917, + "column": 1, + "source_line": "static float stbir__filter_triangle(float x, float s, void * user_data)" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 2928, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbir__filter_point", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "s", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float s" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float s" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "user_data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2930, + "column": 1, + "source_line": "static float stbir__filter_point(float x, float s, void * user_data)" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 2930, + "column": 1, + "source_line": "static float stbir__filter_point(float x, float s, void * user_data)" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 2937, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbir__filter_cubic", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "s", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float s" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float s" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "user_data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2939, + "column": 1, + "source_line": "static float stbir__filter_cubic(float x, float s, void * user_data)" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 2939, + "column": 1, + "source_line": "static float stbir__filter_cubic(float x, float s, void * user_data)" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 2952, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbir__filter_catmullrom", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "s", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float s" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float s" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "user_data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2954, + "column": 1, + "source_line": "static float stbir__filter_catmullrom(float x, float s, void * user_data)" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 2954, + "column": 1, + "source_line": "static float stbir__filter_catmullrom(float x, float s, void * user_data)" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 2967, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbir__filter_mitchell", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "s", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float s" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float s" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "user_data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2969, + "column": 1, + "source_line": "static float stbir__filter_mitchell(float x, float s, void * user_data)" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 2969, + "column": 1, + "source_line": "static float stbir__filter_mitchell(float x, float s, void * user_data)" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 2982, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbir__support_zeropoint5", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float s" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float s" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "user_data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2984, + "column": 1, + "source_line": "static float stbir__support_zeropoint5(float s, void * user_data)" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 2984, + "column": 1, + "source_line": "static float stbir__support_zeropoint5(float s, void * user_data)" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 2989, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbir__support_one", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float s" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float s" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "user_data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2991, + "column": 1, + "source_line": "static float stbir__support_one(float s, void * user_data)" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 2991, + "column": 1, + "source_line": "static float stbir__support_one(float s, void * user_data)" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 2996, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbir__support_two", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float s" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float s" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "user_data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2998, + "column": 1, + "source_line": "static float stbir__support_two(float s, void * user_data)" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 2998, + "column": 1, + "source_line": "static float stbir__support_two(float s, void * user_data)" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 3003, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbir__get_filter_pixel_width", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "support", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__support_callback * support", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbir__support_callback", + "name": "stbir__support_callback", + "type": { + "model": "CFunctionType", + "qualifiers": [], + "source_text": "typedef float stbir__support_callback( float scale, void * user_data )", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameter_types": [ + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float scale" + }, + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + } + ], + "is_variadic": false, + "prototype_style": "prototype" + }, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 569, + "column": 1, + "source_line": "typedef float stbir__support_callback( float scale, void * user_data );" + }, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__support_callback * support", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__support_callback" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "scale", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float scale" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float scale" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "user_data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 3007, + "column": 1, + "source_line": "static int stbir__get_filter_pixel_width(stbir__support_callback * support, float scale, void * user_data)" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 3007, + "column": 1, + "source_line": "static int stbir__get_filter_pixel_width(stbir__support_callback * support, float scale, void * user_data)" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 3015, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbir__get_coefficient_width", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "samp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__sampler * samp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbir__sampler", + "name": "stbir__sampler", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "contributors", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__contributors * contributors", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbir__contributors", + "name": "stbir__contributors", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "n0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n0" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 912, + "column": 3, + "source_line": " int n0; // First contributing pixel" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "n1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n1" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 913, + "column": 3, + "source_line": " int n1; // Last contributing pixel" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_image_resize2.h:910:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 910, + "column": 1, + "source_line": "typedef struct" + } + }, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 910, + "column": 1, + "source_line": "typedef struct" + }, + "declaration_locations": [] + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 943, + "column": 3, + "source_line": " stbir__contributors * contributors;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "coefficients", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * coefficients", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 944, + "column": 3, + "source_line": " float* coefficients;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "gather_prescatter_contributors", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__contributors * gather_prescatter_contributors", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__contributors" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 945, + "column": 3, + "source_line": " stbir__contributors * gather_prescatter_contributors;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "gather_prescatter_coefficients", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * gather_prescatter_coefficients", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 946, + "column": 3, + "source_line": " float * gather_prescatter_coefficients;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "scale_info", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbir__scale_info", + "name": "stbir__scale_info", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": "stbir__scale_info", + "members": [ + { + "name": "input_full_size", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int input_full_size" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 932, + "column": 3, + "source_line": " int input_full_size;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "output_sub_size", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int output_sub_size" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 933, + "column": 3, + "source_line": " int output_sub_size;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "scale", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float scale" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 934, + "column": 3, + "source_line": " float scale;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "inv_scale", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float inv_scale" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 935, + "column": 3, + "source_line": " float inv_scale;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "pixel_shift", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float pixel_shift" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 936, + "column": 3, + "source_line": " float pixel_shift; // starting shift in output pixel space (in pixels)" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "scale_is_rational", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int scale_is_rational" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 937, + "column": 3, + "source_line": " int scale_is_rational;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "scale_numerator", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbir_uint32", + "name": "stbir_uint32", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "typedef unsigned int stbir_uint32" + }, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 395, + "column": 1, + "source_line": "typedef unsigned int stbir_uint32;" + }, + "declaration_locations": [] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 938, + "column": 3, + "source_line": " stbir_uint32 scale_numerator, scale_denominator;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "scale_denominator", + "type": { + "reference": "stbir_uint32" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 938, + "column": 3, + "source_line": " stbir_uint32 scale_numerator, scale_denominator;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": null, + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 930, + "column": 1, + "source_line": "typedef struct stbir__scale_info" + } + }, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 930, + "column": 1, + "source_line": "typedef struct stbir__scale_info" + }, + "declaration_locations": [] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 947, + "column": 3, + "source_line": " stbir__scale_info scale_info;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "support", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float support" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 948, + "column": 3, + "source_line": " float support;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "filter_enum", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbir_filter", + "name": "stbir_filter", + "type": { + "model": "CEnum", + "qualifiers": [], + "source_text": "", + "name": null, + "constants": [ + { + "name": "STBIR_FILTER_DEFAULT", + "value": "0", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 503, + "column": 1, + "source_line": "typedef enum" + } + }, + { + "name": "STBIR_FILTER_BOX", + "value": "1", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 503, + "column": 1, + "source_line": "typedef enum" + } + }, + { + "name": "STBIR_FILTER_TRIANGLE", + "value": "2", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 503, + "column": 1, + "source_line": "typedef enum" + } + }, + { + "name": "STBIR_FILTER_CUBICBSPLINE", + "value": "3", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 503, + "column": 1, + "source_line": "typedef enum" + } + }, + { + "name": "STBIR_FILTER_CATMULLROM", + "value": "4", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 503, + "column": 1, + "source_line": "typedef enum" + } + }, + { + "name": "STBIR_FILTER_MITCHELL", + "value": "5", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 503, + "column": 1, + "source_line": "typedef enum" + } + }, + { + "name": "STBIR_FILTER_POINT_SAMPLE", + "value": "6", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 503, + "column": 1, + "source_line": "typedef enum" + } + }, + { + "name": "STBIR_FILTER_OTHER", + "value": "7", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 503, + "column": 1, + "source_line": "typedef enum" + } + } + ], + "anonymous_id": "enum@stb/stb_image_resize2.h:503:1", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 503, + "column": 1, + "source_line": "typedef enum" + } + }, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 503, + "column": 1, + "source_line": "typedef enum" + }, + "declaration_locations": [] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 949, + "column": 3, + "source_line": " stbir_filter filter_enum;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "filter_kernel", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__kernel_callback * filter_kernel", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbir__kernel_callback", + "name": "stbir__kernel_callback", + "type": { + "model": "CFunctionType", + "qualifiers": [], + "source_text": "typedef float stbir__kernel_callback( float x, float scale, void * user_data )", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameter_types": [ + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float scale" + }, + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + } + ], + "is_variadic": false, + "prototype_style": "prototype" + }, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 568, + "column": 1, + "source_line": "typedef float stbir__kernel_callback( float x, float scale, void * user_data ); // centered at zero" + }, + "declaration_locations": [] + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 950, + "column": 3, + "source_line": " stbir__kernel_callback * filter_kernel;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "filter_support", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__support_callback * filter_support", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__support_callback" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 951, + "column": 3, + "source_line": " stbir__support_callback * filter_support;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "edge", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbir_edge", + "name": "stbir_edge", + "type": { + "model": "CEnum", + "qualifiers": [], + "source_text": "", + "name": null, + "constants": [ + { + "name": "STBIR_EDGE_CLAMP", + "value": "0", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 495, + "column": 1, + "source_line": "typedef enum" + } + }, + { + "name": "STBIR_EDGE_REFLECT", + "value": "1", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 495, + "column": 1, + "source_line": "typedef enum" + } + }, + { + "name": "STBIR_EDGE_WRAP", + "value": "2", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 495, + "column": 1, + "source_line": "typedef enum" + } + }, + { + "name": "STBIR_EDGE_ZERO", + "value": "3", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 495, + "column": 1, + "source_line": "typedef enum" + } + } + ], + "anonymous_id": "enum@stb/stb_image_resize2.h:495:1", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 495, + "column": 1, + "source_line": "typedef enum" + } + }, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 495, + "column": 1, + "source_line": "typedef enum" + }, + "declaration_locations": [] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 952, + "column": 3, + "source_line": " stbir_edge edge;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "coefficient_width", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int coefficient_width" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 953, + "column": 3, + "source_line": " int coefficient_width;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "filter_pixel_width", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int filter_pixel_width" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 954, + "column": 3, + "source_line": " int filter_pixel_width;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "filter_pixel_margin", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int filter_pixel_margin" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 955, + "column": 3, + "source_line": " int filter_pixel_margin;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "num_contributors", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_contributors" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 956, + "column": 3, + "source_line": " int num_contributors;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "contributors_size", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int contributors_size" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 957, + "column": 3, + "source_line": " int contributors_size;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "coefficients_size", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int coefficients_size" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 958, + "column": 3, + "source_line": " int coefficients_size;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "extent_info", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbir__filter_extent_info", + "name": "stbir__filter_extent_info", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "lowest", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int lowest" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 918, + "column": 3, + "source_line": " int lowest; // First sample index for whole filter" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "highest", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int highest" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 919, + "column": 3, + "source_line": " int highest; // Last sample index for whole filter" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "widest", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int widest" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 920, + "column": 3, + "source_line": " int widest; // widest single set of samples for an output" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_image_resize2.h:916:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 916, + "column": 1, + "source_line": "typedef struct" + } + }, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 916, + "column": 1, + "source_line": "typedef struct" + }, + "declaration_locations": [] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 959, + "column": 3, + "source_line": " stbir__filter_extent_info extent_info;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "is_gather", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int is_gather" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 960, + "column": 3, + "source_line": " int is_gather; // 0 = scatter, 1 = gather with scale >= 1, 2 = gather with scale < 1" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "gather_prescatter_num_contributors", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int gather_prescatter_num_contributors" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 961, + "column": 3, + "source_line": " int gather_prescatter_num_contributors;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "gather_prescatter_coefficient_width", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int gather_prescatter_coefficient_width" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 962, + "column": 3, + "source_line": " int gather_prescatter_coefficient_width;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "gather_prescatter_contributors_size", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int gather_prescatter_contributors_size" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 963, + "column": 3, + "source_line": " int gather_prescatter_contributors_size;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "gather_prescatter_coefficients_size", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int gather_prescatter_coefficients_size" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 964, + "column": 3, + "source_line": " int gather_prescatter_coefficients_size;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_image_resize2.h:941:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 941, + "column": 1, + "source_line": "typedef struct" + } + }, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 941, + "column": 1, + "source_line": "typedef struct" + }, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__sampler * samp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__sampler" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "is_gather", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int is_gather" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int is_gather" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "user_data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 3019, + "column": 1, + "source_line": "static int stbir__get_coefficient_width(stbir__sampler * samp, int is_gather, void * user_data)" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 3019, + "column": 1, + "source_line": "static int stbir__get_coefficient_width(stbir__sampler * samp, int is_gather, void * user_data)" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 3036, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbir__get_contributors", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "samp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__sampler * samp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__sampler" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__sampler * samp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__sampler" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "is_gather", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int is_gather" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int is_gather" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 3038, + "column": 1, + "source_line": "static int stbir__get_contributors(stbir__sampler * samp, int is_gather)" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 3038, + "column": 1, + "source_line": "static int stbir__get_contributors(stbir__sampler * samp, int is_gather)" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 3044, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbir__edge_zero_full", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "max", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int max" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int max" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 3046, + "column": 1, + "source_line": "static int stbir__edge_zero_full( int n, int max )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 3046, + "column": 1, + "source_line": "static int stbir__edge_zero_full( int n, int max )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 3051, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbir__edge_clamp_full", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "max", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int max" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int max" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 3053, + "column": 1, + "source_line": "static int stbir__edge_clamp_full( int n, int max )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 3053, + "column": 1, + "source_line": "static int stbir__edge_clamp_full( int n, int max )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 3062, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbir__edge_reflect_full", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "max", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int max" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int max" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 3064, + "column": 1, + "source_line": "static int stbir__edge_reflect_full( int n, int max )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 3064, + "column": 1, + "source_line": "static int stbir__edge_reflect_full( int n, int max )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 3084, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbir__edge_wrap_full", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "max", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int max" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int max" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 3086, + "column": 1, + "source_line": "static int stbir__edge_wrap_full( int n, int max )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 3086, + "column": 1, + "source_line": "static int stbir__edge_wrap_full( int n, int max )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 3099, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbir__get_extents", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "samp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__sampler * samp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__sampler" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__sampler * samp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__sampler" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "scanline_extents", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__extents * scanline_extents", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbir__extents", + "name": "stbir__extents", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "conservative", + "type": { + "reference": "stbir__contributors" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 969, + "column": 3, + "source_line": " stbir__contributors conservative;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "edge_sizes", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int edge_sizes[2]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "2", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 970, + "column": 3, + "source_line": " int edge_sizes[2]; // this can be less than filter_pixel_margin, if the filter and scaling falls off" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "spans", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__span spans[2]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "2", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbir__span", + "name": "stbir__span", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "n0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n0" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 925, + "column": 3, + "source_line": " int n0; // First pixel of decode buffer to write to" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "n1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n1" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 926, + "column": 3, + "source_line": " int n1; // Last pixel of decode that will be written to" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "pixel_offset_for_input", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int pixel_offset_for_input" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 927, + "column": 3, + "source_line": " int pixel_offset_for_input; // Pixel offset into input_scanline" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_image_resize2.h:923:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 923, + "column": 1, + "source_line": "typedef struct" + } + }, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 923, + "column": 1, + "source_line": "typedef struct" + }, + "declaration_locations": [] + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 971, + "column": 3, + "source_line": " stbir__span spans[2]; // can be two spans, if doing input subrect with clamp mode WRAP" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_image_resize2.h:967:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 967, + "column": 1, + "source_line": "typedef struct" + } + }, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 967, + "column": 1, + "source_line": "typedef struct" + }, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__extents * scanline_extents", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__extents" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 3121, + "column": 1, + "source_line": "static void stbir__get_extents( stbir__sampler * samp, stbir__extents * scanline_extents )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 3121, + "column": 1, + "source_line": "static void stbir__get_extents( stbir__sampler * samp, stbir__extents * scanline_extents )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 3291, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbir__calculate_in_pixel_range", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "first_pixel", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int * first_pixel", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int * first_pixel", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "last_pixel", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int * last_pixel", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int * last_pixel", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "out_pixel_center", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float out_pixel_center" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float out_pixel_center" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "out_filter_radius", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float out_filter_radius" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float out_filter_radius" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "inv_scale", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float inv_scale" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float inv_scale" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "out_shift", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float out_shift" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float out_shift" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "input_size", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int input_size" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int input_size" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "edge", + "type": { + "reference": "stbir_edge" + }, + "declared_type": { + "reference": "stbir_edge" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 3293, + "column": 1, + "source_line": "static void stbir__calculate_in_pixel_range( int * first_pixel, int * last_pixel, float out_pixel_center, float out_filter_radius, float inv_scale, float out_shift, int input_size, stbir_edge edge )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 3293, + "column": 1, + "source_line": "static void stbir__calculate_in_pixel_range( int * first_pixel, int * last_pixel, float out_pixel_center, float out_filter_radius, float inv_scale, float out_shift, int input_size, stbir_edge edge )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 3316, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbir__calculate_coefficients_for_gather_upsample", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "out_filter_radius", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float out_filter_radius" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float out_filter_radius" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "kernel", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__kernel_callback * kernel", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__kernel_callback" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__kernel_callback * kernel", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__kernel_callback" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "scale_info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__scale_info * scale_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__scale_info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__scale_info * scale_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__scale_info" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "num_contributors", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_contributors" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_contributors" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "contributors", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__contributors * contributors", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__contributors" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__contributors * contributors", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__contributors" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "coefficient_group", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * coefficient_group", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * coefficient_group", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "coefficient_width", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int coefficient_width" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int coefficient_width" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "edge", + "type": { + "reference": "stbir_edge" + }, + "declared_type": { + "reference": "stbir_edge" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "user_data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 3318, + "column": 1, + "source_line": "static void stbir__calculate_coefficients_for_gather_upsample( float out_filter_radius, stbir__kernel_callback * kernel, stbir__scale_info * scale_info, int num_contributors, stbir__contributors* contributors, float* coefficient_group, int coefficient_width, stbir_edge edge, void * user_data )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 3318, + "column": 1, + "source_line": "static void stbir__calculate_coefficients_for_gather_upsample( float out_filter_radius, stbir__kernel_callback * kernel, stbir__scale_info * scale_info, int num_contributors, stbir__contributors* contributors, float* coefficient_group, int coefficient_width, stbir_edge edge, void * user_data )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 3378, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbir__insert_coeff", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "contribs", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__contributors * contribs", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__contributors" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__contributors * contribs", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__contributors" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "coeffs", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * coeffs", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * coeffs", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "new_pixel", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int new_pixel" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int new_pixel" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "new_coeff", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float new_coeff" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float new_coeff" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "max_width", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int max_width" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int max_width" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 3380, + "column": 1, + "source_line": "static void stbir__insert_coeff( stbir__contributors * contribs, float * coeffs, int new_pixel, float new_coeff, int max_width )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 3380, + "column": 1, + "source_line": "static void stbir__insert_coeff( stbir__contributors * contribs, float * coeffs, int new_pixel, float new_coeff, int max_width )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 3420, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbir__calculate_out_pixel_range", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "first_pixel", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int * first_pixel", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int * first_pixel", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "last_pixel", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int * last_pixel", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int * last_pixel", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "in_pixel_center", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float in_pixel_center" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float in_pixel_center" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "in_pixels_radius", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float in_pixels_radius" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float in_pixels_radius" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "scale", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float scale" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float scale" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "out_shift", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float out_shift" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float out_shift" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "out_size", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int out_size" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int out_size" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 3422, + "column": 1, + "source_line": "static void stbir__calculate_out_pixel_range( int * first_pixel, int * last_pixel, float in_pixel_center, float in_pixels_radius, float scale, float out_shift, int out_size )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 3422, + "column": 1, + "source_line": "static void stbir__calculate_out_pixel_range( int * first_pixel, int * last_pixel, float in_pixel_center, float in_pixels_radius, float scale, float out_shift, int out_size )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 3437, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbir__calculate_coefficients_for_gather_downsample", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "start", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int start" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int start" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "end", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int end" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int end" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "in_pixels_radius", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float in_pixels_radius" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float in_pixels_radius" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "kernel", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__kernel_callback * kernel", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__kernel_callback" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__kernel_callback * kernel", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__kernel_callback" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "scale_info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__scale_info * scale_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__scale_info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__scale_info * scale_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__scale_info" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "coefficient_width", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int coefficient_width" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int coefficient_width" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "num_contributors", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_contributors" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_contributors" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "contributors", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__contributors * contributors", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__contributors" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__contributors * contributors", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__contributors" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "coefficient_group", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * coefficient_group", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * coefficient_group", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "user_data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 3439, + "column": 1, + "source_line": "static void stbir__calculate_coefficients_for_gather_downsample( int start, int end, float in_pixels_radius, stbir__kernel_callback * kernel, stbir__scale_info * scale_info, int coefficient_width, int num_contributors, stbir__contributors * contributors, float * coefficient_group, void * user_data )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 3439, + "column": 1, + "source_line": "static void stbir__calculate_coefficients_for_gather_downsample( int start, int end, float in_pixels_radius, stbir__kernel_callback * kernel, stbir__scale_info * scale_info, int coefficient_width, int num_contributors, stbir__contributors * contributors, float * coefficient_group, void * user_data )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 3515, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbir__cleanup_gathered_coefficients", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "edge", + "type": { + "reference": "stbir_edge" + }, + "declared_type": { + "reference": "stbir_edge" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "filter_info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__filter_extent_info * filter_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__filter_extent_info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__filter_extent_info * filter_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__filter_extent_info" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "scale_info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__scale_info * scale_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__scale_info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__scale_info * scale_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__scale_info" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "num_contributors", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_contributors" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_contributors" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "contributors", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__contributors * contributors", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__contributors" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__contributors * contributors", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__contributors" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "coefficient_group", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * coefficient_group", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * coefficient_group", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "coefficient_width", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int coefficient_width" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int coefficient_width" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 3523, + "column": 1, + "source_line": "static void stbir__cleanup_gathered_coefficients( stbir_edge edge, stbir__filter_extent_info* filter_info, stbir__scale_info * scale_info, int num_contributors, stbir__contributors* contributors, float * coefficient_group, int coefficient_width )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 3523, + "column": 1, + "source_line": "static void stbir__cleanup_gathered_coefficients( stbir_edge edge, stbir__filter_extent_info* filter_info, stbir__scale_info * scale_info, int num_contributors, stbir__contributors* contributors, float * coefficient_group, int coefficient_width )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 3692, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbir__pack_coefficients", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "num_contributors", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_contributors" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_contributors" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "contributors", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__contributors * contributors", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__contributors" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__contributors * contributors", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__contributors" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "coefficents", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * coefficents", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * coefficents", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "coefficient_width", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int coefficient_width" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int coefficient_width" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "widest", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int widest" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int widest" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "row0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int row0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int row0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "row1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int row1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int row1" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 3696, + "column": 1, + "source_line": "static int stbir__pack_coefficients( int num_contributors, stbir__contributors* contributors, float * coefficents, int coefficient_width, int widest, int row0, int row1 ) " + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 3696, + "column": 1, + "source_line": "static int stbir__pack_coefficients( int num_contributors, stbir__contributors* contributors, float * coefficents, int coefficient_width, int widest, int row0, int row1 ) " + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 3929, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbir__fancy_alpha_weight_4ch", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "out_buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * out_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * out_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "width_times_channels", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width_times_channels" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width_times_channels" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4138, + "column": 1, + "source_line": "static void stbir__fancy_alpha_weight_4ch( float * out_buffer, int width_times_channels )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 4138, + "column": 1, + "source_line": "static void stbir__fancy_alpha_weight_4ch( float * out_buffer, int width_times_channels )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 4232, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbir__fancy_alpha_weight_2ch", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "out_buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * out_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * out_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "width_times_channels", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width_times_channels" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width_times_channels" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4234, + "column": 1, + "source_line": "static void stbir__fancy_alpha_weight_2ch( float * out_buffer, int width_times_channels )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 4234, + "column": 1, + "source_line": "static void stbir__fancy_alpha_weight_2ch( float * out_buffer, int width_times_channels )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 4302, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbir__fancy_alpha_unweight_4ch", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "encode_buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * encode_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * encode_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "width_times_channels", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width_times_channels" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width_times_channels" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4304, + "column": 1, + "source_line": "static void stbir__fancy_alpha_unweight_4ch( float * encode_buffer, int width_times_channels )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 4304, + "column": 1, + "source_line": "static void stbir__fancy_alpha_unweight_4ch( float * encode_buffer, int width_times_channels )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 4351, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbir__fancy_alpha_unweight_2ch", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "encode_buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * encode_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * encode_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "width_times_channels", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width_times_channels" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width_times_channels" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4354, + "column": 1, + "source_line": "static void stbir__fancy_alpha_unweight_2ch( float * encode_buffer, int width_times_channels )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 4354, + "column": 1, + "source_line": "static void stbir__fancy_alpha_unweight_2ch( float * encode_buffer, int width_times_channels )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 4370, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbir__simple_alpha_weight_4ch", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "decode_buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * decode_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * decode_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "width_times_channels", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width_times_channels" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width_times_channels" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4372, + "column": 1, + "source_line": "static void stbir__simple_alpha_weight_4ch( float * decode_buffer, int width_times_channels )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 4372, + "column": 1, + "source_line": "static void stbir__simple_alpha_weight_4ch( float * decode_buffer, int width_times_channels )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 4426, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbir__simple_alpha_weight_2ch", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "decode_buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * decode_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * decode_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "width_times_channels", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width_times_channels" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width_times_channels" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4428, + "column": 1, + "source_line": "static void stbir__simple_alpha_weight_2ch( float * decode_buffer, int width_times_channels )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 4428, + "column": 1, + "source_line": "static void stbir__simple_alpha_weight_2ch( float * decode_buffer, int width_times_channels )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 4461, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbir__simple_alpha_unweight_4ch", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "encode_buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * encode_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * encode_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "width_times_channels", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width_times_channels" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width_times_channels" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4463, + "column": 1, + "source_line": "static void stbir__simple_alpha_unweight_4ch( float * encode_buffer, int width_times_channels )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 4463, + "column": 1, + "source_line": "static void stbir__simple_alpha_unweight_4ch( float * encode_buffer, int width_times_channels )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 4494, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbir__simple_alpha_unweight_2ch", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "encode_buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * encode_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * encode_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "width_times_channels", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width_times_channels" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width_times_channels" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4496, + "column": 1, + "source_line": "static void stbir__simple_alpha_unweight_2ch( float * encode_buffer, int width_times_channels )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 4496, + "column": 1, + "source_line": "static void stbir__simple_alpha_unweight_2ch( float * encode_buffer, int width_times_channels )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 4507, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbir__simple_flip_3ch", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "decode_buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * decode_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * decode_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "width_times_channels", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width_times_channels" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width_times_channels" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4511, + "column": 1, + "source_line": "static void stbir__simple_flip_3ch( float * decode_buffer, int width_times_channels )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 4511, + "column": 1, + "source_line": "static void stbir__simple_flip_3ch( float * decode_buffer, int width_times_channels )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 4606, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbir__get_ring_buffer_entry", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "parameters": [ + { + "name": "stbir_info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__info const * stbir_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbir__info", + "name": "stbir__info", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": "stbir__info", + "members": [ + { + "name": "current_zone_excluded_ptr", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir_uint64 * current_zone_excluded_ptr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbir_uint64", + "name": "stbir_uint64", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "typedef uint64_t stbir_uint64", + "name": "uint64_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 402, + "column": 1, + "source_line": "typedef uint64_t stbir_uint64;" + }, + "declaration_locations": [] + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1018, + "column": 3, + "source_line": " stbir_uint64 * current_zone_excluded_ptr;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "horizontal", + "type": { + "reference": "stbir__sampler" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1020, + "column": 3, + "source_line": " stbir__sampler horizontal;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "vertical", + "type": { + "reference": "stbir__sampler" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1021, + "column": 3, + "source_line": " stbir__sampler vertical;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "input_data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void const * input_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [ + "const" + ], + "source_text": "const void" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1023, + "column": 3, + "source_line": " void const * input_data;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "output_data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * output_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1024, + "column": 3, + "source_line": " void * output_data;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "input_stride_bytes", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int input_stride_bytes" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1026, + "column": 3, + "source_line": " int input_stride_bytes;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "output_stride_bytes", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int output_stride_bytes" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1027, + "column": 3, + "source_line": " int output_stride_bytes;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "ring_buffer_length_bytes", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ring_buffer_length_bytes" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1028, + "column": 3, + "source_line": " int ring_buffer_length_bytes; // The length of an individual entry in the ring buffer. The total number of ring buffers is stbir__get_filter_pixel_width(filter)" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "ring_buffer_num_entries", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ring_buffer_num_entries" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1029, + "column": 3, + "source_line": " int ring_buffer_num_entries; // Total number of entries in the ring buffer." + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "input_type", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbir_datatype", + "name": "stbir_datatype", + "type": { + "model": "CEnum", + "qualifiers": [], + "source_text": "", + "name": null, + "constants": [ + { + "name": "STBIR_TYPE_UINT8", + "value": "0", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 515, + "column": 1, + "source_line": "typedef enum" + } + }, + { + "name": "STBIR_TYPE_UINT8_SRGB", + "value": "1", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 515, + "column": 1, + "source_line": "typedef enum" + } + }, + { + "name": "STBIR_TYPE_UINT8_SRGB_ALPHA", + "value": "2", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 515, + "column": 1, + "source_line": "typedef enum" + } + }, + { + "name": "STBIR_TYPE_UINT16", + "value": "3", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 515, + "column": 1, + "source_line": "typedef enum" + } + }, + { + "name": "STBIR_TYPE_FLOAT", + "value": "4", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 515, + "column": 1, + "source_line": "typedef enum" + } + }, + { + "name": "STBIR_TYPE_HALF_FLOAT", + "value": "5", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 515, + "column": 1, + "source_line": "typedef enum" + } + } + ], + "anonymous_id": "enum@stb/stb_image_resize2.h:515:1", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 515, + "column": 1, + "source_line": "typedef enum" + } + }, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 515, + "column": 1, + "source_line": "typedef enum" + }, + "declaration_locations": [] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1031, + "column": 3, + "source_line": " stbir_datatype input_type;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "output_type", + "type": { + "reference": "stbir_datatype" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1032, + "column": 3, + "source_line": " stbir_datatype output_type;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "in_pixels_cb", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir_input_callback * in_pixels_cb", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbir_input_callback", + "name": "stbir_input_callback", + "type": { + "model": "CFunctionType", + "qualifiers": [], + "source_text": "typedef void const * stbir_input_callback( void * optional_output, void const * input_ptr, int num_pixels, int x, int y, void * context )", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const void", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [ + "const" + ], + "source_text": "const void" + } + ] + }, + "parameter_types": [ + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * optional_output", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void const * input_ptr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [ + "const" + ], + "source_text": "const void" + } + ] + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_pixels" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * context", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + } + ], + "is_variadic": false, + "prototype_style": "prototype" + }, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 562, + "column": 1, + "source_line": "typedef void const * stbir_input_callback( void * optional_output, void const * input_ptr, int num_pixels, int x, int y, void * context );" + }, + "declaration_locations": [] + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1034, + "column": 3, + "source_line": " stbir_input_callback * in_pixels_cb;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "user_data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1035, + "column": 3, + "source_line": " void * user_data;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "out_pixels_cb", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir_output_callback * out_pixels_cb", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbir_output_callback", + "name": "stbir_output_callback", + "type": { + "model": "CFunctionType", + "qualifiers": [], + "source_text": "typedef void stbir_output_callback( void const * output_ptr, int num_pixels, int y, void * context )", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameter_types": [ + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void const * output_ptr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [ + "const" + ], + "source_text": "const void" + } + ] + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_pixels" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * context", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + } + ], + "is_variadic": false, + "prototype_style": "prototype" + }, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 565, + "column": 1, + "source_line": "typedef void stbir_output_callback( void const * output_ptr, int num_pixels, int y, void * context );" + }, + "declaration_locations": [] + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1036, + "column": 3, + "source_line": " stbir_output_callback * out_pixels_cb;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "scanline_extents", + "type": { + "reference": "stbir__extents" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1038, + "column": 3, + "source_line": " stbir__extents scanline_extents;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "alloced_mem", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * alloced_mem", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1040, + "column": 3, + "source_line": " void * alloced_mem;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "split_info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__per_split_info * split_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbir__per_split_info", + "name": "stbir__per_split_info", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "current_zone_excluded_ptr", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir_uint64 * current_zone_excluded_ptr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir_uint64" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 982, + "column": 3, + "source_line": " stbir_uint64 * current_zone_excluded_ptr;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "decode_buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * decode_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 984, + "column": 3, + "source_line": " float* decode_buffer;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "ring_buffer_first_scanline", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ring_buffer_first_scanline" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 986, + "column": 3, + "source_line": " int ring_buffer_first_scanline;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "ring_buffer_last_scanline", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ring_buffer_last_scanline" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 987, + "column": 3, + "source_line": " int ring_buffer_last_scanline;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "ring_buffer_begin_index", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ring_buffer_begin_index" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 988, + "column": 3, + "source_line": " int ring_buffer_begin_index; // first_scanline is at this index in the ring buffer" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "start_output_y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int start_output_y" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 989, + "column": 3, + "source_line": " int start_output_y, end_output_y;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "end_output_y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int end_output_y" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 989, + "column": 3, + "source_line": " int start_output_y, end_output_y;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "start_input_y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int start_input_y" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 990, + "column": 3, + "source_line": " int start_input_y, end_input_y; // used in scatter only" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "end_input_y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int end_input_y" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 990, + "column": 3, + "source_line": " int start_input_y, end_input_y; // used in scatter only" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "ring_buffers", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float ** ring_buffers", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 993, + "column": 5, + "source_line": " float** ring_buffers; // one pointer for each ring buffer" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "ring_buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * ring_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 995, + "column": 5, + "source_line": " float* ring_buffer; // one big buffer that we index into" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "vertical_buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * vertical_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 998, + "column": 3, + "source_line": " float* vertical_buffer;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "no_cache_straddle", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char no_cache_straddle[64]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "64", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1000, + "column": 3, + "source_line": " char no_cache_straddle[64];" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_image_resize2.h:974:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 974, + "column": 1, + "source_line": "typedef struct" + } + }, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 974, + "column": 1, + "source_line": "typedef struct" + }, + "declaration_locations": [] + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1041, + "column": 3, + "source_line": " stbir__per_split_info * split_info; // by default 1, but there will be N of these allocated based on the thread init you did" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "decode_pixels", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__decode_pixels_func * decode_pixels", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbir__decode_pixels_func", + "name": "stbir__decode_pixels_func", + "type": { + "model": "CFunctionType", + "qualifiers": [], + "source_text": "typedef float * stbir__decode_pixels_func( float * decode, int width_times_channels, void const * input )", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "parameter_types": [ + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * decode", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int width_times_channels" + }, + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void const * input", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [ + "const" + ], + "source_text": "const void" + } + ] + } + ], + "is_variadic": false, + "prototype_style": "prototype" + }, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1003, + "column": 1, + "source_line": "typedef float * stbir__decode_pixels_func( float * decode, int width_times_channels, void const * input );" + }, + "declaration_locations": [] + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1043, + "column": 3, + "source_line": " stbir__decode_pixels_func * decode_pixels;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "alpha_weight", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__alpha_weight_func * alpha_weight", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbir__alpha_weight_func", + "name": "stbir__alpha_weight_func", + "type": { + "model": "CFunctionType", + "qualifiers": [], + "source_text": "typedef void stbir__alpha_weight_func( float * decode_buffer, int width_times_channels )", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameter_types": [ + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * decode_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int width_times_channels" + } + ], + "is_variadic": false, + "prototype_style": "prototype" + }, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1004, + "column": 1, + "source_line": "typedef void stbir__alpha_weight_func( float * decode_buffer, int width_times_channels );" + }, + "declaration_locations": [] + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1044, + "column": 3, + "source_line": " stbir__alpha_weight_func * alpha_weight;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "horizontal_gather_channels", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__horizontal_gather_channels_func * horizontal_gather_channels", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbir__horizontal_gather_channels_func", + "name": "stbir__horizontal_gather_channels_func", + "type": { + "model": "CFunctionType", + "qualifiers": [], + "source_text": "typedef void stbir__horizontal_gather_channels_func( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer,\n stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameter_types": [ + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * output_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int output_sub_size" + }, + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float const * decode_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [ + "const" + ], + "source_text": "const float" + } + ] + }, + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__contributors const * horizontal_contributors", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__contributors" + } + ] + }, + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float const * horizontal_coefficients", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [ + "const" + ], + "source_text": "const float" + } + ] + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int coefficient_width" + } + ], + "is_variadic": false, + "prototype_style": "prototype" + }, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1005, + "column": 1, + "source_line": "typedef void stbir__horizontal_gather_channels_func( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer," + }, + "declaration_locations": [] + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1045, + "column": 3, + "source_line": " stbir__horizontal_gather_channels_func * horizontal_gather_channels;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "alpha_unweight", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__alpha_unweight_func * alpha_unweight", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbir__alpha_unweight_func", + "name": "stbir__alpha_unweight_func", + "type": { + "model": "CFunctionType", + "qualifiers": [], + "source_text": "typedef void stbir__alpha_unweight_func(float * encode_buffer, int width_times_channels )", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameter_types": [ + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * encode_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int width_times_channels" + } + ], + "is_variadic": false, + "prototype_style": "prototype" + }, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1007, + "column": 1, + "source_line": "typedef void stbir__alpha_unweight_func(float * encode_buffer, int width_times_channels );" + }, + "declaration_locations": [] + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1046, + "column": 3, + "source_line": " stbir__alpha_unweight_func * alpha_unweight;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "encode_pixels", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__encode_pixels_func * encode_pixels", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbir__encode_pixels_func", + "name": "stbir__encode_pixels_func", + "type": { + "model": "CFunctionType", + "qualifiers": [], + "source_text": "typedef void stbir__encode_pixels_func( void * output, int width_times_channels, float const * encode )", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameter_types": [ + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * output", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int width_times_channels" + }, + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float const * encode", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [ + "const" + ], + "source_text": "const float" + } + ] + } + ], + "is_variadic": false, + "prototype_style": "prototype" + }, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1008, + "column": 1, + "source_line": "typedef void stbir__encode_pixels_func( void * output, int width_times_channels, float const * encode );" + }, + "declaration_locations": [] + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1047, + "column": 3, + "source_line": " stbir__encode_pixels_func * encode_pixels;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "alloc_ring_buffer_num_entries", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int alloc_ring_buffer_num_entries" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1049, + "column": 3, + "source_line": " int alloc_ring_buffer_num_entries; // Number of entries in the ring buffer that will be allocated" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "splits", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int splits" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1050, + "column": 3, + "source_line": " int splits; // count of splits" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "input_pixel_layout_internal", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbir_internal_pixel_layout", + "name": "stbir_internal_pixel_layout", + "type": { + "model": "CEnum", + "qualifiers": [], + "source_text": "", + "name": null, + "constants": [ + { + "name": "STBIRI_1CHANNEL", + "value": "0", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 861, + "column": 1, + "source_line": "typedef enum" + } + }, + { + "name": "STBIRI_2CHANNEL", + "value": "1", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 861, + "column": 1, + "source_line": "typedef enum" + } + }, + { + "name": "STBIRI_RGB", + "value": "2", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 861, + "column": 1, + "source_line": "typedef enum" + } + }, + { + "name": "STBIRI_BGR", + "value": "3", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 861, + "column": 1, + "source_line": "typedef enum" + } + }, + { + "name": "STBIRI_4CHANNEL", + "value": "4", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 861, + "column": 1, + "source_line": "typedef enum" + } + }, + { + "name": "STBIRI_RGBA", + "value": "5", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 861, + "column": 1, + "source_line": "typedef enum" + } + }, + { + "name": "STBIRI_BGRA", + "value": "6", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 861, + "column": 1, + "source_line": "typedef enum" + } + }, + { + "name": "STBIRI_ARGB", + "value": "7", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 861, + "column": 1, + "source_line": "typedef enum" + } + }, + { + "name": "STBIRI_ABGR", + "value": "8", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 861, + "column": 1, + "source_line": "typedef enum" + } + }, + { + "name": "STBIRI_RA", + "value": "9", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 861, + "column": 1, + "source_line": "typedef enum" + } + }, + { + "name": "STBIRI_AR", + "value": "10", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 861, + "column": 1, + "source_line": "typedef enum" + } + }, + { + "name": "STBIRI_RGBA_PM", + "value": "11", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 861, + "column": 1, + "source_line": "typedef enum" + } + }, + { + "name": "STBIRI_BGRA_PM", + "value": "12", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 861, + "column": 1, + "source_line": "typedef enum" + } + }, + { + "name": "STBIRI_ARGB_PM", + "value": "13", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 861, + "column": 1, + "source_line": "typedef enum" + } + }, + { + "name": "STBIRI_ABGR_PM", + "value": "14", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 861, + "column": 1, + "source_line": "typedef enum" + } + }, + { + "name": "STBIRI_RA_PM", + "value": "15", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 861, + "column": 1, + "source_line": "typedef enum" + } + }, + { + "name": "STBIRI_AR_PM", + "value": "16", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 861, + "column": 1, + "source_line": "typedef enum" + } + } + ], + "anonymous_id": "enum@stb/stb_image_resize2.h:861:1", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 861, + "column": 1, + "source_line": "typedef enum" + } + }, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 861, + "column": 1, + "source_line": "typedef enum" + }, + "declaration_locations": [] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1052, + "column": 3, + "source_line": " stbir_internal_pixel_layout input_pixel_layout_internal;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "output_pixel_layout_internal", + "type": { + "reference": "stbir_internal_pixel_layout" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1053, + "column": 3, + "source_line": " stbir_internal_pixel_layout output_pixel_layout_internal;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "input_color_and_type", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int input_color_and_type" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1055, + "column": 3, + "source_line": " int input_color_and_type;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "offset_x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int offset_x" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1056, + "column": 3, + "source_line": " int offset_x, offset_y; // offset within output_data" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "offset_y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int offset_y" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1056, + "column": 3, + "source_line": " int offset_x, offset_y; // offset within output_data" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "vertical_first", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int vertical_first" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1057, + "column": 3, + "source_line": " int vertical_first;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "channels", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int channels" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1058, + "column": 3, + "source_line": " int channels;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "effective_channels", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int effective_channels" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1059, + "column": 3, + "source_line": " int effective_channels; // same as channels, except on RGBA/ARGB (7), or XA/AX (3)" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "alloced_total", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t alloced_total", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1060, + "column": 3, + "source_line": " size_t alloced_total;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": null, + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1010, + "column": 1, + "source_line": "struct stbir__info" + } + }, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 572, + "column": 1, + "source_line": "typedef struct stbir__info stbir__info;" + }, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__info const * stbir_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__info" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "split_info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__per_split_info const * split_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__per_split_info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__per_split_info const * split_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__per_split_info" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "index", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int index" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int index" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6218, + "column": 1, + "source_line": "static float* stbir__get_ring_buffer_entry(stbir__info const * stbir_info, stbir__per_split_info const * split_info, int index )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 6218, + "column": 1, + "source_line": "static float* stbir__get_ring_buffer_entry(stbir__info const * stbir_info, stbir__per_split_info const * split_info, int index )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 6227, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbir__get_ring_buffer_scanline", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "parameters": [ + { + "name": "stbir_info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__info const * stbir_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__info const * stbir_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__info" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "split_info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__per_split_info const * split_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__per_split_info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__per_split_info const * split_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__per_split_info" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "get_scanline", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int get_scanline" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int get_scanline" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6230, + "column": 1, + "source_line": "static float* stbir__get_ring_buffer_scanline(stbir__info const * stbir_info, stbir__per_split_info const * split_info, int get_scanline)" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 6230, + "column": 1, + "source_line": "static float* stbir__get_ring_buffer_scanline(stbir__info const * stbir_info, stbir__per_split_info const * split_info, int get_scanline)" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 6234, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbir__resample_vertical_gather", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "stbir_info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__info const * stbir_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__info const * stbir_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__info" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "split_info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__per_split_info * split_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__per_split_info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__per_split_info * split_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__per_split_info" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "contrib_n0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int contrib_n0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int contrib_n0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "contrib_n1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int contrib_n1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int contrib_n1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "vertical_coefficients", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float const * vertical_coefficients", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [ + "const" + ], + "source_text": "const float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float const * vertical_coefficients", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [ + "const" + ], + "source_text": "const float" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6248, + "column": 1, + "source_line": "static void stbir__resample_vertical_gather(stbir__info const * stbir_info, stbir__per_split_info* split_info, int n, int contrib_n0, int contrib_n1, float const * vertical_coefficients )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 6248, + "column": 1, + "source_line": "static void stbir__resample_vertical_gather(stbir__info const * stbir_info, stbir__per_split_info* split_info, int n, int contrib_n0, int contrib_n1, float const * vertical_coefficients )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 6287, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbir__decode_and_resample_for_vertical_gather_loop", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "stbir_info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__info const * stbir_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__info const * stbir_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__info" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "split_info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__per_split_info * split_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__per_split_info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__per_split_info * split_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__per_split_info" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6289, + "column": 1, + "source_line": "static void stbir__decode_and_resample_for_vertical_gather_loop(stbir__info const * stbir_info, stbir__per_split_info* split_info, int n)" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 6289, + "column": 1, + "source_line": "static void stbir__decode_and_resample_for_vertical_gather_loop(stbir__info const * stbir_info, stbir__per_split_info* split_info, int n)" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 6308, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbir__vertical_gather_loop", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "stbir_info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__info const * stbir_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__info const * stbir_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__info" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "split_info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__per_split_info * split_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__per_split_info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__per_split_info * split_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__per_split_info" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "split_count", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int split_count" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int split_count" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6310, + "column": 1, + "source_line": "static void stbir__vertical_gather_loop( stbir__info const * stbir_info, stbir__per_split_info* split_info, int split_count )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 6310, + "column": 1, + "source_line": "static void stbir__vertical_gather_loop( stbir__info const * stbir_info, stbir__per_split_info* split_info, int split_count )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 6369, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbir__encode_first_scanline_from_scatter", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "stbir_info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__info const * stbir_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__info const * stbir_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__info" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "split_info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__per_split_info * split_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__per_split_info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__per_split_info * split_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__per_split_info" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6374, + "column": 1, + "source_line": "static void stbir__encode_first_scanline_from_scatter(stbir__info const * stbir_info, stbir__per_split_info* split_info)" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 6374, + "column": 1, + "source_line": "static void stbir__encode_first_scanline_from_scatter(stbir__info const * stbir_info, stbir__per_split_info* split_info)" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 6389, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbir__horizontal_resample_and_encode_first_scanline_from_scatter", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "stbir_info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__info const * stbir_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__info const * stbir_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__info" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "split_info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__per_split_info * split_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__per_split_info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__per_split_info * split_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__per_split_info" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6391, + "column": 1, + "source_line": "static void stbir__horizontal_resample_and_encode_first_scanline_from_scatter(stbir__info const * stbir_info, stbir__per_split_info* split_info)" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 6391, + "column": 1, + "source_line": "static void stbir__horizontal_resample_and_encode_first_scanline_from_scatter(stbir__info const * stbir_info, stbir__per_split_info* split_info)" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 6410, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbir__resample_vertical_scatter", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "stbir_info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__info const * stbir_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__info const * stbir_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__info" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "split_info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__per_split_info * split_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__per_split_info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__per_split_info * split_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__per_split_info" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "vertical_coefficients", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float const * vertical_coefficients", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [ + "const" + ], + "source_text": "const float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float const * vertical_coefficients", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [ + "const" + ], + "source_text": "const float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "vertical_buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float const * vertical_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [ + "const" + ], + "source_text": "const float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float const * vertical_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [ + "const" + ], + "source_text": "const float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "vertical_buffer_end", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float const * vertical_buffer_end", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [ + "const" + ], + "source_text": "const float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float const * vertical_buffer_end", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [ + "const" + ], + "source_text": "const float" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6412, + "column": 1, + "source_line": "static void stbir__resample_vertical_scatter(stbir__info const * stbir_info, stbir__per_split_info* split_info, int n0, int n1, float const * vertical_coefficients, float const * vertical_buffer, float const * vertical_buffer_end )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 6412, + "column": 1, + "source_line": "static void stbir__resample_vertical_scatter(stbir__info const * stbir_info, stbir__per_split_info* split_info, int n0, int n1, float const * vertical_coefficients, float const * vertical_buffer, float const * vertical_buffer_end )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 6440, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbir__vertical_scatter_loop", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "stbir_info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__info const * stbir_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__info const * stbir_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__info" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "split_info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__per_split_info * split_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__per_split_info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__per_split_info * split_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__per_split_info" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "split_count", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int split_count" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int split_count" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6444, + "column": 1, + "source_line": "static void stbir__vertical_scatter_loop( stbir__info const * stbir_info, stbir__per_split_info* split_info, int split_count )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 6444, + "column": 1, + "source_line": "static void stbir__vertical_scatter_loop( stbir__info const * stbir_info, stbir__per_split_info* split_info, int split_count )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 6567, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbir__set_sampler", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "samp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__sampler * samp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__sampler" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__sampler * samp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__sampler" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "filter", + "type": { + "reference": "stbir_filter" + }, + "declared_type": { + "reference": "stbir_filter" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "kernel", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__kernel_callback * kernel", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__kernel_callback" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__kernel_callback * kernel", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__kernel_callback" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "support", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__support_callback * support", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__support_callback" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__support_callback * support", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__support_callback" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "edge", + "type": { + "reference": "stbir_edge" + }, + "declared_type": { + "reference": "stbir_edge" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "scale_info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__scale_info * scale_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__scale_info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__scale_info * scale_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__scale_info" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "always_gather", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int always_gather" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int always_gather" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "user_data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6573, + "column": 1, + "source_line": "static void stbir__set_sampler(stbir__sampler * samp, stbir_filter filter, stbir__kernel_callback * kernel, stbir__support_callback * support, stbir_edge edge, stbir__scale_info * scale_info, int always_gather, void * user_data )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 6573, + "column": 1, + "source_line": "static void stbir__set_sampler(stbir__sampler * samp, stbir_filter filter, stbir__kernel_callback * kernel, stbir__support_callback * support, stbir_edge edge, stbir__scale_info * scale_info, int always_gather, void * user_data )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 6653, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbir__get_conservative_extents", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "samp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__sampler * samp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__sampler" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__sampler * samp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__sampler" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "range", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__contributors * range", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__contributors" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__contributors * range", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__contributors" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "user_data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6655, + "column": 1, + "source_line": "static void stbir__get_conservative_extents( stbir__sampler * samp, stbir__contributors * range, void * user_data )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 6655, + "column": 1, + "source_line": "static void stbir__get_conservative_extents( stbir__sampler * samp, stbir__contributors * range, void * user_data )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 6745, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbir__get_split_info", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "split_info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__per_split_info * split_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__per_split_info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__per_split_info * split_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__per_split_info" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "splits", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int splits" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int splits" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "output_height", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int output_height" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int output_height" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "vertical_pixel_margin", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int vertical_pixel_margin" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int vertical_pixel_margin" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "input_full_height", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int input_full_height" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int input_full_height" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "is_gather", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int is_gather" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int is_gather" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "contribs", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__contributors * contribs", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__contributors" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__contributors * contribs", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__contributors" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6747, + "column": 1, + "source_line": "static void stbir__get_split_info( stbir__per_split_info* split_info, int splits, int output_height, int vertical_pixel_margin, int input_full_height, int is_gather, stbir__contributors * contribs )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 6747, + "column": 1, + "source_line": "static void stbir__get_split_info( stbir__per_split_info* split_info, int splits, int output_height, int vertical_pixel_margin, int input_full_height, int is_gather, stbir__contributors * contribs )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 6815, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbir__free_internal_mem", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__info *info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__info *info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__info" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6817, + "column": 1, + "source_line": "static void stbir__free_internal_mem( stbir__info *info )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 6817, + "column": 1, + "source_line": "static void stbir__free_internal_mem( stbir__info *info )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 6866, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbir__get_max_split", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "splits", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int splits" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int splits" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "height", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int height" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int height" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6868, + "column": 1, + "source_line": "static int stbir__get_max_split( int splits, int height )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 6868, + "column": 1, + "source_line": "static int stbir__get_max_split( int splits, int height )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 6881, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbir__should_do_vertical_first", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "weights_table", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float weights_table[STBIR_RESIZE_CLASSIFICATIONS][4]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "4", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float weights_table[STBIR_RESIZE_CLASSIFICATIONS][4]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STBIR_RESIZE_CLASSIFICATIONS", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "4", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "horizontal_filter_pixel_width", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int horizontal_filter_pixel_width" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int horizontal_filter_pixel_width" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "horizontal_scale", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float horizontal_scale" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float horizontal_scale" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "horizontal_output_size", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int horizontal_output_size" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int horizontal_output_size" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "vertical_filter_pixel_width", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int vertical_filter_pixel_width" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int vertical_filter_pixel_width" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "vertical_scale", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float vertical_scale" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float vertical_scale" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "vertical_output_size", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int vertical_output_size" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int vertical_output_size" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "is_gather", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int is_gather" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int is_gather" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STBIR__V_FIRST_INFO * info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "STBIR__V_FIRST_INFO", + "name": "STBIR__V_FIRST_INFO", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": "STBIR__V_FIRST_INFO", + "members": [ + { + "name": "v_cost", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double v_cost" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6949, + "column": 3, + "source_line": " double v_cost, h_cost;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "h_cost", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double h_cost" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6949, + "column": 3, + "source_line": " double v_cost, h_cost;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "control_v_first", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int control_v_first" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6950, + "column": 3, + "source_line": " int control_v_first; // 0 = no control, 1 = force hori, 2 = force vert" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "v_first", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v_first" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6951, + "column": 3, + "source_line": " int v_first;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "v_resize_classification", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v_resize_classification" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6952, + "column": 3, + "source_line": " int v_resize_classification;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "is_gather", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int is_gather" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6953, + "column": 3, + "source_line": " int is_gather;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": null, + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6947, + "column": 1, + "source_line": "typedef struct STBIR__V_FIRST_INFO" + } + }, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6947, + "column": 1, + "source_line": "typedef struct STBIR__V_FIRST_INFO" + }, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STBIR__V_FIRST_INFO * info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STBIR__V_FIRST_INFO" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6985, + "column": 1, + "source_line": "static int stbir__should_do_vertical_first( float weights_table[STBIR_RESIZE_CLASSIFICATIONS][4], int horizontal_filter_pixel_width, float horizontal_scale, int horizontal_output_size, int vertical_filter_pixel_width, float vertical_scale, int vertical_output_size, int is_gather, STBIR__V_FIRST_INFO * info )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 6985, + "column": 1, + "source_line": "static int stbir__should_do_vertical_first( float weights_table[STBIR_RESIZE_CLASSIFICATIONS][4], int horizontal_filter_pixel_width, float horizontal_scale, int horizontal_output_size, int vertical_filter_pixel_width, float vertical_scale, int vertical_output_size, int is_gather, STBIR__V_FIRST_INFO * info )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 7031, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbir__perform_resize", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__info const * info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__info const * info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__info" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "split_start", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int split_start" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int split_start" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "split_count", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int split_count" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int split_count" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 7380, + "column": 1, + "source_line": "static int stbir__perform_resize( stbir__info const * info, int split_start, int split_count )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 7380, + "column": 1, + "source_line": "static int stbir__perform_resize( stbir__info const * info, int split_start, int split_count )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 7394, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbir__update_info_from_resize", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__info * info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__info * info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__info" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "resize", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STBIR_RESIZE * resize", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "STBIR_RESIZE", + "name": "STBIR_RESIZE", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": "STBIR_RESIZE", + "members": [ + { + "name": "user_data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 576, + "column": 3, + "source_line": " void * user_data;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "input_pixels", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void const * input_pixels", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [ + "const" + ], + "source_text": "const void" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 577, + "column": 3, + "source_line": " void const * input_pixels;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "input_w", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int input_w" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 578, + "column": 3, + "source_line": " int input_w, input_h;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "input_h", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int input_h" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 578, + "column": 3, + "source_line": " int input_w, input_h;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "input_s0", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double input_s0" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 579, + "column": 3, + "source_line": " double input_s0, input_t0, input_s1, input_t1;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "input_t0", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double input_t0" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 579, + "column": 3, + "source_line": " double input_s0, input_t0, input_s1, input_t1;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "input_s1", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double input_s1" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 579, + "column": 3, + "source_line": " double input_s0, input_t0, input_s1, input_t1;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "input_t1", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double input_t1" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 579, + "column": 3, + "source_line": " double input_s0, input_t0, input_s1, input_t1;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "input_cb", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir_input_callback * input_cb", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir_input_callback" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 580, + "column": 3, + "source_line": " stbir_input_callback * input_cb;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "output_pixels", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * output_pixels", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 581, + "column": 3, + "source_line": " void * output_pixels;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "output_w", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int output_w" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 582, + "column": 3, + "source_line": " int output_w, output_h;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "output_h", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int output_h" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 582, + "column": 3, + "source_line": " int output_w, output_h;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "output_subx", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int output_subx" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 583, + "column": 3, + "source_line": " int output_subx, output_suby, output_subw, output_subh;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "output_suby", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int output_suby" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 583, + "column": 3, + "source_line": " int output_subx, output_suby, output_subw, output_subh;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "output_subw", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int output_subw" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 583, + "column": 3, + "source_line": " int output_subx, output_suby, output_subw, output_subh;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "output_subh", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int output_subh" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 583, + "column": 3, + "source_line": " int output_subx, output_suby, output_subw, output_subh;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "output_cb", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir_output_callback * output_cb", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir_output_callback" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 584, + "column": 3, + "source_line": " stbir_output_callback * output_cb;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "input_stride_in_bytes", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int input_stride_in_bytes" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 585, + "column": 3, + "source_line": " int input_stride_in_bytes;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "output_stride_in_bytes", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int output_stride_in_bytes" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 586, + "column": 3, + "source_line": " int output_stride_in_bytes;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "splits", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int splits" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 587, + "column": 3, + "source_line": " int splits;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "fast_alpha", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int fast_alpha" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 588, + "column": 3, + "source_line": " int fast_alpha;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "needs_rebuild", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int needs_rebuild" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 589, + "column": 3, + "source_line": " int needs_rebuild;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "called_alloc", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int called_alloc" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 590, + "column": 3, + "source_line": " int called_alloc;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "input_pixel_layout_public", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbir_pixel_layout", + "name": "stbir_pixel_layout", + "type": { + "model": "CEnum", + "qualifiers": [], + "source_text": "", + "name": null, + "constants": [ + { + "name": "STBIR_1CHANNEL", + "value": "1", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 435, + "column": 1, + "source_line": "typedef enum" + } + }, + { + "name": "STBIR_2CHANNEL", + "value": "2", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 435, + "column": 1, + "source_line": "typedef enum" + } + }, + { + "name": "STBIR_RGB", + "value": "3", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 435, + "column": 1, + "source_line": "typedef enum" + } + }, + { + "name": "STBIR_BGR", + "value": "0", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 435, + "column": 1, + "source_line": "typedef enum" + } + }, + { + "name": "STBIR_4CHANNEL", + "value": "5", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 435, + "column": 1, + "source_line": "typedef enum" + } + }, + { + "name": "STBIR_RGBA", + "value": "4", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 435, + "column": 1, + "source_line": "typedef enum" + } + }, + { + "name": "STBIR_BGRA", + "value": "6", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 435, + "column": 1, + "source_line": "typedef enum" + } + }, + { + "name": "STBIR_ARGB", + "value": "7", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 435, + "column": 1, + "source_line": "typedef enum" + } + }, + { + "name": "STBIR_ABGR", + "value": "8", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 435, + "column": 1, + "source_line": "typedef enum" + } + }, + { + "name": "STBIR_RA", + "value": "9", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 435, + "column": 1, + "source_line": "typedef enum" + } + }, + { + "name": "STBIR_AR", + "value": "10", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 435, + "column": 1, + "source_line": "typedef enum" + } + }, + { + "name": "STBIR_RGBA_PM", + "value": "11", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 435, + "column": 1, + "source_line": "typedef enum" + } + }, + { + "name": "STBIR_BGRA_PM", + "value": "12", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 435, + "column": 1, + "source_line": "typedef enum" + } + }, + { + "name": "STBIR_ARGB_PM", + "value": "13", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 435, + "column": 1, + "source_line": "typedef enum" + } + }, + { + "name": "STBIR_ABGR_PM", + "value": "14", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 435, + "column": 1, + "source_line": "typedef enum" + } + }, + { + "name": "STBIR_RA_PM", + "value": "15", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 435, + "column": 1, + "source_line": "typedef enum" + } + }, + { + "name": "STBIR_AR_PM", + "value": "16", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 435, + "column": 1, + "source_line": "typedef enum" + } + }, + { + "name": "STBIR_RGBA_NO_AW", + "value": "11", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 435, + "column": 1, + "source_line": "typedef enum" + } + }, + { + "name": "STBIR_BGRA_NO_AW", + "value": "12", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 435, + "column": 1, + "source_line": "typedef enum" + } + }, + { + "name": "STBIR_ARGB_NO_AW", + "value": "13", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 435, + "column": 1, + "source_line": "typedef enum" + } + }, + { + "name": "STBIR_ABGR_NO_AW", + "value": "14", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 435, + "column": 1, + "source_line": "typedef enum" + } + }, + { + "name": "STBIR_RA_NO_AW", + "value": "15", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 435, + "column": 1, + "source_line": "typedef enum" + } + }, + { + "name": "STBIR_AR_NO_AW", + "value": "16", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 435, + "column": 1, + "source_line": "typedef enum" + } + } + ], + "anonymous_id": "enum@stb/stb_image_resize2.h:435:1", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 435, + "column": 1, + "source_line": "typedef enum" + } + }, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 435, + "column": 1, + "source_line": "typedef enum" + }, + "declaration_locations": [] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 591, + "column": 3, + "source_line": " stbir_pixel_layout input_pixel_layout_public;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "output_pixel_layout_public", + "type": { + "reference": "stbir_pixel_layout" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 592, + "column": 3, + "source_line": " stbir_pixel_layout output_pixel_layout_public;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "input_data_type", + "type": { + "reference": "stbir_datatype" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 593, + "column": 3, + "source_line": " stbir_datatype input_data_type;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "output_data_type", + "type": { + "reference": "stbir_datatype" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 594, + "column": 3, + "source_line": " stbir_datatype output_data_type;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "horizontal_filter", + "type": { + "reference": "stbir_filter" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 595, + "column": 3, + "source_line": " stbir_filter horizontal_filter, vertical_filter;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "vertical_filter", + "type": { + "reference": "stbir_filter" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 595, + "column": 3, + "source_line": " stbir_filter horizontal_filter, vertical_filter;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "horizontal_edge", + "type": { + "reference": "stbir_edge" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 596, + "column": 3, + "source_line": " stbir_edge horizontal_edge, vertical_edge;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "vertical_edge", + "type": { + "reference": "stbir_edge" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 596, + "column": 3, + "source_line": " stbir_edge horizontal_edge, vertical_edge;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "horizontal_filter_kernel", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__kernel_callback * horizontal_filter_kernel", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__kernel_callback" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 597, + "column": 3, + "source_line": " stbir__kernel_callback * horizontal_filter_kernel; stbir__support_callback * horizontal_filter_support;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "horizontal_filter_support", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__support_callback * horizontal_filter_support", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__support_callback" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 597, + "column": 54, + "source_line": " stbir__kernel_callback * horizontal_filter_kernel; stbir__support_callback * horizontal_filter_support;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "vertical_filter_kernel", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__kernel_callback * vertical_filter_kernel", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__kernel_callback" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 598, + "column": 3, + "source_line": " stbir__kernel_callback * vertical_filter_kernel; stbir__support_callback * vertical_filter_support;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "vertical_filter_support", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__support_callback * vertical_filter_support", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__support_callback" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 598, + "column": 52, + "source_line": " stbir__kernel_callback * vertical_filter_kernel; stbir__support_callback * vertical_filter_support;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "samplers", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__info * samplers", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__info" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 599, + "column": 3, + "source_line": " stbir__info * samplers;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": null, + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 574, + "column": 1, + "source_line": "typedef struct STBIR_RESIZE // use the stbir_resize_init and stbir_override functions to set these values for future compatibility" + } + }, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 574, + "column": 1, + "source_line": "typedef struct STBIR_RESIZE // use the stbir_resize_init and stbir_override functions to set these values for future compatibility" + }, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STBIR_RESIZE * resize", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STBIR_RESIZE" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 7396, + "column": 1, + "source_line": "static void stbir__update_info_from_resize( stbir__info * info, STBIR_RESIZE * resize )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 7396, + "column": 1, + "source_line": "static void stbir__update_info_from_resize( stbir__info * info, STBIR_RESIZE * resize )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 7543, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbir__clip", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "outx", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int * outx", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int * outx", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "outsubw", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int * outsubw", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int * outsubw", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "outw", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int outw" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int outw" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "u0", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "double * u0", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "double * u0", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "u1", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "double * u1", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "double * u1", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 7545, + "column": 1, + "source_line": "static void stbir__clip( int * outx, int * outsubw, int outw, double * u0, double * u1 )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 7545, + "column": 1, + "source_line": "static void stbir__clip( int * outx, int * outsubw, int outw, double * u0, double * u1 )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 7568, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbir__double_to_rational", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double f" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double f" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "limit", + "type": { + "reference": "stbir_uint32" + }, + "declared_type": { + "reference": "stbir_uint32" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "numer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir_uint32 *numer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir_uint32" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir_uint32 *numer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir_uint32" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "denom", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir_uint32 *denom", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir_uint32" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir_uint32 *denom", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir_uint32" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "limit_denom", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int limit_denom" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int limit_denom" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 7571, + "column": 1, + "source_line": "static int stbir__double_to_rational(double f, stbir_uint32 limit, stbir_uint32 *numer, stbir_uint32 *denom, int limit_denom ) // limit_denom (1) or limit numer (0)" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 7571, + "column": 1, + "source_line": "static int stbir__double_to_rational(double f, stbir_uint32 limit, stbir_uint32 *numer, stbir_uint32 *denom, int limit_denom ) // limit_denom (1) or limit numer (0)" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 7646, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbir__calculate_region_transform", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "scale_info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__scale_info * scale_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__scale_info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__scale_info * scale_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__scale_info" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "output_full_range", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int output_full_range" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int output_full_range" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "output_offset", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int * output_offset", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int * output_offset", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "output_sub_range", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int output_sub_range" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int output_sub_range" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "input_full_range", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int input_full_range" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int input_full_range" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "input_s0", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double input_s0" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double input_s0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "input_s1", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double input_s1" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double input_s1" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 7648, + "column": 1, + "source_line": "static int stbir__calculate_region_transform( stbir__scale_info * scale_info, int output_full_range, int * output_offset, int output_sub_range, int input_full_range, double input_s0, double input_s1 )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 7648, + "column": 1, + "source_line": "static int stbir__calculate_region_transform( stbir__scale_info * scale_info, int output_full_range, int * output_offset, int output_sub_range, int input_full_range, double input_s0, double input_s1 )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 7695, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbir__init_and_set_layout", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "resize", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STBIR_RESIZE * resize", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STBIR_RESIZE" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STBIR_RESIZE * resize", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STBIR_RESIZE" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "pixel_layout", + "type": { + "reference": "stbir_pixel_layout" + }, + "declared_type": { + "reference": "stbir_pixel_layout" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "data_type", + "type": { + "reference": "stbir_datatype" + }, + "declared_type": { + "reference": "stbir_datatype" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 7698, + "column": 1, + "source_line": "static void stbir__init_and_set_layout( STBIR_RESIZE * resize, stbir_pixel_layout pixel_layout, stbir_datatype data_type )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 7698, + "column": 1, + "source_line": "static void stbir__init_and_set_layout( STBIR_RESIZE * resize, stbir_pixel_layout pixel_layout, stbir_datatype data_type )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 7718, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbir__perform_build", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "resize", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STBIR_RESIZE * resize", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STBIR_RESIZE" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STBIR_RESIZE * resize", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STBIR_RESIZE" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "splits", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int splits" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int splits" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 7876, + "column": 1, + "source_line": "static int stbir__perform_build( STBIR_RESIZE * resize, int splits )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 7876, + "column": 1, + "source_line": "static int stbir__perform_build( STBIR_RESIZE * resize, int splits )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 7947, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbir_quick_resize_helper", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "parameters": [ + { + "name": "input_pixels", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const void *input_pixels", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [ + "const" + ], + "source_text": "const void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const void *input_pixels", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [ + "const" + ], + "source_text": "const void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "input_w", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int input_w" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int input_w" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "input_h", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int input_h" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int input_h" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "input_stride_in_bytes", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int input_stride_in_bytes" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int input_stride_in_bytes" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "output_pixels", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *output_pixels", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *output_pixels", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "output_w", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int output_w" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int output_w" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "output_h", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int output_h" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int output_h" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "output_stride_in_bytes", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int output_stride_in_bytes" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int output_stride_in_bytes" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "pixel_layout", + "type": { + "reference": "stbir_pixel_layout" + }, + "declared_type": { + "reference": "stbir_pixel_layout" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "data_type", + "type": { + "reference": "stbir_datatype" + }, + "declared_type": { + "reference": "stbir_datatype" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "edge", + "type": { + "reference": "stbir_edge" + }, + "declared_type": { + "reference": "stbir_edge" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "filter", + "type": { + "reference": "stbir_filter" + }, + "declared_type": { + "reference": "stbir_filter" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8044, + "column": 1, + "source_line": "static void * stbir_quick_resize_helper( const void *input_pixels , int input_w , int input_h, int input_stride_in_bytes," + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 8044, + "column": 1, + "source_line": "static void * stbir_quick_resize_helper( const void *input_pixels , int input_w , int input_h, int input_stride_in_bytes," + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 8116, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + } + ], + "structs": [ + { + "reference": "struct STBIR_RESIZE" + }, + { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": "STBIR_PROFILE_INFO", + "members": [ + { + "name": "total_clocks", + "type": { + "reference": "stbir_uint64" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 755, + "column": 3, + "source_line": " stbir_uint64 total_clocks;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "clocks", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir_uint64 clocks[ 8 ]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "8", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "reference": "stbir_uint64" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 759, + "column": 3, + "source_line": " stbir_uint64 clocks[ 8 ];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "descriptions", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char const ** descriptions", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 760, + "column": 3, + "source_line": " char const ** descriptions;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "count", + "type": { + "reference": "stbir_uint32" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 763, + "column": 3, + "source_line": " stbir_uint32 count;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": null, + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 753, + "column": 1, + "source_line": "typedef struct STBIR_PROFILE_INFO" + } + }, + { + "reference": "struct@stb/stb_image_resize2.h:910:1" + }, + { + "reference": "struct@stb/stb_image_resize2.h:916:1" + }, + { + "reference": "struct@stb/stb_image_resize2.h:923:1" + }, + { + "reference": "struct stbir__scale_info" + }, + { + "reference": "struct@stb/stb_image_resize2.h:941:1" + }, + { + "reference": "struct@stb/stb_image_resize2.h:967:1" + }, + { + "reference": "struct@stb/stb_image_resize2.h:974:1" + }, + { + "reference": "struct stbir__info" + }, + { + "reference": "struct STBIR__V_FIRST_INFO" + } + ], + "unions": [ + { + "model": "CUnion", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "u", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int u" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1116, + "column": 3, + "source_line": " unsigned int u;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "f", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float f" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1117, + "column": 3, + "source_line": " float f;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "union@stb/stb_image_resize2.h:1114:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1114, + "column": 1, + "source_line": "typedef union" + } + }, + { + "model": "CUnion", + "qualifiers": [], + "source_text": "", + "name": "stbir__FP16", + "members": [ + { + "name": "u", + "type": { + "model": "CUnsignedShort", + "qualifiers": [], + "source_text": "unsigned short u" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2228, + "column": 5, + "source_line": " unsigned short u;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": null, + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2226, + "column": 3, + "source_line": " typedef union stbir__FP16" + } + }, + { + "model": "CUnion", + "qualifiers": [], + "source_text": "", + "name": "stbir__simdi_u32", + "members": [ + { + "name": "m128i_u32", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir_uint32 m128i_u32[4]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "4", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "reference": "stbir_uint32" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2559, + "column": 3, + "source_line": " stbir_uint32 m128i_u32[4];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "m128i_i32", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int m128i_i32[4]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "4", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2560, + "column": 3, + "source_line": " int m128i_i32[4];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "m128i_i128", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbir__simdi m128i_i128", + "name": "stbir__simdi", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2561, + "column": 3, + "source_line": " stbir__simdi m128i_i128;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": null, + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2557, + "column": 1, + "source_line": "typedef union stbir__simdi_u32" + } + } + ], + "enums": [ + { + "reference": "enum@stb/stb_image_resize2.h:435:1" + }, + { + "reference": "enum@stb/stb_image_resize2.h:495:1" + }, + { + "reference": "enum@stb/stb_image_resize2.h:503:1" + }, + { + "reference": "enum@stb/stb_image_resize2.h:515:1" + }, + { + "reference": "enum@stb/stb_image_resize2.h:861:1" + } + ], + "typedefs": [ + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbir_uint8", + "name": "stbir_uint8", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "typedef unsigned char stbir_uint8" + }, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 393, + "column": 1, + "source_line": "typedef unsigned char stbir_uint8;" + }, + "declaration_locations": [] + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbir_uint16", + "name": "stbir_uint16", + "type": { + "model": "CUnsignedShort", + "qualifiers": [], + "source_text": "typedef unsigned short stbir_uint16" + }, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 394, + "column": 1, + "source_line": "typedef unsigned short stbir_uint16;" + }, + "declaration_locations": [] + }, + { + "reference": "stbir_uint32" + }, + { + "reference": "stbir_uint64" + }, + { + "reference": "stbir_pixel_layout" + }, + { + "reference": "stbir_edge" + }, + { + "reference": "stbir_filter" + }, + { + "reference": "stbir_datatype" + }, + { + "reference": "stbir_input_callback" + }, + { + "reference": "stbir_output_callback" + }, + { + "reference": "stbir__kernel_callback" + }, + { + "reference": "stbir__support_callback" + }, + { + "reference": "stbir__info" + }, + { + "reference": "STBIR_RESIZE" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "STBIR_PROFILE_INFO", + "name": "STBIR_PROFILE_INFO", + "type": { + "reference": "struct STBIR_PROFILE_INFO" + }, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 753, + "column": 1, + "source_line": "typedef struct STBIR_PROFILE_INFO" + }, + "declaration_locations": [] + }, + { + "reference": "stbir_internal_pixel_layout" + }, + { + "reference": "stbir__contributors" + }, + { + "reference": "stbir__filter_extent_info" + }, + { + "reference": "stbir__span" + }, + { + "reference": "stbir__scale_info" + }, + { + "reference": "stbir__sampler" + }, + { + "reference": "stbir__extents" + }, + { + "reference": "stbir__per_split_info" + }, + { + "reference": "stbir__decode_pixels_func" + }, + { + "reference": "stbir__alpha_weight_func" + }, + { + "reference": "stbir__horizontal_gather_channels_func" + }, + { + "reference": "stbir__alpha_unweight_func" + }, + { + "reference": "stbir__encode_pixels_func" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbir__FP32", + "name": "stbir__FP32", + "type": { + "reference": "union@stb/stb_image_resize2.h:1114:1" + }, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1114, + "column": 1, + "source_line": "typedef union" + }, + "declaration_locations": [] + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbir__FP16", + "name": "stbir__FP16", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "typedef __int16 stbir__FP16", + "name": "__int16", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2219, + "column": 3, + "source_line": " typedef __int16 stbir__FP16;" + }, + "declaration_locations": [] + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbir__simdi_u32", + "name": "stbir__simdi_u32", + "type": { + "reference": "union stbir__simdi_u32" + }, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2557, + "column": 1, + "source_line": "typedef union stbir__simdi_u32" + }, + "declaration_locations": [] + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbir__edge_wrap_func", + "name": "stbir__edge_wrap_func", + "type": { + "model": "CFunctionType", + "qualifiers": [], + "source_text": "typedef int stbir__edge_wrap_func( int n, int max )", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameter_types": [ + { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int max" + } + ], + "is_variadic": false, + "prototype_style": "prototype" + }, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 3101, + "column": 1, + "source_line": "typedef int stbir__edge_wrap_func( int n, int max );" + }, + "declaration_locations": [] + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "STBIR_VERTICAL_GATHERFUNC", + "name": "STBIR_VERTICAL_GATHERFUNC", + "type": { + "model": "CFunctionType", + "qualifiers": [], + "source_text": "typedef void STBIR_VERTICAL_GATHERFUNC( float * output, float const * coeffs, float const ** inputs, float const * input0_end )", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameter_types": [ + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * output", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float const * coeffs", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [ + "const" + ], + "source_text": "const float" + } + ] + }, + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float const ** inputs", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [ + "const" + ], + "source_text": "const float" + } + ] + }, + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float const * input0_end", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [ + "const" + ], + "source_text": "const float" + } + ] + } + ], + "is_variadic": false, + "prototype_style": "prototype" + }, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6159, + "column": 1, + "source_line": "typedef void STBIR_VERTICAL_GATHERFUNC( float * output, float const * coeffs, float const ** inputs, float const * input0_end );" + }, + "declaration_locations": [] + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "STBIR_VERTICAL_SCATTERFUNC", + "name": "STBIR_VERTICAL_SCATTERFUNC", + "type": { + "model": "CFunctionType", + "qualifiers": [], + "source_text": "typedef void STBIR_VERTICAL_SCATTERFUNC( float ** outputs, float const * coeffs, float const * input, float const * input_end )", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameter_types": [ + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float ** outputs", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float const * coeffs", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [ + "const" + ], + "source_text": "const float" + } + ] + }, + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float const * input", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [ + "const" + ], + "source_text": "const float" + } + ] + }, + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float const * input_end", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [ + "const" + ], + "source_text": "const float" + } + ] + } + ], + "is_variadic": false, + "prototype_style": "prototype" + }, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6171, + "column": 1, + "source_line": "typedef void STBIR_VERTICAL_SCATTERFUNC( float ** outputs, float const * coeffs, float const * input, float const * input_end );" + }, + "declaration_locations": [] + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbir__handle_scanline_for_scatter_func", + "name": "stbir__handle_scanline_for_scatter_func", + "type": { + "model": "CFunctionType", + "qualifiers": [], + "source_text": "typedef void stbir__handle_scanline_for_scatter_func(stbir__info const * stbir_info, stbir__per_split_info* split_info)", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameter_types": [ + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__info const * stbir_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__info" + } + ] + }, + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__per_split_info * split_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__per_split_info" + } + ] + } + ], + "is_variadic": false, + "prototype_style": "prototype" + }, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6442, + "column": 1, + "source_line": "typedef void stbir__handle_scanline_for_scatter_func(stbir__info const * stbir_info, stbir__per_split_info* split_info);" + }, + "declaration_locations": [] + }, + { + "reference": "STBIR__V_FIRST_INFO" + } + ], + "variables": [], + "macros": [ + { + "name": "STBIR_INCLUDE_STB_IMAGE_RESIZE2_H", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 389, + "column": 1, + "source_line": "#define STBIR_INCLUDE_STB_IMAGE_RESIZE2_H" + } + }, + { + "name": "STBIRDEF", + "value": "static", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 407, + "column": 1, + "source_line": "#define STBIRDEF static" + } + }, + { + "name": "STBIRDEF", + "value": "extern \"C\"", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 410, + "column": 1, + "source_line": "#define STBIRDEF extern \"C\"" + } + }, + { + "name": "STBIRDEF", + "value": "extern", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 412, + "column": 1, + "source_line": "#define STBIRDEF extern" + } + }, + { + "name": "STBIR_ASSERT", + "value": "assert(x)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 787, + "column": 1, + "source_line": "#define STBIR_ASSERT(x) assert(x)" + } + }, + { + "name": "STBIR_MALLOC", + "value": "((void)(user_data), malloc(size))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 792, + "column": 1, + "source_line": "#define STBIR_MALLOC(size,user_data) ((void)(user_data), malloc(size))" + } + }, + { + "name": "STBIR_FREE", + "value": "((void)(user_data), free(ptr))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 793, + "column": 1, + "source_line": "#define STBIR_FREE(ptr,user_data) ((void)(user_data), free(ptr))" + } + }, + { + "name": "stbir__inline", + "value": "__forceinline", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 799, + "column": 1, + "source_line": "#define stbir__inline __forceinline" + } + }, + { + "name": "stbir__inline", + "value": "__inline__", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 803, + "column": 1, + "source_line": "#define stbir__inline __inline__" + } + }, + { + "name": "STBIR__SEPARATE_ALLOCATIONS", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 809, + "column": 7, + "source_line": " #define STBIR__SEPARATE_ALLOCATIONS" + } + }, + { + "name": "STBIR__SEPARATE_ALLOCATIONS", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 819, + "column": 5, + "source_line": " #define STBIR__SEPARATE_ALLOCATIONS" + } + }, + { + "name": "STBIR__UNUSED", + "value": "(void)(v)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 838, + "column": 1, + "source_line": "#define STBIR__UNUSED(v) (void)(v)" + } + }, + { + "name": "STBIR__UNUSED", + "value": "(void)sizeof(v)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 840, + "column": 1, + "source_line": "#define STBIR__UNUSED(v) (void)sizeof(v)" + } + }, + { + "name": "STBIR__ARRAY_SIZE", + "value": "(sizeof((a))/sizeof((a)[0]))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 843, + "column": 1, + "source_line": "#define STBIR__ARRAY_SIZE(a) (sizeof((a))/sizeof((a)[0]))" + } + }, + { + "name": "STBIR_DEFAULT_FILTER_UPSAMPLE", + "value": "STBIR_FILTER_CATMULLROM", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 847, + "column": 1, + "source_line": "#define STBIR_DEFAULT_FILTER_UPSAMPLE STBIR_FILTER_CATMULLROM" + } + }, + { + "name": "STBIR_DEFAULT_FILTER_DOWNSAMPLE", + "value": "STBIR_FILTER_MITCHELL", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 851, + "column": 1, + "source_line": "#define STBIR_DEFAULT_FILTER_DOWNSAMPLE STBIR_FILTER_MITCHELL" + } + }, + { + "name": "STBIR__HEADER_FILENAME", + "value": "\"stb_image_resize2.h\"", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 856, + "column": 1, + "source_line": "#define STBIR__HEADER_FILENAME \"stb_image_resize2.h\"" + } + }, + { + "name": "STBIR_BGR", + "value": "bad_dont_use_in_implementation", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 885, + "column": 1, + "source_line": "#define STBIR_BGR bad_dont_use_in_implementation" + } + }, + { + "name": "STBIR_1CHANNEL", + "value": "STBIR_BGR", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 886, + "column": 1, + "source_line": "#define STBIR_1CHANNEL STBIR_BGR" + } + }, + { + "name": "STBIR_2CHANNEL", + "value": "STBIR_BGR", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 887, + "column": 1, + "source_line": "#define STBIR_2CHANNEL STBIR_BGR" + } + }, + { + "name": "STBIR_RGB", + "value": "STBIR_BGR", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 888, + "column": 1, + "source_line": "#define STBIR_RGB STBIR_BGR" + } + }, + { + "name": "STBIR_RGBA", + "value": "STBIR_BGR", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 889, + "column": 1, + "source_line": "#define STBIR_RGBA STBIR_BGR" + } + }, + { + "name": "STBIR_4CHANNEL", + "value": "STBIR_BGR", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 890, + "column": 1, + "source_line": "#define STBIR_4CHANNEL STBIR_BGR" + } + }, + { + "name": "STBIR_BGRA", + "value": "STBIR_BGR", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 891, + "column": 1, + "source_line": "#define STBIR_BGRA STBIR_BGR" + } + }, + { + "name": "STBIR_ARGB", + "value": "STBIR_BGR", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 892, + "column": 1, + "source_line": "#define STBIR_ARGB STBIR_BGR" + } + }, + { + "name": "STBIR_ABGR", + "value": "STBIR_BGR", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 893, + "column": 1, + "source_line": "#define STBIR_ABGR STBIR_BGR" + } + }, + { + "name": "STBIR_RA", + "value": "STBIR_BGR", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 894, + "column": 1, + "source_line": "#define STBIR_RA STBIR_BGR" + } + }, + { + "name": "STBIR_AR", + "value": "STBIR_BGR", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 895, + "column": 1, + "source_line": "#define STBIR_AR STBIR_BGR" + } + }, + { + "name": "STBIR_RGBA_PM", + "value": "STBIR_BGR", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 896, + "column": 1, + "source_line": "#define STBIR_RGBA_PM STBIR_BGR" + } + }, + { + "name": "STBIR_BGRA_PM", + "value": "STBIR_BGR", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 897, + "column": 1, + "source_line": "#define STBIR_BGRA_PM STBIR_BGR" + } + }, + { + "name": "STBIR_ARGB_PM", + "value": "STBIR_BGR", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 898, + "column": 1, + "source_line": "#define STBIR_ARGB_PM STBIR_BGR" + } + }, + { + "name": "STBIR_ABGR_PM", + "value": "STBIR_BGR", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 899, + "column": 1, + "source_line": "#define STBIR_ABGR_PM STBIR_BGR" + } + }, + { + "name": "STBIR_RA_PM", + "value": "STBIR_BGR", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 900, + "column": 1, + "source_line": "#define STBIR_RA_PM STBIR_BGR" + } + }, + { + "name": "STBIR_AR_PM", + "value": "STBIR_BGR", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 901, + "column": 1, + "source_line": "#define STBIR_AR_PM STBIR_BGR" + } + }, + { + "name": "stbir__max_uint8_as_float", + "value": "255.0f", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1064, + "column": 1, + "source_line": "#define stbir__max_uint8_as_float 255.0f" + } + }, + { + "name": "stbir__max_uint16_as_float", + "value": "65535.0f", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1065, + "column": 1, + "source_line": "#define stbir__max_uint16_as_float 65535.0f" + } + }, + { + "name": "stbir__max_uint8_as_float_inverted", + "value": "3.9215689e-03f", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1066, + "column": 1, + "source_line": "#define stbir__max_uint8_as_float_inverted 3.9215689e-03f // (1.0f/255.0f)" + } + }, + { + "name": "stbir__max_uint16_as_float_inverted", + "value": "1.5259022e-05f", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1067, + "column": 1, + "source_line": "#define stbir__max_uint16_as_float_inverted 1.5259022e-05f // (1.0f/65535.0f)" + } + }, + { + "name": "stbir__small_float", + "value": "((float)1 / (1 << 20) / (1 << 20) / (1 << 20) / (1 << 20) / (1 << 20) / (1 << 20))", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1068, + "column": 1, + "source_line": "#define stbir__small_float ((float)1 / (1 << 20) / (1 << 20) / (1 << 20) / (1 << 20) / (1 << 20) / (1 << 20))" + } + }, + { + "name": "STBIR_CLAMP", + "value": "for(;;) { if ( (x) < (xmin) ) (x) = (xmin); if ( (x) > (xmax) ) (x) = (xmax); break; }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1071, + "column": 1, + "source_line": "#define STBIR_CLAMP(x, xmin, xmax) for(;;) { \\" + } + }, + { + "name": "STBIR_FORCE_GATHER_FILTER_SCANLINES_AMOUNT", + "value": "32", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1165, + "column": 1, + "source_line": "#define STBIR_FORCE_GATHER_FILTER_SCANLINES_AMOUNT 32 // when downsampling and <= 32 scanlines of buffering, use gather. gather used down to 1/8th scaling for 25% win." + } + }, + { + "name": "STBIR_FORCE_MINIMUM_SCANLINES_FOR_SPLITS", + "value": "4", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1169, + "column": 1, + "source_line": "#define STBIR_FORCE_MINIMUM_SCANLINES_FOR_SPLITS 4 // when threading, what is the minimum number of scanlines for a split?" + } + }, + { + "name": "STBIR_INPUT_CALLBACK_PADDING", + "value": "3", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1172, + "column": 1, + "source_line": "#define STBIR_INPUT_CALLBACK_PADDING 3" + } + }, + { + "name": "STBIR_SSE", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1177, + "column": 1, + "source_line": "#define STBIR_SSE" + } + }, + { + "name": "STBIR_NO_SIMD", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1184, + "column": 3, + "source_line": " #define STBIR_NO_SIMD" + } + }, + { + "name": "STBIR_SSE2", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1189, + "column": 5, + "source_line": " #define STBIR_SSE2" + } + }, + { + "name": "STBIR_AVX", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1194, + "column": 9, + "source_line": " #define STBIR_AVX" + } + }, + { + "name": "STBIR_AVX2", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1201, + "column": 9, + "source_line": " #define STBIR_AVX2" + } + }, + { + "name": "STBIR_FP16C", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1205, + "column": 11, + "source_line": " #define STBIR_FP16C" + } + }, + { + "name": "STBIR_FP16C", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1212, + "column": 7, + "source_line": " #define STBIR_FP16C" + } + }, + { + "name": "STBIR_NEON", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1219, + "column": 1, + "source_line": "#define STBIR_NEON" + } + }, + { + "name": "STBIR_USE_FMA", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1225, + "column": 1, + "source_line": "#undef STBIR_USE_FMA // no FMA for 32-bit arm on MSVC" + } + }, + { + "name": "STBIR_WASM", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1231, + "column": 1, + "source_line": "#define STBIR_WASM" + } + }, + { + "name": "STBIR_STREAMOUT_PTR", + "value": "star __restrict", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1237, + "column": 3, + "source_line": " #define STBIR_STREAMOUT_PTR( star ) star __restrict" + } + }, + { + "name": "STBIR_NO_UNROLL", + "value": "__assume(ptr)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1238, + "column": 3, + "source_line": " #define STBIR_NO_UNROLL( ptr ) __assume(ptr) // this oddly keeps msvc from unrolling a loop" + } + }, + { + "name": "STBIR_NO_UNROLL_LOOP_START", + "value": "__pragma(loop( no_vector ))", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1240, + "column": 5, + "source_line": " #define STBIR_NO_UNROLL_LOOP_START __pragma(loop( no_vector )) " + } + }, + { + "name": "STBIR_NO_UNROLL_LOOP_START", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1242, + "column": 5, + "source_line": " #define STBIR_NO_UNROLL_LOOP_START " + } + }, + { + "name": "STBIR_STREAMOUT_PTR", + "value": "star __restrict__", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1245, + "column": 3, + "source_line": " #define STBIR_STREAMOUT_PTR( star ) star __restrict__" + } + }, + { + "name": "STBIR_NO_UNROLL", + "value": "__asm__ (\"\"::\"r\"(ptr))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1246, + "column": 3, + "source_line": " #define STBIR_NO_UNROLL( ptr ) __asm__ (\"\"::\"r\"(ptr)) " + } + }, + { + "name": "STBIR_NO_UNROLL_LOOP_START", + "value": "_Pragma(\"clang loop unroll(disable)\") _Pragma(\"clang loop vectorize(disable)\")", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1248, + "column": 5, + "source_line": " #define STBIR_NO_UNROLL_LOOP_START _Pragma(\"clang loop unroll(disable)\") _Pragma(\"clang loop vectorize(disable)\")" + } + }, + { + "name": "STBIR_NO_UNROLL_LOOP_START", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1250, + "column": 5, + "source_line": " #define STBIR_NO_UNROLL_LOOP_START" + } + }, + { + "name": "STBIR_STREAMOUT_PTR", + "value": "star __restrict__", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1253, + "column": 3, + "source_line": " #define STBIR_STREAMOUT_PTR( star ) star __restrict__" + } + }, + { + "name": "STBIR_NO_UNROLL", + "value": "__asm__ (\"\"::\"r\"(ptr))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1254, + "column": 3, + "source_line": " #define STBIR_NO_UNROLL( ptr ) __asm__ (\"\"::\"r\"(ptr))" + } + }, + { + "name": "STBIR_NO_UNROLL_LOOP_START", + "value": "_Pragma(\"GCC unroll 0\") _Pragma(\"GCC novector\")", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1256, + "column": 5, + "source_line": " #define STBIR_NO_UNROLL_LOOP_START _Pragma(\"GCC unroll 0\") _Pragma(\"GCC novector\")" + } + }, + { + "name": "STBIR_NO_UNROLL_LOOP_START", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1258, + "column": 5, + "source_line": " #define STBIR_NO_UNROLL_LOOP_START" + } + }, + { + "name": "STBIR_NO_UNROLL_LOOP_START_INF_FOR", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1260, + "column": 3, + "source_line": " #define STBIR_NO_UNROLL_LOOP_START_INF_FOR" + } + }, + { + "name": "STBIR_STREAMOUT_PTR", + "value": "star", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1262, + "column": 3, + "source_line": " #define STBIR_STREAMOUT_PTR( star ) star" + } + }, + { + "name": "STBIR_NO_UNROLL", + "value": null, + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1263, + "column": 3, + "source_line": " #define STBIR_NO_UNROLL( ptr )" + } + }, + { + "name": "STBIR_NO_UNROLL_LOOP_START", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1264, + "column": 3, + "source_line": " #define STBIR_NO_UNROLL_LOOP_START" + } + }, + { + "name": "STBIR_NO_UNROLL_LOOP_START_INF_FOR", + "value": "STBIR_NO_UNROLL_LOOP_START", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1268, + "column": 1, + "source_line": "#define STBIR_NO_UNROLL_LOOP_START_INF_FOR STBIR_NO_UNROLL_LOOP_START" + } + }, + { + "name": "STBIR_SSE2", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1276, + "column": 1, + "source_line": "#undef STBIR_SSE2" + } + }, + { + "name": "STBIR_AVX", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1280, + "column": 1, + "source_line": "#undef STBIR_AVX" + } + }, + { + "name": "STBIR_NEON", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1284, + "column": 1, + "source_line": "#undef STBIR_NEON" + } + }, + { + "name": "STBIR_AVX2", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1288, + "column": 1, + "source_line": "#undef STBIR_AVX2" + } + }, + { + "name": "STBIR_FP16C", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1292, + "column": 1, + "source_line": "#undef STBIR_FP16C" + } + }, + { + "name": "STBIR_WASM", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1296, + "column": 1, + "source_line": "#undef STBIR_WASM" + } + }, + { + "name": "STBIR_SIMD", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1300, + "column": 1, + "source_line": "#undef STBIR_SIMD" + } + }, + { + "name": "stbir__simdf", + "value": "__m128", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1308, + "column": 3, + "source_line": " #define stbir__simdf __m128" + } + }, + { + "name": "stbir__simdi", + "value": "__m128i", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1309, + "column": 3, + "source_line": " #define stbir__simdi __m128i" + } + }, + { + "name": "stbir_simdi_castf", + "value": "_mm_castps_si128(reg)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1311, + "column": 3, + "source_line": " #define stbir_simdi_castf( reg ) _mm_castps_si128(reg)" + } + }, + { + "name": "stbir_simdf_casti", + "value": "_mm_castsi128_ps(reg)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1312, + "column": 3, + "source_line": " #define stbir_simdf_casti( reg ) _mm_castsi128_ps(reg)" + } + }, + { + "name": "stbir__simdf_load", + "value": "(reg) = _mm_loadu_ps( (float const*)(ptr) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1314, + "column": 3, + "source_line": " #define stbir__simdf_load( reg, ptr ) (reg) = _mm_loadu_ps( (float const*)(ptr) )" + } + }, + { + "name": "stbir__simdi_load", + "value": "(reg) = _mm_loadu_si128 ( (stbir__simdi const*)(ptr) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1315, + "column": 3, + "source_line": " #define stbir__simdi_load( reg, ptr ) (reg) = _mm_loadu_si128 ( (stbir__simdi const*)(ptr) )" + } + }, + { + "name": "stbir__simdf_load1", + "value": "(out) = _mm_load_ss( (float const*)(ptr) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1316, + "column": 3, + "source_line": " #define stbir__simdf_load1( out, ptr ) (out) = _mm_load_ss( (float const*)(ptr) ) // top values can be random (not denormal or nan for perf)" + } + }, + { + "name": "stbir__simdi_load1", + "value": "(out) = _mm_castps_si128( _mm_load_ss( (float const*)(ptr) ))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1317, + "column": 3, + "source_line": " #define stbir__simdi_load1( out, ptr ) (out) = _mm_castps_si128( _mm_load_ss( (float const*)(ptr) ))" + } + }, + { + "name": "stbir__simdf_load1z", + "value": "(out) = _mm_load_ss( (float const*)(ptr) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1318, + "column": 3, + "source_line": " #define stbir__simdf_load1z( out, ptr ) (out) = _mm_load_ss( (float const*)(ptr) ) // top values must be zero" + } + }, + { + "name": "stbir__simdf_frep4", + "value": "_mm_set_ps1( fvar )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1319, + "column": 3, + "source_line": " #define stbir__simdf_frep4( fvar ) _mm_set_ps1( fvar )" + } + }, + { + "name": "stbir__simdf_load1frep4", + "value": "(out) = _mm_set_ps1( fvar )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1320, + "column": 3, + "source_line": " #define stbir__simdf_load1frep4( out, fvar ) (out) = _mm_set_ps1( fvar )" + } + }, + { + "name": "stbir__simdf_load2", + "value": "(out) = _mm_castsi128_ps( _mm_loadl_epi64( (__m128i*)(ptr)) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1321, + "column": 3, + "source_line": " #define stbir__simdf_load2( out, ptr ) (out) = _mm_castsi128_ps( _mm_loadl_epi64( (__m128i*)(ptr)) ) // top values can be random (not denormal or nan for perf)" + } + }, + { + "name": "stbir__simdf_load2z", + "value": "(out) = _mm_castsi128_ps( _mm_loadl_epi64( (__m128i*)(ptr)) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1322, + "column": 3, + "source_line": " #define stbir__simdf_load2z( out, ptr ) (out) = _mm_castsi128_ps( _mm_loadl_epi64( (__m128i*)(ptr)) ) // top values must be zero" + } + }, + { + "name": "stbir__simdf_load2hmerge", + "value": "(out) = _mm_castpd_ps(_mm_loadh_pd( _mm_castps_pd(reg), (double*)(ptr) ))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1323, + "column": 3, + "source_line": " #define stbir__simdf_load2hmerge( out, reg, ptr ) (out) = _mm_castpd_ps(_mm_loadh_pd( _mm_castps_pd(reg), (double*)(ptr) ))" + } + }, + { + "name": "stbir__simdf_zeroP", + "value": "_mm_setzero_ps()", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1325, + "column": 3, + "source_line": " #define stbir__simdf_zeroP() _mm_setzero_ps()" + } + }, + { + "name": "stbir__simdf_zero", + "value": "(reg) = _mm_setzero_ps()", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1326, + "column": 3, + "source_line": " #define stbir__simdf_zero( reg ) (reg) = _mm_setzero_ps()" + } + }, + { + "name": "stbir__simdf_store", + "value": "_mm_storeu_ps( (float*)(ptr), reg )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1328, + "column": 3, + "source_line": " #define stbir__simdf_store( ptr, reg ) _mm_storeu_ps( (float*)(ptr), reg )" + } + }, + { + "name": "stbir__simdf_store1", + "value": "_mm_store_ss( (float*)(ptr), reg )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1329, + "column": 3, + "source_line": " #define stbir__simdf_store1( ptr, reg ) _mm_store_ss( (float*)(ptr), reg )" + } + }, + { + "name": "stbir__simdf_store2", + "value": "_mm_storel_epi64( (__m128i*)(ptr), _mm_castps_si128(reg) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1330, + "column": 3, + "source_line": " #define stbir__simdf_store2( ptr, reg ) _mm_storel_epi64( (__m128i*)(ptr), _mm_castps_si128(reg) )" + } + }, + { + "name": "stbir__simdf_store2h", + "value": "_mm_storeh_pd( (double*)(ptr), _mm_castps_pd(reg) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1331, + "column": 3, + "source_line": " #define stbir__simdf_store2h( ptr, reg ) _mm_storeh_pd( (double*)(ptr), _mm_castps_pd(reg) )" + } + }, + { + "name": "stbir__simdi_store", + "value": "_mm_storeu_si128( (__m128i*)(ptr), reg )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1333, + "column": 3, + "source_line": " #define stbir__simdi_store( ptr, reg ) _mm_storeu_si128( (__m128i*)(ptr), reg )" + } + }, + { + "name": "stbir__simdi_store1", + "value": "_mm_store_ss( (float*)(ptr), _mm_castsi128_ps(reg) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1334, + "column": 3, + "source_line": " #define stbir__simdi_store1( ptr, reg ) _mm_store_ss( (float*)(ptr), _mm_castsi128_ps(reg) )" + } + }, + { + "name": "stbir__simdi_store2", + "value": "_mm_storel_epi64( (__m128i*)(ptr), (reg) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1335, + "column": 3, + "source_line": " #define stbir__simdi_store2( ptr, reg ) _mm_storel_epi64( (__m128i*)(ptr), (reg) )" + } + }, + { + "name": "stbir__prefetch", + "value": "_mm_prefetch((char*)(ptr), _MM_HINT_T0 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1337, + "column": 3, + "source_line": " #define stbir__prefetch( ptr ) _mm_prefetch((char*)(ptr), _MM_HINT_T0 )" + } + }, + { + "name": "stbir__simdi_expand_u8_to_u32", + "value": "{ stbir__simdi zero = _mm_setzero_si128(); out2 = _mm_unpacklo_epi8( ireg, zero ); out3 = _mm_unpackhi_epi8( ireg, zero ); out0 = _mm_unpacklo_epi16( out2, zero ); out1 = _mm_unpackhi_epi16( out2, zero ); out2 = _mm_unpacklo_epi16( out3, zero ); out3 = _mm_unpackhi_epi16( out3, zero ); }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1339, + "column": 3, + "source_line": " #define stbir__simdi_expand_u8_to_u32(out0,out1,out2,out3,ireg) \\" + } + }, + { + "name": "stbir__simdi_expand_u8_to_1u32", + "value": "{ stbir__simdi zero = _mm_setzero_si128(); out = _mm_unpacklo_epi8( ireg, zero ); out = _mm_unpacklo_epi16( out, zero ); }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1350, + "column": 1, + "source_line": "#define stbir__simdi_expand_u8_to_1u32(out,ireg) \\" + } + }, + { + "name": "stbir__simdi_expand_u16_to_u32", + "value": "{ stbir__simdi zero = _mm_setzero_si128(); out0 = _mm_unpacklo_epi16( ireg, zero ); out1 = _mm_unpackhi_epi16( ireg, zero ); }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1357, + "column": 3, + "source_line": " #define stbir__simdi_expand_u16_to_u32(out0,out1,ireg) \\" + } + }, + { + "name": "stbir__simdf_convert_float_to_i32", + "value": "(i) = _mm_cvttps_epi32(f)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1364, + "column": 3, + "source_line": " #define stbir__simdf_convert_float_to_i32( i, f ) (i) = _mm_cvttps_epi32(f)" + } + }, + { + "name": "stbir__simdf_convert_float_to_int", + "value": "_mm_cvtt_ss2si(f)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1365, + "column": 3, + "source_line": " #define stbir__simdf_convert_float_to_int( f ) _mm_cvtt_ss2si(f)" + } + }, + { + "name": "stbir__simdf_convert_float_to_uint8", + "value": "((unsigned char)_mm_cvtsi128_si32(_mm_cvttps_epi32(_mm_max_ps(_mm_min_ps(f,STBIR__CONSTF(STBIR_max_uint8_as_float)),_mm_setzero_ps()))))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1366, + "column": 3, + "source_line": " #define stbir__simdf_convert_float_to_uint8( f ) ((unsigned char)_mm_cvtsi128_si32(_mm_cvttps_epi32(_mm_max_ps(_mm_min_ps(f,STBIR__CONSTF(STBIR_max_uint8_as_float)),_mm_setzero_ps()))))" + } + }, + { + "name": "stbir__simdf_convert_float_to_short", + "value": "((unsigned short)_mm_cvtsi128_si32(_mm_cvttps_epi32(_mm_max_ps(_mm_min_ps(f,STBIR__CONSTF(STBIR_max_uint16_as_float)),_mm_setzero_ps()))))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1367, + "column": 3, + "source_line": " #define stbir__simdf_convert_float_to_short( f ) ((unsigned short)_mm_cvtsi128_si32(_mm_cvttps_epi32(_mm_max_ps(_mm_min_ps(f,STBIR__CONSTF(STBIR_max_uint16_as_float)),_mm_setzero_ps()))))" + } + }, + { + "name": "stbir__simdi_to_int", + "value": "_mm_cvtsi128_si32(i)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1369, + "column": 3, + "source_line": " #define stbir__simdi_to_int( i ) _mm_cvtsi128_si32(i)" + } + }, + { + "name": "stbir__simdi_convert_i32_to_float", + "value": "(out) = _mm_cvtepi32_ps( ireg )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1370, + "column": 3, + "source_line": " #define stbir__simdi_convert_i32_to_float(out, ireg) (out) = _mm_cvtepi32_ps( ireg )" + } + }, + { + "name": "stbir__simdf_add", + "value": "(out) = _mm_add_ps( reg0, reg1 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1371, + "column": 3, + "source_line": " #define stbir__simdf_add( out, reg0, reg1 ) (out) = _mm_add_ps( reg0, reg1 )" + } + }, + { + "name": "stbir__simdf_mult", + "value": "(out) = _mm_mul_ps( reg0, reg1 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1372, + "column": 3, + "source_line": " #define stbir__simdf_mult( out, reg0, reg1 ) (out) = _mm_mul_ps( reg0, reg1 )" + } + }, + { + "name": "stbir__simdf_mult_mem", + "value": "(out) = _mm_mul_ps( reg, _mm_loadu_ps( (float const*)(ptr) ) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1373, + "column": 3, + "source_line": " #define stbir__simdf_mult_mem( out, reg, ptr ) (out) = _mm_mul_ps( reg, _mm_loadu_ps( (float const*)(ptr) ) )" + } + }, + { + "name": "stbir__simdf_mult1_mem", + "value": "(out) = _mm_mul_ss( reg, _mm_load_ss( (float const*)(ptr) ) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1374, + "column": 3, + "source_line": " #define stbir__simdf_mult1_mem( out, reg, ptr ) (out) = _mm_mul_ss( reg, _mm_load_ss( (float const*)(ptr) ) )" + } + }, + { + "name": "stbir__simdf_add_mem", + "value": "(out) = _mm_add_ps( reg, _mm_loadu_ps( (float const*)(ptr) ) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1375, + "column": 3, + "source_line": " #define stbir__simdf_add_mem( out, reg, ptr ) (out) = _mm_add_ps( reg, _mm_loadu_ps( (float const*)(ptr) ) )" + } + }, + { + "name": "stbir__simdf_add1_mem", + "value": "(out) = _mm_add_ss( reg, _mm_load_ss( (float const*)(ptr) ) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1376, + "column": 3, + "source_line": " #define stbir__simdf_add1_mem( out, reg, ptr ) (out) = _mm_add_ss( reg, _mm_load_ss( (float const*)(ptr) ) )" + } + }, + { + "name": "stbir__simdf_madd", + "value": "(out) = _mm_fmadd_ps( mul1, mul2, add )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1380, + "column": 3, + "source_line": " #define stbir__simdf_madd( out, add, mul1, mul2 ) (out) = _mm_fmadd_ps( mul1, mul2, add )" + } + }, + { + "name": "stbir__simdf_madd1", + "value": "(out) = _mm_fmadd_ss( mul1, mul2, add )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1381, + "column": 3, + "source_line": " #define stbir__simdf_madd1( out, add, mul1, mul2 ) (out) = _mm_fmadd_ss( mul1, mul2, add )" + } + }, + { + "name": "stbir__simdf_madd_mem", + "value": "(out) = _mm_fmadd_ps( mul, _mm_loadu_ps( (float const*)(ptr) ), add )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1382, + "column": 3, + "source_line": " #define stbir__simdf_madd_mem( out, add, mul, ptr ) (out) = _mm_fmadd_ps( mul, _mm_loadu_ps( (float const*)(ptr) ), add )" + } + }, + { + "name": "stbir__simdf_madd1_mem", + "value": "(out) = _mm_fmadd_ss( mul, _mm_load_ss( (float const*)(ptr) ), add )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1383, + "column": 3, + "source_line": " #define stbir__simdf_madd1_mem( out, add, mul, ptr ) (out) = _mm_fmadd_ss( mul, _mm_load_ss( (float const*)(ptr) ), add )" + } + }, + { + "name": "stbir__simdf_madd", + "value": "(out) = _mm_add_ps( add, _mm_mul_ps( mul1, mul2 ) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1385, + "column": 3, + "source_line": " #define stbir__simdf_madd( out, add, mul1, mul2 ) (out) = _mm_add_ps( add, _mm_mul_ps( mul1, mul2 ) )" + } + }, + { + "name": "stbir__simdf_madd1", + "value": "(out) = _mm_add_ss( add, _mm_mul_ss( mul1, mul2 ) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1386, + "column": 3, + "source_line": " #define stbir__simdf_madd1( out, add, mul1, mul2 ) (out) = _mm_add_ss( add, _mm_mul_ss( mul1, mul2 ) )" + } + }, + { + "name": "stbir__simdf_madd_mem", + "value": "(out) = _mm_add_ps( add, _mm_mul_ps( mul, _mm_loadu_ps( (float const*)(ptr) ) ) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1387, + "column": 3, + "source_line": " #define stbir__simdf_madd_mem( out, add, mul, ptr ) (out) = _mm_add_ps( add, _mm_mul_ps( mul, _mm_loadu_ps( (float const*)(ptr) ) ) )" + } + }, + { + "name": "stbir__simdf_madd1_mem", + "value": "(out) = _mm_add_ss( add, _mm_mul_ss( mul, _mm_load_ss( (float const*)(ptr) ) ) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1388, + "column": 3, + "source_line": " #define stbir__simdf_madd1_mem( out, add, mul, ptr ) (out) = _mm_add_ss( add, _mm_mul_ss( mul, _mm_load_ss( (float const*)(ptr) ) ) )" + } + }, + { + "name": "stbir__simdf_add1", + "value": "(out) = _mm_add_ss( reg0, reg1 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1391, + "column": 3, + "source_line": " #define stbir__simdf_add1( out, reg0, reg1 ) (out) = _mm_add_ss( reg0, reg1 )" + } + }, + { + "name": "stbir__simdf_mult1", + "value": "(out) = _mm_mul_ss( reg0, reg1 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1392, + "column": 3, + "source_line": " #define stbir__simdf_mult1( out, reg0, reg1 ) (out) = _mm_mul_ss( reg0, reg1 )" + } + }, + { + "name": "stbir__simdf_and", + "value": "(out) = _mm_and_ps( reg0, reg1 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1394, + "column": 3, + "source_line": " #define stbir__simdf_and( out, reg0, reg1 ) (out) = _mm_and_ps( reg0, reg1 )" + } + }, + { + "name": "stbir__simdf_or", + "value": "(out) = _mm_or_ps( reg0, reg1 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1395, + "column": 3, + "source_line": " #define stbir__simdf_or( out, reg0, reg1 ) (out) = _mm_or_ps( reg0, reg1 )" + } + }, + { + "name": "stbir__simdf_min", + "value": "(out) = _mm_min_ps( reg0, reg1 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1397, + "column": 3, + "source_line": " #define stbir__simdf_min( out, reg0, reg1 ) (out) = _mm_min_ps( reg0, reg1 )" + } + }, + { + "name": "stbir__simdf_max", + "value": "(out) = _mm_max_ps( reg0, reg1 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1398, + "column": 3, + "source_line": " #define stbir__simdf_max( out, reg0, reg1 ) (out) = _mm_max_ps( reg0, reg1 )" + } + }, + { + "name": "stbir__simdf_min1", + "value": "(out) = _mm_min_ss( reg0, reg1 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1399, + "column": 3, + "source_line": " #define stbir__simdf_min1( out, reg0, reg1 ) (out) = _mm_min_ss( reg0, reg1 )" + } + }, + { + "name": "stbir__simdf_max1", + "value": "(out) = _mm_max_ss( reg0, reg1 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1400, + "column": 3, + "source_line": " #define stbir__simdf_max1( out, reg0, reg1 ) (out) = _mm_max_ss( reg0, reg1 )" + } + }, + { + "name": "stbir__simdf_0123ABCDto3ABx", + "value": "(out)=_mm_castsi128_ps( _mm_shuffle_epi32( _mm_castps_si128( _mm_shuffle_ps( reg1,reg0, (0<<0) + (1<<2) + (2<<4) + (3<<6) )), (3<<0) + (0<<2) + (1<<4) + (2<<6) ) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1402, + "column": 3, + "source_line": " #define stbir__simdf_0123ABCDto3ABx( out, reg0, reg1 ) (out)=_mm_castsi128_ps( _mm_shuffle_epi32( _mm_castps_si128( _mm_shuffle_ps( reg1,reg0, (0<<0) + (1<<2) + (2<<4) + (3<<6) )), (3<<0) + (0<<2) + (1<<4) + (2<<6) ) )" + } + }, + { + "name": "stbir__simdf_0123ABCDto23Ax", + "value": "(out)=_mm_castsi128_ps( _mm_shuffle_epi32( _mm_castps_si128( _mm_shuffle_ps( reg1,reg0, (0<<0) + (1<<2) + (2<<4) + (3<<6) )), (2<<0) + (3<<2) + (0<<4) + (1<<6) ) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1403, + "column": 3, + "source_line": " #define stbir__simdf_0123ABCDto23Ax( out, reg0, reg1 ) (out)=_mm_castsi128_ps( _mm_shuffle_epi32( _mm_castps_si128( _mm_shuffle_ps( reg1,reg0, (0<<0) + (1<<2) + (2<<4) + (3<<6) )), (2<<0) + (3<<2) + (0<<4) + (1<<6) ) )" + } + }, + { + "name": "stbir__simdf_aaa1", + "value": "(out)=_mm_castsi128_ps( _mm_shuffle_epi32( _mm_castps_si128( _mm_movehl_ps( ones, alp ) ), (1<<0) + (1<<2) + (1<<4) + (2<<6) ) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1407, + "column": 3, + "source_line": " #define stbir__simdf_aaa1( out, alp, ones ) (out)=_mm_castsi128_ps( _mm_shuffle_epi32( _mm_castps_si128( _mm_movehl_ps( ones, alp ) ), (1<<0) + (1<<2) + (1<<4) + (2<<6) ) )" + } + }, + { + "name": "stbir__simdf_1aaa", + "value": "(out)=_mm_castsi128_ps( _mm_shuffle_epi32( _mm_castps_si128( _mm_movelh_ps( ones, alp ) ), (0<<0) + (2<<2) + (2<<4) + (2<<6) ) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1408, + "column": 3, + "source_line": " #define stbir__simdf_1aaa( out, alp, ones ) (out)=_mm_castsi128_ps( _mm_shuffle_epi32( _mm_castps_si128( _mm_movelh_ps( ones, alp ) ), (0<<0) + (2<<2) + (2<<4) + (2<<6) ) )" + } + }, + { + "name": "stbir__simdf_a1a1", + "value": "(out) = _mm_or_ps( _mm_castsi128_ps( _mm_srli_epi64( _mm_castps_si128(alp), 32 ) ), STBIR_zeroones )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1409, + "column": 3, + "source_line": " #define stbir__simdf_a1a1( out, alp, ones) (out) = _mm_or_ps( _mm_castsi128_ps( _mm_srli_epi64( _mm_castps_si128(alp), 32 ) ), STBIR_zeroones )" + } + }, + { + "name": "stbir__simdf_1a1a", + "value": "(out) = _mm_or_ps( _mm_castsi128_ps( _mm_slli_epi64( _mm_castps_si128(alp), 32 ) ), STBIR_onezeros )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1410, + "column": 3, + "source_line": " #define stbir__simdf_1a1a( out, alp, ones) (out) = _mm_or_ps( _mm_castsi128_ps( _mm_slli_epi64( _mm_castps_si128(alp), 32 ) ), STBIR_onezeros )" + } + }, + { + "name": "stbir__simdf_swiz", + "value": "_mm_castsi128_ps( _mm_shuffle_epi32( _mm_castps_si128( reg ), (one<<0) + (two<<2) + (three<<4) + (four<<6) ) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1412, + "column": 3, + "source_line": " #define stbir__simdf_swiz( reg, one, two, three, four ) _mm_castsi128_ps( _mm_shuffle_epi32( _mm_castps_si128( reg ), (one<<0) + (two<<2) + (three<<4) + (four<<6) ) )" + } + }, + { + "name": "stbir__simdi_and", + "value": "(out) = _mm_and_si128( reg0, reg1 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1414, + "column": 3, + "source_line": " #define stbir__simdi_and( out, reg0, reg1 ) (out) = _mm_and_si128( reg0, reg1 )" + } + }, + { + "name": "stbir__simdi_or", + "value": "(out) = _mm_or_si128( reg0, reg1 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1415, + "column": 3, + "source_line": " #define stbir__simdi_or( out, reg0, reg1 ) (out) = _mm_or_si128( reg0, reg1 )" + } + }, + { + "name": "stbir__simdi_16madd", + "value": "(out) = _mm_madd_epi16( reg0, reg1 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1416, + "column": 3, + "source_line": " #define stbir__simdi_16madd( out, reg0, reg1 ) (out) = _mm_madd_epi16( reg0, reg1 )" + } + }, + { + "name": "stbir__simdf_pack_to_8bytes", + "value": "{ stbir__simdf af,bf; stbir__simdi a,b; af = _mm_min_ps( aa, STBIR_max_uint8_as_float ); bf = _mm_min_ps( bb, STBIR_max_uint8_as_float ); af = _mm_max_ps( af, _mm_setzero_ps() ); bf = _mm_max_ps( bf, _mm_setzero_ps() ); a = _mm_cvttps_epi32( af ); b = _mm_cvttps_epi32( bf ); a = _mm_packs_epi32( a, b ); out = _mm_packus_epi16( a, a ); }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1418, + "column": 3, + "source_line": " #define stbir__simdf_pack_to_8bytes(out,aa,bb) \\" + } + }, + { + "name": "stbir__simdf_load4_transposed", + "value": "stbir__simdf_load( o0, (ptr) ); stbir__simdf_load( o1, (ptr)+4 ); stbir__simdf_load( o2, (ptr)+8 ); stbir__simdf_load( o3, (ptr)+12 ); { __m128 tmp0, tmp1, tmp2, tmp3; tmp0 = _mm_unpacklo_ps(o0, o1); tmp2 = _mm_unpacklo_ps(o2, o3); tmp1 = _mm_unpackhi_ps(o0, o1); tmp3 = _mm_unpackhi_ps(o2, o3); o0 = _mm_movelh_ps(tmp0, tmp2); o1 = _mm_movehl_ps(tmp2, tmp0); o2 = _mm_movelh_ps(tmp1, tmp3); o3 = _mm_movehl_ps(tmp3, tmp1); }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1432, + "column": 3, + "source_line": " #define stbir__simdf_load4_transposed( o0, o1, o2, o3, ptr ) \\" + } + }, + { + "name": "stbir__interleave_pack_and_store_16_u8", + "value": "r0 = _mm_packs_epi32( r0, r1 ); r2 = _mm_packs_epi32( r2, r3 ); r1 = _mm_unpacklo_epi16( r0, r2 ); r3 = _mm_unpackhi_epi16( r0, r2 ); r0 = _mm_unpacklo_epi16( r1, r3 ); r2 = _mm_unpackhi_epi16( r1, r3 ); r0 = _mm_packus_epi16( r0, r2 ); stbir__simdi_store( ptr, r0 );", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1449, + "column": 3, + "source_line": " #define stbir__interleave_pack_and_store_16_u8( ptr, r0, r1, r2, r3 ) \\" + } + }, + { + "name": "stbir__simdi_32shr", + "value": "out = _mm_srli_epi32( reg, imm )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1459, + "column": 3, + "source_line": " #define stbir__simdi_32shr( out, reg, imm ) out = _mm_srli_epi32( reg, imm )" + } + }, + { + "name": "STBIR__CONST_32_TO_8", + "value": "(char)(unsigned char)((v)&255),(char)(unsigned char)(((v)>>8)&255),(char)(unsigned char)(((v)>>16)&255),(char)(unsigned char)(((v)>>24)&255)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1463, + "column": 5, + "source_line": " #define STBIR__CONST_32_TO_8( v ) (char)(unsigned char)((v)&255),(char)(unsigned char)(((v)>>8)&255),(char)(unsigned char)(((v)>>16)&255),(char)(unsigned char)(((v)>>24)&255)" + } + }, + { + "name": "STBIR__CONST_4_32i", + "value": "STBIR__CONST_32_TO_8( v ), STBIR__CONST_32_TO_8( v ), STBIR__CONST_32_TO_8( v ), STBIR__CONST_32_TO_8( v )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1464, + "column": 5, + "source_line": " #define STBIR__CONST_4_32i( v ) STBIR__CONST_32_TO_8( v ), STBIR__CONST_32_TO_8( v ), STBIR__CONST_32_TO_8( v ), STBIR__CONST_32_TO_8( v )" + } + }, + { + "name": "STBIR__CONST_4d_32i", + "value": "STBIR__CONST_32_TO_8( v0 ), STBIR__CONST_32_TO_8( v1 ), STBIR__CONST_32_TO_8( v2 ), STBIR__CONST_32_TO_8( v3 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1465, + "column": 5, + "source_line": " #define STBIR__CONST_4d_32i( v0, v1, v2, v3 ) STBIR__CONST_32_TO_8( v0 ), STBIR__CONST_32_TO_8( v1 ), STBIR__CONST_32_TO_8( v2 ), STBIR__CONST_32_TO_8( v3 )" + } + }, + { + "name": "STBIR__CONST_4_32i", + "value": "(long long)((((stbir_uint64)(stbir_uint32)(v))<<32)|((stbir_uint64)(stbir_uint32)(v))),(long long)((((stbir_uint64)(stbir_uint32)(v))<<32)|((stbir_uint64)(stbir_uint32)(v)))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1468, + "column": 5, + "source_line": " #define STBIR__CONST_4_32i( v ) (long long)((((stbir_uint64)(stbir_uint32)(v))<<32)|((stbir_uint64)(stbir_uint32)(v))),(long long)((((stbir_uint64)(stbir_uint32)(v))<<32)|((stbir_uint64)(stbir_uint32)(v)))" + } + }, + { + "name": "STBIR__CONST_4d_32i", + "value": "(long long)((((stbir_uint64)(stbir_uint32)(v1))<<32)|((stbir_uint64)(stbir_uint32)(v0))),(long long)((((stbir_uint64)(stbir_uint32)(v3))<<32)|((stbir_uint64)(stbir_uint32)(v2)))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1469, + "column": 5, + "source_line": " #define STBIR__CONST_4d_32i( v0, v1, v2, v3 ) (long long)((((stbir_uint64)(stbir_uint32)(v1))<<32)|((stbir_uint64)(stbir_uint32)(v0))),(long long)((((stbir_uint64)(stbir_uint32)(v3))<<32)|((stbir_uint64)(stbir_uint32)(v2)))" + } + }, + { + "name": "STBIR__SIMDF_CONST", + "value": "stbir__simdf var = { x, x, x, x }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1472, + "column": 3, + "source_line": " #define STBIR__SIMDF_CONST(var, x) stbir__simdf var = { x, x, x, x }" + } + }, + { + "name": "STBIR__SIMDI_CONST", + "value": "stbir__simdi var = { STBIR__CONST_4_32i(x) }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1473, + "column": 3, + "source_line": " #define STBIR__SIMDI_CONST(var, x) stbir__simdi var = { STBIR__CONST_4_32i(x) }" + } + }, + { + "name": "STBIR__CONSTF", + "value": "(var)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1474, + "column": 3, + "source_line": " #define STBIR__CONSTF(var) (var)" + } + }, + { + "name": "STBIR__CONSTI", + "value": "(var)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1475, + "column": 3, + "source_line": " #define STBIR__CONSTI(var) (var)" + } + }, + { + "name": "stbir__simdf_pack_to_8words", + "value": "out = _mm_packus_epi32(_mm_cvttps_epi32(_mm_max_ps(_mm_min_ps(reg0,STBIR__CONSTF(STBIR_max_uint16_as_float)),_mm_setzero_ps())), _mm_cvttps_epi32(_mm_max_ps(_mm_min_ps(reg1,STBIR__CONSTF(STBIR_max_uint16_as_float)),_mm_setzero_ps())))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1479, + "column": 5, + "source_line": " #define stbir__simdf_pack_to_8words(out,reg0,reg1) out = _mm_packus_epi32(_mm_cvttps_epi32(_mm_max_ps(_mm_min_ps(reg0,STBIR__CONSTF(STBIR_max_uint16_as_float)),_mm_setzero_ps())), _mm_cvttps_epi32(_mm_max_ps(_mm_min_ps(reg1,STBIR__CONSTF(STBIR_max_uint16_as_float)),_mm_setzero_ps())))" + } + }, + { + "name": "stbir__simdf_pack_to_8words", + "value": "{ stbir__simdi tmp0,tmp1; tmp0 = _mm_cvttps_epi32(_mm_max_ps(_mm_min_ps(reg0,STBIR__CONSTF(STBIR_max_uint16_as_float)),_mm_setzero_ps())); tmp1 = _mm_cvttps_epi32(_mm_max_ps(_mm_min_ps(reg1,STBIR__CONSTF(STBIR_max_uint16_as_float)),_mm_setzero_ps())); tmp0 = _mm_sub_epi32( tmp0, stbir__s32_32768 ); tmp1 = _mm_sub_epi32( tmp1, stbir__s32_32768 ); out = _mm_packs_epi32( tmp0, tmp1 ); out = _mm_sub_epi16( out, stbir__s16_32768 ); }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1484, + "column": 5, + "source_line": " #define stbir__simdf_pack_to_8words(out,reg0,reg1) \\" + } + }, + { + "name": "STBIR_SIMD", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1497, + "column": 3, + "source_line": " #define STBIR_SIMD" + } + }, + { + "name": "STBIR_SIMD8", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1502, + "column": 5, + "source_line": " #define STBIR_SIMD8" + } + }, + { + "name": "stbir__simdf8", + "value": "__m256", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1503, + "column": 5, + "source_line": " #define stbir__simdf8 __m256" + } + }, + { + "name": "stbir__simdi8", + "value": "__m256i", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1504, + "column": 5, + "source_line": " #define stbir__simdi8 __m256i" + } + }, + { + "name": "stbir__simdf8_load", + "value": "(out) = _mm256_loadu_ps( (float const *)(ptr) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1505, + "column": 5, + "source_line": " #define stbir__simdf8_load( out, ptr ) (out) = _mm256_loadu_ps( (float const *)(ptr) )" + } + }, + { + "name": "stbir__simdi8_load", + "value": "(out) = _mm256_loadu_si256( (__m256i const *)(ptr) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1506, + "column": 5, + "source_line": " #define stbir__simdi8_load( out, ptr ) (out) = _mm256_loadu_si256( (__m256i const *)(ptr) )" + } + }, + { + "name": "stbir__simdf8_mult", + "value": "(out) = _mm256_mul_ps( (a), (b) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1507, + "column": 5, + "source_line": " #define stbir__simdf8_mult( out, a, b ) (out) = _mm256_mul_ps( (a), (b) )" + } + }, + { + "name": "stbir__simdf8_store", + "value": "_mm256_storeu_ps( (float*)(ptr), out )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1508, + "column": 5, + "source_line": " #define stbir__simdf8_store( ptr, out ) _mm256_storeu_ps( (float*)(ptr), out )" + } + }, + { + "name": "stbir__simdi8_store", + "value": "_mm256_storeu_si256( (__m256i*)(ptr), reg )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1509, + "column": 5, + "source_line": " #define stbir__simdi8_store( ptr, reg ) _mm256_storeu_si256( (__m256i*)(ptr), reg )" + } + }, + { + "name": "stbir__simdf8_frep8", + "value": "_mm256_set1_ps( fval )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1510, + "column": 5, + "source_line": " #define stbir__simdf8_frep8( fval ) _mm256_set1_ps( fval )" + } + }, + { + "name": "stbir__simdf8_min", + "value": "(out) = _mm256_min_ps( reg0, reg1 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1512, + "column": 5, + "source_line": " #define stbir__simdf8_min( out, reg0, reg1 ) (out) = _mm256_min_ps( reg0, reg1 )" + } + }, + { + "name": "stbir__simdf8_max", + "value": "(out) = _mm256_max_ps( reg0, reg1 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1513, + "column": 5, + "source_line": " #define stbir__simdf8_max( out, reg0, reg1 ) (out) = _mm256_max_ps( reg0, reg1 )" + } + }, + { + "name": "stbir__simdf8_add4halves", + "value": "(out) = _mm_add_ps( bot4, _mm256_extractf128_ps( top8, 1 ) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1515, + "column": 5, + "source_line": " #define stbir__simdf8_add4halves( out, bot4, top8 ) (out) = _mm_add_ps( bot4, _mm256_extractf128_ps( top8, 1 ) )" + } + }, + { + "name": "stbir__simdf8_mult_mem", + "value": "(out) = _mm256_mul_ps( reg, _mm256_loadu_ps( (float const*)(ptr) ) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1516, + "column": 5, + "source_line": " #define stbir__simdf8_mult_mem( out, reg, ptr ) (out) = _mm256_mul_ps( reg, _mm256_loadu_ps( (float const*)(ptr) ) )" + } + }, + { + "name": "stbir__simdf8_add_mem", + "value": "(out) = _mm256_add_ps( reg, _mm256_loadu_ps( (float const*)(ptr) ) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1517, + "column": 5, + "source_line": " #define stbir__simdf8_add_mem( out, reg, ptr ) (out) = _mm256_add_ps( reg, _mm256_loadu_ps( (float const*)(ptr) ) )" + } + }, + { + "name": "stbir__simdf8_add", + "value": "(out) = _mm256_add_ps( a, b )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1518, + "column": 5, + "source_line": " #define stbir__simdf8_add( out, a, b ) (out) = _mm256_add_ps( a, b )" + } + }, + { + "name": "stbir__simdf8_load1b", + "value": "(out) = _mm256_broadcast_ss( ptr )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1519, + "column": 5, + "source_line": " #define stbir__simdf8_load1b( out, ptr ) (out) = _mm256_broadcast_ss( ptr )" + } + }, + { + "name": "stbir__simdf_load1rep4", + "value": "(out) = _mm_broadcast_ss( ptr )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1520, + "column": 5, + "source_line": " #define stbir__simdf_load1rep4( out, ptr ) (out) = _mm_broadcast_ss( ptr ) // avx load instruction" + } + }, + { + "name": "stbir__simdi8_convert_i32_to_float", + "value": "(out) = _mm256_cvtepi32_ps( ireg )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1522, + "column": 5, + "source_line": " #define stbir__simdi8_convert_i32_to_float(out, ireg) (out) = _mm256_cvtepi32_ps( ireg )" + } + }, + { + "name": "stbir__simdf8_convert_float_to_i32", + "value": "(i) = _mm256_cvttps_epi32(f)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1523, + "column": 5, + "source_line": " #define stbir__simdf8_convert_float_to_i32( i, f ) (i) = _mm256_cvttps_epi32(f)" + } + }, + { + "name": "stbir__simdf8_bot4s", + "value": "(out) = _mm256_permute2f128_ps(a,b, (0<<0)+(2<<4) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1525, + "column": 5, + "source_line": " #define stbir__simdf8_bot4s( out, a, b ) (out) = _mm256_permute2f128_ps(a,b, (0<<0)+(2<<4) )" + } + }, + { + "name": "stbir__simdf8_top4s", + "value": "(out) = _mm256_permute2f128_ps(a,b, (1<<0)+(3<<4) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1526, + "column": 5, + "source_line": " #define stbir__simdf8_top4s( out, a, b ) (out) = _mm256_permute2f128_ps(a,b, (1<<0)+(3<<4) )" + } + }, + { + "name": "stbir__simdf8_gettop4", + "value": "_mm256_extractf128_ps(reg,1)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1528, + "column": 5, + "source_line": " #define stbir__simdf8_gettop4( reg ) _mm256_extractf128_ps(reg,1)" + } + }, + { + "name": "stbir__simdi8_expand_u8_to_u32", + "value": "{ stbir__simdi8 a, zero =_mm256_setzero_si256(); a = _mm256_permute4x64_epi64( _mm256_unpacklo_epi8( _mm256_permute4x64_epi64(_mm256_castsi128_si256(ireg),(0<<0)+(2<<2)+(1<<4)+(3<<6)), zero ),(0<<0)+(2<<2)+(1<<4)+(3<<6)); out0 = _mm256_unpacklo_epi16( a, zero ); out1 = _mm256_unpackhi_epi16( a, zero ); }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1532, + "column": 5, + "source_line": " #define stbir__simdi8_expand_u8_to_u32(out0,out1,ireg) \\" + } + }, + { + "name": "stbir__simdf8_pack_to_16bytes", + "value": "{ stbir__simdi8 t; stbir__simdf8 af,bf; stbir__simdi8 a,b; af = _mm256_min_ps( aa, STBIR_max_uint8_as_floatX ); bf = _mm256_min_ps( bb, STBIR_max_uint8_as_floatX ); af = _mm256_max_ps( af, _mm256_setzero_ps() ); bf = _mm256_max_ps( bf, _mm256_setzero_ps() ); a = _mm256_cvttps_epi32( af ); b = _mm256_cvttps_epi32( bf ); t = _mm256_permute4x64_epi64( _mm256_packs_epi32( a, b ), (0<<0)+(2<<2)+(1<<4)+(3<<6) ); out = _mm256_castsi256_si128( _mm256_permute4x64_epi64( _mm256_packus_epi16( t, t ), (0<<0)+(2<<2)+(1<<4)+(3<<6) ) ); }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1540, + "column": 5, + "source_line": " #define stbir__simdf8_pack_to_16bytes(out,aa,bb) \\" + } + }, + { + "name": "stbir__simdi8_expand_u16_to_u32", + "value": "out = _mm256_unpacklo_epi16( _mm256_permute4x64_epi64(_mm256_castsi128_si256(ireg),(0<<0)+(2<<2)+(1<<4)+(3<<6)), _mm256_setzero_si256() );", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1555, + "column": 5, + "source_line": " #define stbir__simdi8_expand_u16_to_u32(out,ireg) out = _mm256_unpacklo_epi16( _mm256_permute4x64_epi64(_mm256_castsi128_si256(ireg),(0<<0)+(2<<2)+(1<<4)+(3<<6)), _mm256_setzero_si256() );" + } + }, + { + "name": "stbir__simdf8_pack_to_16words", + "value": "{ stbir__simdf8 af,bf; stbir__simdi8 a,b; af = _mm256_min_ps( aa, STBIR_max_uint16_as_floatX ); bf = _mm256_min_ps( bb, STBIR_max_uint16_as_floatX ); af = _mm256_max_ps( af, _mm256_setzero_ps() ); bf = _mm256_max_ps( bf, _mm256_setzero_ps() ); a = _mm256_cvttps_epi32( af ); b = _mm256_cvttps_epi32( bf ); (out) = _mm256_permute4x64_epi64( _mm256_packus_epi32(a, b), (0<<0)+(2<<2)+(1<<4)+(3<<6) ); }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1557, + "column": 5, + "source_line": " #define stbir__simdf8_pack_to_16words(out,aa,bb) \\" + } + }, + { + "name": "stbir__simdi8_expand_u8_to_u32", + "value": "{ stbir__simdi a,zero = _mm_setzero_si128(); a = _mm_unpacklo_epi8( ireg, zero ); out0 = _mm256_setr_m128i( _mm_unpacklo_epi16( a, zero ), _mm_unpackhi_epi16( a, zero ) ); a = _mm_unpackhi_epi8( ireg, zero ); out1 = _mm256_setr_m128i( _mm_unpacklo_epi16( a, zero ), _mm_unpackhi_epi16( a, zero ) ); }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1572, + "column": 5, + "source_line": " #define stbir__simdi8_expand_u8_to_u32(out0,out1,ireg) \\" + } + }, + { + "name": "stbir__simdf8_pack_to_16bytes", + "value": "{ stbir__simdi t; stbir__simdf8 af,bf; stbir__simdi8 a,b; af = _mm256_min_ps( aa, STBIR_max_uint8_as_floatX ); bf = _mm256_min_ps( bb, STBIR_max_uint8_as_floatX ); af = _mm256_max_ps( af, _mm256_setzero_ps() ); bf = _mm256_max_ps( bf, _mm256_setzero_ps() ); a = _mm256_cvttps_epi32( af ); b = _mm256_cvttps_epi32( bf ); out = _mm_packs_epi32( _mm256_castsi256_si128(a), _mm256_extractf128_si256( a, 1 ) ); out = _mm_packus_epi16( out, out ); t = _mm_packs_epi32( _mm256_castsi256_si128(b), _mm256_extractf128_si256( b, 1 ) ); t = _mm_packus_epi16( t, t ); out = _mm_castps_si128( _mm_shuffle_ps( _mm_castsi128_ps(out), _mm_castsi128_ps(t), (0<<0)+(1<<2)+(0<<4)+(1<<6) ) ); }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1581, + "column": 5, + "source_line": " #define stbir__simdf8_pack_to_16bytes(out,aa,bb) \\" + } + }, + { + "name": "stbir__simdi8_expand_u16_to_u32", + "value": "{ stbir__simdi a,b,zero = _mm_setzero_si128(); a = _mm_unpacklo_epi16( ireg, zero ); b = _mm_unpackhi_epi16( ireg, zero ); out = _mm256_insertf128_si256( _mm256_castsi128_si256( a ), b, 1 ); }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1599, + "column": 5, + "source_line": " #define stbir__simdi8_expand_u16_to_u32(out,ireg) \\" + } + }, + { + "name": "stbir__simdf8_pack_to_16words", + "value": "{ stbir__simdi t0,t1; stbir__simdf8 af,bf; stbir__simdi8 a,b; af = _mm256_min_ps( aa, STBIR_max_uint16_as_floatX ); bf = _mm256_min_ps( bb, STBIR_max_uint16_as_floatX ); af = _mm256_max_ps( af, _mm256_setzero_ps() ); bf = _mm256_max_ps( bf, _mm256_setzero_ps() ); a = _mm256_cvttps_epi32( af ); b = _mm256_cvttps_epi32( bf ); t0 = _mm_packus_epi32( _mm256_castsi256_si128(a), _mm256_extractf128_si256( a, 1 ) ); t1 = _mm_packus_epi32( _mm256_castsi256_si128(b), _mm256_extractf128_si256( b, 1 ) ); out = _mm256_setr_m128i( t0, t1 ); }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1607, + "column": 5, + "source_line": " #define stbir__simdf8_pack_to_16words(out,aa,bb) \\" + } + }, + { + "name": "stbir__simdf8_0123to00001111", + "value": "(out) = _mm256_permutevar_ps ( in, stbir_00001111 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1626, + "column": 5, + "source_line": " #define stbir__simdf8_0123to00001111( out, in ) (out) = _mm256_permutevar_ps ( in, stbir_00001111 )" + } + }, + { + "name": "stbir__simdf8_0123to22223333", + "value": "(out) = _mm256_permutevar_ps ( in, stbir_22223333 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1629, + "column": 5, + "source_line": " #define stbir__simdf8_0123to22223333( out, in ) (out) = _mm256_permutevar_ps ( in, stbir_22223333 )" + } + }, + { + "name": "stbir__simdf8_0123to2222", + "value": "(out) = stbir__simdf_swiz(_mm256_castps256_ps128(in), 2,2,2,2 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1631, + "column": 5, + "source_line": " #define stbir__simdf8_0123to2222( out, in ) (out) = stbir__simdf_swiz(_mm256_castps256_ps128(in), 2,2,2,2 )" + } + }, + { + "name": "stbir__simdf8_load4b", + "value": "(out) = _mm256_broadcast_ps( (__m128 const *)(ptr) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1633, + "column": 5, + "source_line": " #define stbir__simdf8_load4b( out, ptr ) (out) = _mm256_broadcast_ps( (__m128 const *)(ptr) )" + } + }, + { + "name": "stbir__simdf8_0123to00112233", + "value": "(out) = _mm256_permutevar_ps ( in, stbir_00112233 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1636, + "column": 5, + "source_line": " #define stbir__simdf8_0123to00112233( out, in ) (out) = _mm256_permutevar_ps ( in, stbir_00112233 )" + } + }, + { + "name": "stbir__simdf8_add4", + "value": "(out) = _mm256_add_ps( a8, _mm256_castps128_ps256( b ) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1637, + "column": 5, + "source_line": " #define stbir__simdf8_add4( out, a8, b ) (out) = _mm256_add_ps( a8, _mm256_castps128_ps256( b ) )" + } + }, + { + "name": "stbir__simdf8_load6z", + "value": "(out) = _mm256_maskload_ps( ptr, stbir_load6 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1640, + "column": 5, + "source_line": " #define stbir__simdf8_load6z( out, ptr ) (out) = _mm256_maskload_ps( ptr, stbir_load6 )" + } + }, + { + "name": "stbir__simdf8_0123to00000000", + "value": "(out) = _mm256_shuffle_ps ( in, in, (0<<0)+(0<<2)+(0<<4)+(0<<6) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1642, + "column": 5, + "source_line": " #define stbir__simdf8_0123to00000000( out, in ) (out) = _mm256_shuffle_ps ( in, in, (0<<0)+(0<<2)+(0<<4)+(0<<6) )" + } + }, + { + "name": "stbir__simdf8_0123to11111111", + "value": "(out) = _mm256_shuffle_ps ( in, in, (1<<0)+(1<<2)+(1<<4)+(1<<6) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1643, + "column": 5, + "source_line": " #define stbir__simdf8_0123to11111111( out, in ) (out) = _mm256_shuffle_ps ( in, in, (1<<0)+(1<<2)+(1<<4)+(1<<6) )" + } + }, + { + "name": "stbir__simdf8_0123to22222222", + "value": "(out) = _mm256_shuffle_ps ( in, in, (2<<0)+(2<<2)+(2<<4)+(2<<6) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1644, + "column": 5, + "source_line": " #define stbir__simdf8_0123to22222222( out, in ) (out) = _mm256_shuffle_ps ( in, in, (2<<0)+(2<<2)+(2<<4)+(2<<6) )" + } + }, + { + "name": "stbir__simdf8_0123to33333333", + "value": "(out) = _mm256_shuffle_ps ( in, in, (3<<0)+(3<<2)+(3<<4)+(3<<6) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1645, + "column": 5, + "source_line": " #define stbir__simdf8_0123to33333333( out, in ) (out) = _mm256_shuffle_ps ( in, in, (3<<0)+(3<<2)+(3<<4)+(3<<6) )" + } + }, + { + "name": "stbir__simdf8_0123to21032103", + "value": "(out) = _mm256_shuffle_ps ( in, in, (2<<0)+(1<<2)+(0<<4)+(3<<6) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1646, + "column": 5, + "source_line": " #define stbir__simdf8_0123to21032103( out, in ) (out) = _mm256_shuffle_ps ( in, in, (2<<0)+(1<<2)+(0<<4)+(3<<6) )" + } + }, + { + "name": "stbir__simdf8_0123to32103210", + "value": "(out) = _mm256_shuffle_ps ( in, in, (3<<0)+(2<<2)+(1<<4)+(0<<6) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1647, + "column": 5, + "source_line": " #define stbir__simdf8_0123to32103210( out, in ) (out) = _mm256_shuffle_ps ( in, in, (3<<0)+(2<<2)+(1<<4)+(0<<6) )" + } + }, + { + "name": "stbir__simdf8_0123to12301230", + "value": "(out) = _mm256_shuffle_ps ( in, in, (1<<0)+(2<<2)+(3<<4)+(0<<6) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1648, + "column": 5, + "source_line": " #define stbir__simdf8_0123to12301230( out, in ) (out) = _mm256_shuffle_ps ( in, in, (1<<0)+(2<<2)+(3<<4)+(0<<6) )" + } + }, + { + "name": "stbir__simdf8_0123to10321032", + "value": "(out) = _mm256_shuffle_ps ( in, in, (1<<0)+(0<<2)+(3<<4)+(2<<6) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1649, + "column": 5, + "source_line": " #define stbir__simdf8_0123to10321032( out, in ) (out) = _mm256_shuffle_ps ( in, in, (1<<0)+(0<<2)+(3<<4)+(2<<6) )" + } + }, + { + "name": "stbir__simdf8_0123to30123012", + "value": "(out) = _mm256_shuffle_ps ( in, in, (3<<0)+(0<<2)+(1<<4)+(2<<6) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1650, + "column": 5, + "source_line": " #define stbir__simdf8_0123to30123012( out, in ) (out) = _mm256_shuffle_ps ( in, in, (3<<0)+(0<<2)+(1<<4)+(2<<6) )" + } + }, + { + "name": "stbir__simdf8_0123to11331133", + "value": "(out) = _mm256_shuffle_ps ( in, in, (1<<0)+(1<<2)+(3<<4)+(3<<6) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1652, + "column": 5, + "source_line": " #define stbir__simdf8_0123to11331133( out, in ) (out) = _mm256_shuffle_ps ( in, in, (1<<0)+(1<<2)+(3<<4)+(3<<6) )" + } + }, + { + "name": "stbir__simdf8_0123to00220022", + "value": "(out) = _mm256_shuffle_ps ( in, in, (0<<0)+(0<<2)+(2<<4)+(2<<6) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1653, + "column": 5, + "source_line": " #define stbir__simdf8_0123to00220022( out, in ) (out) = _mm256_shuffle_ps ( in, in, (0<<0)+(0<<2)+(2<<4)+(2<<6) )" + } + }, + { + "name": "stbir__simdf8_aaa1", + "value": "(out) = _mm256_blend_ps( alp, ones, (1<<0)+(1<<1)+(1<<2)+(0<<3)+(1<<4)+(1<<5)+(1<<6)+(0<<7)); (out)=_mm256_shuffle_ps( out,out, (3<<0) + (3<<2) + (3<<4) + (0<<6) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1655, + "column": 5, + "source_line": " #define stbir__simdf8_aaa1( out, alp, ones ) (out) = _mm256_blend_ps( alp, ones, (1<<0)+(1<<1)+(1<<2)+(0<<3)+(1<<4)+(1<<5)+(1<<6)+(0<<7)); (out)=_mm256_shuffle_ps( out,out, (3<<0) + (3<<2) + (3<<4) + (0<<6) )" + } + }, + { + "name": "stbir__simdf8_1aaa", + "value": "(out) = _mm256_blend_ps( alp, ones, (0<<0)+(1<<1)+(1<<2)+(1<<3)+(0<<4)+(1<<5)+(1<<6)+(1<<7)); (out)=_mm256_shuffle_ps( out,out, (1<<0) + (0<<2) + (0<<4) + (0<<6) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1656, + "column": 5, + "source_line": " #define stbir__simdf8_1aaa( out, alp, ones ) (out) = _mm256_blend_ps( alp, ones, (0<<0)+(1<<1)+(1<<2)+(1<<3)+(0<<4)+(1<<5)+(1<<6)+(1<<7)); (out)=_mm256_shuffle_ps( out,out, (1<<0) + (0<<2) + (0<<4) + (0<<6) )" + } + }, + { + "name": "stbir__simdf8_a1a1", + "value": "(out) = _mm256_blend_ps( alp, ones, (1<<0)+(0<<1)+(1<<2)+(0<<3)+(1<<4)+(0<<5)+(1<<6)+(0<<7)); (out)=_mm256_shuffle_ps( out,out, (1<<0) + (0<<2) + (3<<4) + (2<<6) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1657, + "column": 5, + "source_line": " #define stbir__simdf8_a1a1( out, alp, ones) (out) = _mm256_blend_ps( alp, ones, (1<<0)+(0<<1)+(1<<2)+(0<<3)+(1<<4)+(0<<5)+(1<<6)+(0<<7)); (out)=_mm256_shuffle_ps( out,out, (1<<0) + (0<<2) + (3<<4) + (2<<6) )" + } + }, + { + "name": "stbir__simdf8_1a1a", + "value": "(out) = _mm256_blend_ps( alp, ones, (0<<0)+(1<<1)+(0<<2)+(1<<3)+(0<<4)+(1<<5)+(0<<6)+(1<<7)); (out)=_mm256_shuffle_ps( out,out, (1<<0) + (0<<2) + (3<<4) + (2<<6) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1658, + "column": 5, + "source_line": " #define stbir__simdf8_1a1a( out, alp, ones) (out) = _mm256_blend_ps( alp, ones, (0<<0)+(1<<1)+(0<<2)+(1<<3)+(0<<4)+(1<<5)+(0<<6)+(1<<7)); (out)=_mm256_shuffle_ps( out,out, (1<<0) + (0<<2) + (3<<4) + (2<<6) )" + } + }, + { + "name": "stbir__simdf8_zero", + "value": "(reg) = _mm256_setzero_ps()", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1660, + "column": 5, + "source_line": " #define stbir__simdf8_zero( reg ) (reg) = _mm256_setzero_ps()" + } + }, + { + "name": "stbir__simdf8_madd", + "value": "(out) = _mm256_fmadd_ps( mul1, mul2, add )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1663, + "column": 5, + "source_line": " #define stbir__simdf8_madd( out, add, mul1, mul2 ) (out) = _mm256_fmadd_ps( mul1, mul2, add )" + } + }, + { + "name": "stbir__simdf8_madd_mem", + "value": "(out) = _mm256_fmadd_ps( mul, _mm256_loadu_ps( (float const*)(ptr) ), add )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1664, + "column": 5, + "source_line": " #define stbir__simdf8_madd_mem( out, add, mul, ptr ) (out) = _mm256_fmadd_ps( mul, _mm256_loadu_ps( (float const*)(ptr) ), add )" + } + }, + { + "name": "stbir__simdf8_madd", + "value": "(out) = _mm256_add_ps( add, _mm256_mul_ps( mul1, mul2 ) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1667, + "column": 5, + "source_line": " #define stbir__simdf8_madd( out, add, mul1, mul2 ) (out) = _mm256_add_ps( add, _mm256_mul_ps( mul1, mul2 ) )" + } + }, + { + "name": "stbir__simdf8_madd_mem", + "value": "(out) = _mm256_add_ps( add, _mm256_mul_ps( mul, _mm256_loadu_ps( (float const*)(ptr) ) ) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1668, + "column": 5, + "source_line": " #define stbir__simdf8_madd_mem( out, add, mul, ptr ) (out) = _mm256_add_ps( add, _mm256_mul_ps( mul, _mm256_loadu_ps( (float const*)(ptr) ) ) )" + } + }, + { + "name": "stbir__simdf8_madd_mem4", + "value": "(out) = _mm256_add_ps( add, _mm256_setr_m128( _mm_mul_ps( mul, _mm_loadu_ps( (float const*)(ptr) ) ), _mm_setzero_ps() ) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1669, + "column": 5, + "source_line": " #define stbir__simdf8_madd_mem4( out, add, mul, ptr ) (out) = _mm256_add_ps( add, _mm256_setr_m128( _mm_mul_ps( mul, _mm_loadu_ps( (float const*)(ptr) ) ), _mm_setzero_ps() ) )" + } + }, + { + "name": "stbir__if_simdf8_cast_to_simdf4", + "value": "_mm256_castps256_ps128( val )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1671, + "column": 5, + "source_line": " #define stbir__if_simdf8_cast_to_simdf4( val ) _mm256_castps256_ps128( val )" + } + }, + { + "name": "STBIR_FLOORF", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1676, + "column": 3, + "source_line": " #undef STBIR_FLOORF" + } + }, + { + "name": "STBIR_FLOORF", + "value": "stbir_simd_floorf", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1678, + "column": 3, + "source_line": " #define STBIR_FLOORF stbir_simd_floorf" + } + }, + { + "name": "STBIR_CEILF", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1693, + "column": 3, + "source_line": " #undef STBIR_CEILF" + } + }, + { + "name": "STBIR_CEILF", + "value": "stbir_simd_ceilf", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1695, + "column": 3, + "source_line": " #define STBIR_CEILF stbir_simd_ceilf" + } + }, + { + "name": "stbir__simdf", + "value": "float32x4_t", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1713, + "column": 3, + "source_line": " #define stbir__simdf float32x4_t" + } + }, + { + "name": "stbir__simdi", + "value": "uint32x4_t", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1714, + "column": 3, + "source_line": " #define stbir__simdi uint32x4_t" + } + }, + { + "name": "stbir_simdi_castf", + "value": "vreinterpretq_u32_f32(reg)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1716, + "column": 3, + "source_line": " #define stbir_simdi_castf( reg ) vreinterpretq_u32_f32(reg)" + } + }, + { + "name": "stbir_simdf_casti", + "value": "vreinterpretq_f32_u32(reg)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1717, + "column": 3, + "source_line": " #define stbir_simdf_casti( reg ) vreinterpretq_f32_u32(reg)" + } + }, + { + "name": "stbir__simdf_load", + "value": "(reg) = vld1q_f32( (float const*)(ptr) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1719, + "column": 3, + "source_line": " #define stbir__simdf_load( reg, ptr ) (reg) = vld1q_f32( (float const*)(ptr) )" + } + }, + { + "name": "stbir__simdi_load", + "value": "(reg) = vld1q_u32( (uint32_t const*)(ptr) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1720, + "column": 3, + "source_line": " #define stbir__simdi_load( reg, ptr ) (reg) = vld1q_u32( (uint32_t const*)(ptr) )" + } + }, + { + "name": "stbir__simdf_load1", + "value": "(out) = vld1q_dup_f32( (float const*)(ptr) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1721, + "column": 3, + "source_line": " #define stbir__simdf_load1( out, ptr ) (out) = vld1q_dup_f32( (float const*)(ptr) ) // top values can be random (not denormal or nan for perf)" + } + }, + { + "name": "stbir__simdi_load1", + "value": "(out) = vld1q_dup_u32( (uint32_t const*)(ptr) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1722, + "column": 3, + "source_line": " #define stbir__simdi_load1( out, ptr ) (out) = vld1q_dup_u32( (uint32_t const*)(ptr) )" + } + }, + { + "name": "stbir__simdf_load1z", + "value": "(out) = vld1q_lane_f32( (float const*)(ptr), vdupq_n_f32(0), 0 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1723, + "column": 3, + "source_line": " #define stbir__simdf_load1z( out, ptr ) (out) = vld1q_lane_f32( (float const*)(ptr), vdupq_n_f32(0), 0 ) // top values must be zero" + } + }, + { + "name": "stbir__simdf_frep4", + "value": "vdupq_n_f32( fvar )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1724, + "column": 3, + "source_line": " #define stbir__simdf_frep4( fvar ) vdupq_n_f32( fvar )" + } + }, + { + "name": "stbir__simdf_load1frep4", + "value": "(out) = vdupq_n_f32( fvar )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1725, + "column": 3, + "source_line": " #define stbir__simdf_load1frep4( out, fvar ) (out) = vdupq_n_f32( fvar )" + } + }, + { + "name": "stbir__simdf_load2", + "value": "(out) = vcombine_f32( vld1_f32( (float const*)(ptr) ), vcreate_f32(0) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1726, + "column": 3, + "source_line": " #define stbir__simdf_load2( out, ptr ) (out) = vcombine_f32( vld1_f32( (float const*)(ptr) ), vcreate_f32(0) ) // top values can be random (not denormal or nan for perf)" + } + }, + { + "name": "stbir__simdf_load2z", + "value": "(out) = vcombine_f32( vld1_f32( (float const*)(ptr) ), vcreate_f32(0) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1727, + "column": 3, + "source_line": " #define stbir__simdf_load2z( out, ptr ) (out) = vcombine_f32( vld1_f32( (float const*)(ptr) ), vcreate_f32(0) ) // top values must be zero" + } + }, + { + "name": "stbir__simdf_load2hmerge", + "value": "(out) = vcombine_f32( vget_low_f32(reg), vld1_f32( (float const*)(ptr) ) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1728, + "column": 3, + "source_line": " #define stbir__simdf_load2hmerge( out, reg, ptr ) (out) = vcombine_f32( vget_low_f32(reg), vld1_f32( (float const*)(ptr) ) )" + } + }, + { + "name": "stbir__simdf_zeroP", + "value": "vdupq_n_f32(0)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1730, + "column": 3, + "source_line": " #define stbir__simdf_zeroP() vdupq_n_f32(0)" + } + }, + { + "name": "stbir__simdf_zero", + "value": "(reg) = vdupq_n_f32(0)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1731, + "column": 3, + "source_line": " #define stbir__simdf_zero( reg ) (reg) = vdupq_n_f32(0)" + } + }, + { + "name": "stbir__simdf_store", + "value": "vst1q_f32( (float*)(ptr), reg )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1733, + "column": 3, + "source_line": " #define stbir__simdf_store( ptr, reg ) vst1q_f32( (float*)(ptr), reg )" + } + }, + { + "name": "stbir__simdf_store1", + "value": "vst1q_lane_f32( (float*)(ptr), reg, 0)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1734, + "column": 3, + "source_line": " #define stbir__simdf_store1( ptr, reg ) vst1q_lane_f32( (float*)(ptr), reg, 0)" + } + }, + { + "name": "stbir__simdf_store2", + "value": "vst1_f32( (float*)(ptr), vget_low_f32(reg) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1735, + "column": 3, + "source_line": " #define stbir__simdf_store2( ptr, reg ) vst1_f32( (float*)(ptr), vget_low_f32(reg) )" + } + }, + { + "name": "stbir__simdf_store2h", + "value": "vst1_f32( (float*)(ptr), vget_high_f32(reg) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1736, + "column": 3, + "source_line": " #define stbir__simdf_store2h( ptr, reg ) vst1_f32( (float*)(ptr), vget_high_f32(reg) )" + } + }, + { + "name": "stbir__simdi_store", + "value": "vst1q_u32( (uint32_t*)(ptr), reg )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1738, + "column": 3, + "source_line": " #define stbir__simdi_store( ptr, reg ) vst1q_u32( (uint32_t*)(ptr), reg )" + } + }, + { + "name": "stbir__simdi_store1", + "value": "vst1q_lane_u32( (uint32_t*)(ptr), reg, 0 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1739, + "column": 3, + "source_line": " #define stbir__simdi_store1( ptr, reg ) vst1q_lane_u32( (uint32_t*)(ptr), reg, 0 )" + } + }, + { + "name": "stbir__simdi_store2", + "value": "vst1_u32( (uint32_t*)(ptr), vget_low_u32(reg) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1740, + "column": 3, + "source_line": " #define stbir__simdi_store2( ptr, reg ) vst1_u32( (uint32_t*)(ptr), vget_low_u32(reg) )" + } + }, + { + "name": "stbir__prefetch", + "value": null, + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1742, + "column": 3, + "source_line": " #define stbir__prefetch( ptr )" + } + }, + { + "name": "stbir__simdi_expand_u8_to_u32", + "value": "{ uint16x8_t l = vmovl_u8( vget_low_u8 ( vreinterpretq_u8_u32(ireg) ) ); uint16x8_t h = vmovl_u8( vget_high_u8( vreinterpretq_u8_u32(ireg) ) ); out0 = vmovl_u16( vget_low_u16 ( l ) ); out1 = vmovl_u16( vget_high_u16( l ) ); out2 = vmovl_u16( vget_low_u16 ( h ) ); out3 = vmovl_u16( vget_high_u16( h ) ); }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1744, + "column": 3, + "source_line": " #define stbir__simdi_expand_u8_to_u32(out0,out1,out2,out3,ireg) \\" + } + }, + { + "name": "stbir__simdi_expand_u8_to_1u32", + "value": "{ uint16x8_t tmp = vmovl_u8( vget_low_u8( vreinterpretq_u8_u32(ireg) ) ); out = vmovl_u16( vget_low_u16( tmp ) ); }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1754, + "column": 3, + "source_line": " #define stbir__simdi_expand_u8_to_1u32(out,ireg) \\" + } + }, + { + "name": "stbir__simdi_expand_u16_to_u32", + "value": "{ uint16x8_t tmp = vreinterpretq_u16_u32(ireg); out0 = vmovl_u16( vget_low_u16 ( tmp ) ); out1 = vmovl_u16( vget_high_u16( tmp ) ); }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1760, + "column": 3, + "source_line": " #define stbir__simdi_expand_u16_to_u32(out0,out1,ireg) \\" + } + }, + { + "name": "stbir__simdf_convert_float_to_i32", + "value": "(i) = vreinterpretq_u32_s32( vcvtq_s32_f32(f) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1767, + "column": 3, + "source_line": " #define stbir__simdf_convert_float_to_i32( i, f ) (i) = vreinterpretq_u32_s32( vcvtq_s32_f32(f) )" + } + }, + { + "name": "stbir__simdf_convert_float_to_int", + "value": "vgetq_lane_s32(vcvtq_s32_f32(f), 0)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1768, + "column": 3, + "source_line": " #define stbir__simdf_convert_float_to_int( f ) vgetq_lane_s32(vcvtq_s32_f32(f), 0)" + } + }, + { + "name": "stbir__simdi_to_int", + "value": "(int)vgetq_lane_u32(i, 0)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1769, + "column": 3, + "source_line": " #define stbir__simdi_to_int( i ) (int)vgetq_lane_u32(i, 0)" + } + }, + { + "name": "stbir__simdf_convert_float_to_uint8", + "value": "((unsigned char)vgetq_lane_s32(vcvtq_s32_f32(vmaxq_f32(vminq_f32(f,STBIR__CONSTF(STBIR_max_uint8_as_float)),vdupq_n_f32(0))), 0))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1770, + "column": 3, + "source_line": " #define stbir__simdf_convert_float_to_uint8( f ) ((unsigned char)vgetq_lane_s32(vcvtq_s32_f32(vmaxq_f32(vminq_f32(f,STBIR__CONSTF(STBIR_max_uint8_as_float)),vdupq_n_f32(0))), 0))" + } + }, + { + "name": "stbir__simdf_convert_float_to_short", + "value": "((unsigned short)vgetq_lane_s32(vcvtq_s32_f32(vmaxq_f32(vminq_f32(f,STBIR__CONSTF(STBIR_max_uint16_as_float)),vdupq_n_f32(0))), 0))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1771, + "column": 3, + "source_line": " #define stbir__simdf_convert_float_to_short( f ) ((unsigned short)vgetq_lane_s32(vcvtq_s32_f32(vmaxq_f32(vminq_f32(f,STBIR__CONSTF(STBIR_max_uint16_as_float)),vdupq_n_f32(0))), 0))" + } + }, + { + "name": "stbir__simdi_convert_i32_to_float", + "value": "(out) = vcvtq_f32_s32( vreinterpretq_s32_u32(ireg) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1772, + "column": 3, + "source_line": " #define stbir__simdi_convert_i32_to_float(out, ireg) (out) = vcvtq_f32_s32( vreinterpretq_s32_u32(ireg) )" + } + }, + { + "name": "stbir__simdf_add", + "value": "(out) = vaddq_f32( reg0, reg1 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1773, + "column": 3, + "source_line": " #define stbir__simdf_add( out, reg0, reg1 ) (out) = vaddq_f32( reg0, reg1 )" + } + }, + { + "name": "stbir__simdf_mult", + "value": "(out) = vmulq_f32( reg0, reg1 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1774, + "column": 3, + "source_line": " #define stbir__simdf_mult( out, reg0, reg1 ) (out) = vmulq_f32( reg0, reg1 )" + } + }, + { + "name": "stbir__simdf_mult_mem", + "value": "(out) = vmulq_f32( reg, vld1q_f32( (float const*)(ptr) ) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1775, + "column": 3, + "source_line": " #define stbir__simdf_mult_mem( out, reg, ptr ) (out) = vmulq_f32( reg, vld1q_f32( (float const*)(ptr) ) )" + } + }, + { + "name": "stbir__simdf_mult1_mem", + "value": "(out) = vmulq_f32( reg, vld1q_dup_f32( (float const*)(ptr) ) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1776, + "column": 3, + "source_line": " #define stbir__simdf_mult1_mem( out, reg, ptr ) (out) = vmulq_f32( reg, vld1q_dup_f32( (float const*)(ptr) ) )" + } + }, + { + "name": "stbir__simdf_add_mem", + "value": "(out) = vaddq_f32( reg, vld1q_f32( (float const*)(ptr) ) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1777, + "column": 3, + "source_line": " #define stbir__simdf_add_mem( out, reg, ptr ) (out) = vaddq_f32( reg, vld1q_f32( (float const*)(ptr) ) )" + } + }, + { + "name": "stbir__simdf_add1_mem", + "value": "(out) = vaddq_f32( reg, vld1q_dup_f32( (float const*)(ptr) ) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1778, + "column": 3, + "source_line": " #define stbir__simdf_add1_mem( out, reg, ptr ) (out) = vaddq_f32( reg, vld1q_dup_f32( (float const*)(ptr) ) )" + } + }, + { + "name": "stbir__simdf_madd", + "value": "(out) = vfmaq_f32( add, mul1, mul2 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1781, + "column": 3, + "source_line": " #define stbir__simdf_madd( out, add, mul1, mul2 ) (out) = vfmaq_f32( add, mul1, mul2 )" + } + }, + { + "name": "stbir__simdf_madd1", + "value": "(out) = vfmaq_f32( add, mul1, mul2 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1782, + "column": 3, + "source_line": " #define stbir__simdf_madd1( out, add, mul1, mul2 ) (out) = vfmaq_f32( add, mul1, mul2 )" + } + }, + { + "name": "stbir__simdf_madd_mem", + "value": "(out) = vfmaq_f32( add, mul, vld1q_f32( (float const*)(ptr) ) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1783, + "column": 3, + "source_line": " #define stbir__simdf_madd_mem( out, add, mul, ptr ) (out) = vfmaq_f32( add, mul, vld1q_f32( (float const*)(ptr) ) )" + } + }, + { + "name": "stbir__simdf_madd1_mem", + "value": "(out) = vfmaq_f32( add, mul, vld1q_dup_f32( (float const*)(ptr) ) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1784, + "column": 3, + "source_line": " #define stbir__simdf_madd1_mem( out, add, mul, ptr ) (out) = vfmaq_f32( add, mul, vld1q_dup_f32( (float const*)(ptr) ) )" + } + }, + { + "name": "stbir__simdf_madd", + "value": "(out) = vaddq_f32( add, vmulq_f32( mul1, mul2 ) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1786, + "column": 3, + "source_line": " #define stbir__simdf_madd( out, add, mul1, mul2 ) (out) = vaddq_f32( add, vmulq_f32( mul1, mul2 ) )" + } + }, + { + "name": "stbir__simdf_madd1", + "value": "(out) = vaddq_f32( add, vmulq_f32( mul1, mul2 ) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1787, + "column": 3, + "source_line": " #define stbir__simdf_madd1( out, add, mul1, mul2 ) (out) = vaddq_f32( add, vmulq_f32( mul1, mul2 ) )" + } + }, + { + "name": "stbir__simdf_madd_mem", + "value": "(out) = vaddq_f32( add, vmulq_f32( mul, vld1q_f32( (float const*)(ptr) ) ) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1788, + "column": 3, + "source_line": " #define stbir__simdf_madd_mem( out, add, mul, ptr ) (out) = vaddq_f32( add, vmulq_f32( mul, vld1q_f32( (float const*)(ptr) ) ) )" + } + }, + { + "name": "stbir__simdf_madd1_mem", + "value": "(out) = vaddq_f32( add, vmulq_f32( mul, vld1q_dup_f32( (float const*)(ptr) ) ) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1789, + "column": 3, + "source_line": " #define stbir__simdf_madd1_mem( out, add, mul, ptr ) (out) = vaddq_f32( add, vmulq_f32( mul, vld1q_dup_f32( (float const*)(ptr) ) ) )" + } + }, + { + "name": "stbir__simdf_add1", + "value": "(out) = vaddq_f32( reg0, reg1 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1792, + "column": 3, + "source_line": " #define stbir__simdf_add1( out, reg0, reg1 ) (out) = vaddq_f32( reg0, reg1 )" + } + }, + { + "name": "stbir__simdf_mult1", + "value": "(out) = vmulq_f32( reg0, reg1 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1793, + "column": 3, + "source_line": " #define stbir__simdf_mult1( out, reg0, reg1 ) (out) = vmulq_f32( reg0, reg1 )" + } + }, + { + "name": "stbir__simdf_and", + "value": "(out) = vreinterpretq_f32_u32( vandq_u32( vreinterpretq_u32_f32(reg0), vreinterpretq_u32_f32(reg1) ) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1795, + "column": 3, + "source_line": " #define stbir__simdf_and( out, reg0, reg1 ) (out) = vreinterpretq_f32_u32( vandq_u32( vreinterpretq_u32_f32(reg0), vreinterpretq_u32_f32(reg1) ) )" + } + }, + { + "name": "stbir__simdf_or", + "value": "(out) = vreinterpretq_f32_u32( vorrq_u32( vreinterpretq_u32_f32(reg0), vreinterpretq_u32_f32(reg1) ) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1796, + "column": 3, + "source_line": " #define stbir__simdf_or( out, reg0, reg1 ) (out) = vreinterpretq_f32_u32( vorrq_u32( vreinterpretq_u32_f32(reg0), vreinterpretq_u32_f32(reg1) ) )" + } + }, + { + "name": "stbir__simdf_min", + "value": "(out) = vminq_f32( reg0, reg1 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1798, + "column": 3, + "source_line": " #define stbir__simdf_min( out, reg0, reg1 ) (out) = vminq_f32( reg0, reg1 )" + } + }, + { + "name": "stbir__simdf_max", + "value": "(out) = vmaxq_f32( reg0, reg1 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1799, + "column": 3, + "source_line": " #define stbir__simdf_max( out, reg0, reg1 ) (out) = vmaxq_f32( reg0, reg1 )" + } + }, + { + "name": "stbir__simdf_min1", + "value": "(out) = vminq_f32( reg0, reg1 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1800, + "column": 3, + "source_line": " #define stbir__simdf_min1( out, reg0, reg1 ) (out) = vminq_f32( reg0, reg1 )" + } + }, + { + "name": "stbir__simdf_max1", + "value": "(out) = vmaxq_f32( reg0, reg1 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1801, + "column": 3, + "source_line": " #define stbir__simdf_max1( out, reg0, reg1 ) (out) = vmaxq_f32( reg0, reg1 )" + } + }, + { + "name": "stbir__simdf_0123ABCDto3ABx", + "value": "(out) = vextq_f32( reg0, reg1, 3 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1803, + "column": 3, + "source_line": " #define stbir__simdf_0123ABCDto3ABx( out, reg0, reg1 ) (out) = vextq_f32( reg0, reg1, 3 )" + } + }, + { + "name": "stbir__simdf_0123ABCDto23Ax", + "value": "(out) = vextq_f32( reg0, reg1, 2 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1804, + "column": 3, + "source_line": " #define stbir__simdf_0123ABCDto23Ax( out, reg0, reg1 ) (out) = vextq_f32( reg0, reg1, 2 )" + } + }, + { + "name": "stbir__simdf_a1a1", + "value": "(out) = vzipq_f32(vuzpq_f32(alp, alp).val[1], ones).val[0]", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1806, + "column": 3, + "source_line": " #define stbir__simdf_a1a1( out, alp, ones ) (out) = vzipq_f32(vuzpq_f32(alp, alp).val[1], ones).val[0]" + } + }, + { + "name": "stbir__simdf_1a1a", + "value": "(out) = vzipq_f32(ones, vuzpq_f32(alp, alp).val[0]).val[0]", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1807, + "column": 3, + "source_line": " #define stbir__simdf_1a1a( out, alp, ones ) (out) = vzipq_f32(ones, vuzpq_f32(alp, alp).val[0]).val[0]" + } + }, + { + "name": "stbir__simdf_aaa1", + "value": "(out) = vcopyq_laneq_f32(vdupq_n_f32(vgetq_lane_f32(alp, 3)), 3, ones, 3)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1811, + "column": 5, + "source_line": " #define stbir__simdf_aaa1( out, alp, ones ) (out) = vcopyq_laneq_f32(vdupq_n_f32(vgetq_lane_f32(alp, 3)), 3, ones, 3)" + } + }, + { + "name": "stbir__simdf_1aaa", + "value": "(out) = vcopyq_laneq_f32(vdupq_n_f32(vgetq_lane_f32(alp, 0)), 0, ones, 0)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1812, + "column": 5, + "source_line": " #define stbir__simdf_1aaa( out, alp, ones ) (out) = vcopyq_laneq_f32(vdupq_n_f32(vgetq_lane_f32(alp, 0)), 0, ones, 0)" + } + }, + { + "name": "stbir_make16", + "value": "vcombine_u8( vcreate_u8( (4*a+0) | ((4*a+1)<<8) | ((4*a+2)<<16) | ((4*a+3)<<24) | ((stbir_uint64)(4*b+0)<<32) | ((stbir_uint64)(4*b+1)<<40) | ((stbir_uint64)(4*b+2)<<48) | ((stbir_uint64)(4*b+3)<<56)), vcreate_u8( (4*c+0) | ((4*c+1)<<8) | ((4*c+2)<<16) | ((4*c+3)<<24) | ((stbir_uint64)(4*d+0)<<32) | ((stbir_uint64)(4*d+1)<<40) | ((stbir_uint64)(4*d+2)<<48) | ((stbir_uint64)(4*d+3)<<56) ) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1815, + "column": 7, + "source_line": " #define stbir_make16(a,b,c,d) vcombine_u8( \\" + } + }, + { + "name": "stbir_make16", + "value": "(uint8x16_t){4*a+0,4*a+1,4*a+2,4*a+3,4*b+0,4*b+1,4*b+2,4*b+3,4*c+0,4*c+1,4*c+2,4*c+3,4*d+0,4*d+1,4*d+2,4*d+3}", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1827, + "column": 7, + "source_line": " #define stbir_make16(a,b,c,d) (uint8x16_t){4*a+0,4*a+1,4*a+2,4*a+3,4*b+0,4*b+1,4*b+2,4*b+3,4*c+0,4*c+1,4*c+2,4*c+3,4*d+0,4*d+1,4*d+2,4*d+3}" + } + }, + { + "name": "stbir_make16x2", + "value": "(uint8x16x2_t){{vreinterpretq_u8_f32(a),vreinterpretq_u8_f32(b)}}", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1828, + "column": 7, + "source_line": " #define stbir_make16x2(a,b) (uint8x16x2_t){{vreinterpretq_u8_f32(a),vreinterpretq_u8_f32(b)}}" + } + }, + { + "name": "stbir__simdf_swiz", + "value": "vreinterpretq_f32_u8( vqtbl1q_u8( vreinterpretq_u8_f32(reg), stbir_make16(one, two, three, four) ) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1831, + "column": 5, + "source_line": " #define stbir__simdf_swiz( reg, one, two, three, four ) vreinterpretq_f32_u8( vqtbl1q_u8( vreinterpretq_u8_f32(reg), stbir_make16(one, two, three, four) ) )" + } + }, + { + "name": "stbir__simdf_swiz2", + "value": "vreinterpretq_f32_u8( vqtbl2q_u8( stbir_make16x2(rega,regb), stbir_make16(one, two, three, four) ) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1832, + "column": 5, + "source_line": " #define stbir__simdf_swiz2( rega, regb, one, two, three, four ) vreinterpretq_f32_u8( vqtbl2q_u8( stbir_make16x2(rega,regb), stbir_make16(one, two, three, four) ) )" + } + }, + { + "name": "stbir__simdi_16madd", + "value": "{ int16x8_t r0 = vreinterpretq_s16_u32(reg0); int16x8_t r1 = vreinterpretq_s16_u32(reg1); int32x4_t tmp0 = vmull_s16( vget_low_s16(r0), vget_low_s16(r1) ); int32x4_t tmp1 = vmull_s16( vget_high_s16(r0), vget_high_s16(r1) ); (out) = vreinterpretq_u32_s32( vpaddq_s32(tmp0, tmp1) ); }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1834, + "column": 5, + "source_line": " #define stbir__simdi_16madd( out, reg0, reg1 ) \\" + } + }, + { + "name": "stbir__simdf_aaa1", + "value": "(out) = vsetq_lane_f32(1.0f, vdupq_n_f32(vgetq_lane_f32(alp, 3)), 3)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1845, + "column": 5, + "source_line": " #define stbir__simdf_aaa1( out, alp, ones ) (out) = vsetq_lane_f32(1.0f, vdupq_n_f32(vgetq_lane_f32(alp, 3)), 3)" + } + }, + { + "name": "stbir__simdf_1aaa", + "value": "(out) = vsetq_lane_f32(1.0f, vdupq_n_f32(vgetq_lane_f32(alp, 0)), 0)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1846, + "column": 5, + "source_line": " #define stbir__simdf_1aaa( out, alp, ones ) (out) = vsetq_lane_f32(1.0f, vdupq_n_f32(vgetq_lane_f32(alp, 0)), 0)" + } + }, + { + "name": "stbir_make8", + "value": "vcreate_u8( (4*a+0) | ((4*a+1)<<8) | ((4*a+2)<<16) | ((4*a+3)<<24) | ((stbir_uint64)(4*b+0)<<32) | ((stbir_uint64)(4*b+1)<<40) | ((stbir_uint64)(4*b+2)<<48) | ((stbir_uint64)(4*b+3)<<56) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1854, + "column": 7, + "source_line": " #define stbir_make8(a,b) vcreate_u8( \\" + } + }, + { + "name": "stbir_make8x2", + "value": "(uint8x8x2_t){ { vget_low_u8(vreinterpretq_u8_f32(reg)), vget_high_u8(vreinterpretq_u8_f32(reg)) } }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1858, + "column": 7, + "source_line": " #define stbir_make8x2(reg) (uint8x8x2_t){ { vget_low_u8(vreinterpretq_u8_f32(reg)), vget_high_u8(vreinterpretq_u8_f32(reg)) } }" + } + }, + { + "name": "stbir_make8", + "value": "(uint8x8_t){4*a+0,4*a+1,4*a+2,4*a+3,4*b+0,4*b+1,4*b+2,4*b+3}", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1859, + "column": 7, + "source_line": " #define stbir_make8(a,b) (uint8x8_t){4*a+0,4*a+1,4*a+2,4*a+3,4*b+0,4*b+1,4*b+2,4*b+3}" + } + }, + { + "name": "stbir__simdf_swiz", + "value": "vreinterpretq_f32_u8( vcombine_u8( vtbl2_u8( stbir_make8x2( reg ), stbir_make8( one, two ) ), vtbl2_u8( stbir_make8x2( reg ), stbir_make8( three, four ) ) ) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1862, + "column": 5, + "source_line": " #define stbir__simdf_swiz( reg, one, two, three, four ) vreinterpretq_f32_u8( vcombine_u8( \\" + } + }, + { + "name": "stbir__simdi_16madd", + "value": "{ int16x8_t r0 = vreinterpretq_s16_u32(reg0); int16x8_t r1 = vreinterpretq_s16_u32(reg1); int32x4_t tmp0 = vmull_s16( vget_low_s16(r0), vget_low_s16(r1) ); int32x4_t tmp1 = vmull_s16( vget_high_s16(r0), vget_high_s16(r1) ); int32x2_t out0 = vpadd_s32( vget_low_s32(tmp0), vget_high_s32(tmp0) ); int32x2_t out1 = vpadd_s32( vget_low_s32(tmp1), vget_high_s32(tmp1) ); (out) = vreinterpretq_u32_s32( vcombine_s32(out0, out1) ); }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1866, + "column": 5, + "source_line": " #define stbir__simdi_16madd( out, reg0, reg1 ) \\" + } + }, + { + "name": "stbir__simdi_and", + "value": "(out) = vandq_u32( reg0, reg1 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1879, + "column": 3, + "source_line": " #define stbir__simdi_and( out, reg0, reg1 ) (out) = vandq_u32( reg0, reg1 )" + } + }, + { + "name": "stbir__simdi_or", + "value": "(out) = vorrq_u32( reg0, reg1 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1880, + "column": 3, + "source_line": " #define stbir__simdi_or( out, reg0, reg1 ) (out) = vorrq_u32( reg0, reg1 )" + } + }, + { + "name": "stbir__simdf_pack_to_8bytes", + "value": "{ float32x4_t af = vmaxq_f32( vminq_f32(aa,STBIR__CONSTF(STBIR_max_uint8_as_float) ), vdupq_n_f32(0) ); float32x4_t bf = vmaxq_f32( vminq_f32(bb,STBIR__CONSTF(STBIR_max_uint8_as_float) ), vdupq_n_f32(0) ); int16x4_t ai = vqmovn_s32( vcvtq_s32_f32( af ) ); int16x4_t bi = vqmovn_s32( vcvtq_s32_f32( bf ) ); uint8x8_t out8 = vqmovun_s16( vcombine_s16(ai, bi) ); out = vreinterpretq_u32_u8( vcombine_u8(out8, out8) ); }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1882, + "column": 3, + "source_line": " #define stbir__simdf_pack_to_8bytes(out,aa,bb) \\" + } + }, + { + "name": "stbir__simdf_pack_to_8words", + "value": "{ float32x4_t af = vmaxq_f32( vminq_f32(aa,STBIR__CONSTF(STBIR_max_uint16_as_float) ), vdupq_n_f32(0) ); float32x4_t bf = vmaxq_f32( vminq_f32(bb,STBIR__CONSTF(STBIR_max_uint16_as_float) ), vdupq_n_f32(0) ); int32x4_t ai = vcvtq_s32_f32( af ); int32x4_t bi = vcvtq_s32_f32( bf ); out = vreinterpretq_u32_u16( vcombine_u16(vqmovun_s32(ai), vqmovun_s32(bi)) ); }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1892, + "column": 3, + "source_line": " #define stbir__simdf_pack_to_8words(out,aa,bb) \\" + } + }, + { + "name": "stbir__interleave_pack_and_store_16_u8", + "value": "{ int16x4x2_t tmp0 = vzip_s16( vqmovn_s32(vreinterpretq_s32_u32(r0)), vqmovn_s32(vreinterpretq_s32_u32(r2)) ); int16x4x2_t tmp1 = vzip_s16( vqmovn_s32(vreinterpretq_s32_u32(r1)), vqmovn_s32(vreinterpretq_s32_u32(r3)) ); uint8x8x2_t out = { { vqmovun_s16( vcombine_s16(tmp0.val[0], tmp0.val[1]) ), vqmovun_s16( vcombine_s16(tmp1.val[0], tmp1.val[1]) ), } }; vst2_u8(ptr, out); }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1901, + "column": 3, + "source_line": " #define stbir__interleave_pack_and_store_16_u8( ptr, r0, r1, r2, r3 ) \\" + } + }, + { + "name": "stbir__simdf_load4_transposed", + "value": "{ float32x4x4_t tmp = vld4q_f32(ptr); o0 = tmp.val[0]; o1 = tmp.val[1]; o2 = tmp.val[2]; o3 = tmp.val[3]; }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1913, + "column": 3, + "source_line": " #define stbir__simdf_load4_transposed( o0, o1, o2, o3, ptr ) \\" + } + }, + { + "name": "stbir__simdi_32shr", + "value": "out = vshrq_n_u32( reg, imm )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1922, + "column": 3, + "source_line": " #define stbir__simdi_32shr( out, reg, imm ) out = vshrq_n_u32( reg, imm )" + } + }, + { + "name": "STBIR__SIMDF_CONST", + "value": "__declspec(align(8)) float var[] = { x, x, x, x }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1925, + "column": 5, + "source_line": " #define STBIR__SIMDF_CONST(var, x) __declspec(align(8)) float var[] = { x, x, x, x }" + } + }, + { + "name": "STBIR__SIMDI_CONST", + "value": "__declspec(align(8)) uint32_t var[] = { x, x, x, x }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1926, + "column": 5, + "source_line": " #define STBIR__SIMDI_CONST(var, x) __declspec(align(8)) uint32_t var[] = { x, x, x, x }" + } + }, + { + "name": "STBIR__CONSTF", + "value": "(*(const float32x4_t*)var)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1927, + "column": 5, + "source_line": " #define STBIR__CONSTF(var) (*(const float32x4_t*)var)" + } + }, + { + "name": "STBIR__CONSTI", + "value": "(*(const uint32x4_t*)var)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1928, + "column": 5, + "source_line": " #define STBIR__CONSTI(var) (*(const uint32x4_t*)var)" + } + }, + { + "name": "STBIR__SIMDF_CONST", + "value": "stbir__simdf var = { x, x, x, x }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1930, + "column": 5, + "source_line": " #define STBIR__SIMDF_CONST(var, x) stbir__simdf var = { x, x, x, x }" + } + }, + { + "name": "STBIR__SIMDI_CONST", + "value": "stbir__simdi var = { x, x, x, x }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1931, + "column": 5, + "source_line": " #define STBIR__SIMDI_CONST(var, x) stbir__simdi var = { x, x, x, x }" + } + }, + { + "name": "STBIR__CONSTF", + "value": "(var)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1932, + "column": 5, + "source_line": " #define STBIR__CONSTF(var) (var)" + } + }, + { + "name": "STBIR__CONSTI", + "value": "(var)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1933, + "column": 5, + "source_line": " #define STBIR__CONSTI(var) (var)" + } + }, + { + "name": "STBIR_FLOORF", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1937, + "column": 3, + "source_line": " #undef STBIR_FLOORF" + } + }, + { + "name": "STBIR_FLOORF", + "value": "stbir_simd_floorf", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1939, + "column": 3, + "source_line": " #define STBIR_FLOORF stbir_simd_floorf" + } + }, + { + "name": "STBIR_CEILF", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1955, + "column": 3, + "source_line": " #undef STBIR_CEILF" + } + }, + { + "name": "STBIR_CEILF", + "value": "stbir_simd_ceilf", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1957, + "column": 3, + "source_line": " #define STBIR_CEILF stbir_simd_ceilf" + } + }, + { + "name": "STBIR_SIMD", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1972, + "column": 3, + "source_line": " #define STBIR_SIMD" + } + }, + { + "name": "stbir__simdf", + "value": "v128_t", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1978, + "column": 3, + "source_line": " #define stbir__simdf v128_t" + } + }, + { + "name": "stbir__simdi", + "value": "v128_t", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1979, + "column": 3, + "source_line": " #define stbir__simdi v128_t" + } + }, + { + "name": "stbir_simdi_castf", + "value": "(reg)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1981, + "column": 3, + "source_line": " #define stbir_simdi_castf( reg ) (reg)" + } + }, + { + "name": "stbir_simdf_casti", + "value": "(reg)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1982, + "column": 3, + "source_line": " #define stbir_simdf_casti( reg ) (reg)" + } + }, + { + "name": "stbir__simdf_load", + "value": "(reg) = wasm_v128_load( (void const*)(ptr) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1984, + "column": 3, + "source_line": " #define stbir__simdf_load( reg, ptr ) (reg) = wasm_v128_load( (void const*)(ptr) )" + } + }, + { + "name": "stbir__simdi_load", + "value": "(reg) = wasm_v128_load( (void const*)(ptr) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1985, + "column": 3, + "source_line": " #define stbir__simdi_load( reg, ptr ) (reg) = wasm_v128_load( (void const*)(ptr) )" + } + }, + { + "name": "stbir__simdf_load1", + "value": "(out) = wasm_v128_load32_splat( (void const*)(ptr) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1986, + "column": 3, + "source_line": " #define stbir__simdf_load1( out, ptr ) (out) = wasm_v128_load32_splat( (void const*)(ptr) ) // top values can be random (not denormal or nan for perf)" + } + }, + { + "name": "stbir__simdi_load1", + "value": "(out) = wasm_v128_load32_splat( (void const*)(ptr) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1987, + "column": 3, + "source_line": " #define stbir__simdi_load1( out, ptr ) (out) = wasm_v128_load32_splat( (void const*)(ptr) )" + } + }, + { + "name": "stbir__simdf_load1z", + "value": "(out) = wasm_v128_load32_zero( (void const*)(ptr) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1988, + "column": 3, + "source_line": " #define stbir__simdf_load1z( out, ptr ) (out) = wasm_v128_load32_zero( (void const*)(ptr) ) // top values must be zero" + } + }, + { + "name": "stbir__simdf_frep4", + "value": "wasm_f32x4_splat( fvar )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1989, + "column": 3, + "source_line": " #define stbir__simdf_frep4( fvar ) wasm_f32x4_splat( fvar )" + } + }, + { + "name": "stbir__simdf_load1frep4", + "value": "(out) = wasm_f32x4_splat( fvar )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1990, + "column": 3, + "source_line": " #define stbir__simdf_load1frep4( out, fvar ) (out) = wasm_f32x4_splat( fvar )" + } + }, + { + "name": "stbir__simdf_load2", + "value": "(out) = wasm_v128_load64_splat( (void const*)(ptr) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1991, + "column": 3, + "source_line": " #define stbir__simdf_load2( out, ptr ) (out) = wasm_v128_load64_splat( (void const*)(ptr) ) // top values can be random (not denormal or nan for perf)" + } + }, + { + "name": "stbir__simdf_load2z", + "value": "(out) = wasm_v128_load64_zero( (void const*)(ptr) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1992, + "column": 3, + "source_line": " #define stbir__simdf_load2z( out, ptr ) (out) = wasm_v128_load64_zero( (void const*)(ptr) ) // top values must be zero" + } + }, + { + "name": "stbir__simdf_load2hmerge", + "value": "(out) = wasm_v128_load64_lane( (void const*)(ptr), reg, 1 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1993, + "column": 3, + "source_line": " #define stbir__simdf_load2hmerge( out, reg, ptr ) (out) = wasm_v128_load64_lane( (void const*)(ptr), reg, 1 )" + } + }, + { + "name": "stbir__simdf_zeroP", + "value": "wasm_f32x4_const_splat(0)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1995, + "column": 3, + "source_line": " #define stbir__simdf_zeroP() wasm_f32x4_const_splat(0)" + } + }, + { + "name": "stbir__simdf_zero", + "value": "(reg) = wasm_f32x4_const_splat(0)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1996, + "column": 3, + "source_line": " #define stbir__simdf_zero( reg ) (reg) = wasm_f32x4_const_splat(0)" + } + }, + { + "name": "stbir__simdf_store", + "value": "wasm_v128_store( (void*)(ptr), reg )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1998, + "column": 3, + "source_line": " #define stbir__simdf_store( ptr, reg ) wasm_v128_store( (void*)(ptr), reg )" + } + }, + { + "name": "stbir__simdf_store1", + "value": "wasm_v128_store32_lane( (void*)(ptr), reg, 0 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1999, + "column": 3, + "source_line": " #define stbir__simdf_store1( ptr, reg ) wasm_v128_store32_lane( (void*)(ptr), reg, 0 )" + } + }, + { + "name": "stbir__simdf_store2", + "value": "wasm_v128_store64_lane( (void*)(ptr), reg, 0 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2000, + "column": 3, + "source_line": " #define stbir__simdf_store2( ptr, reg ) wasm_v128_store64_lane( (void*)(ptr), reg, 0 )" + } + }, + { + "name": "stbir__simdf_store2h", + "value": "wasm_v128_store64_lane( (void*)(ptr), reg, 1 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2001, + "column": 3, + "source_line": " #define stbir__simdf_store2h( ptr, reg ) wasm_v128_store64_lane( (void*)(ptr), reg, 1 )" + } + }, + { + "name": "stbir__simdi_store", + "value": "wasm_v128_store( (void*)(ptr), reg )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2003, + "column": 3, + "source_line": " #define stbir__simdi_store( ptr, reg ) wasm_v128_store( (void*)(ptr), reg )" + } + }, + { + "name": "stbir__simdi_store1", + "value": "wasm_v128_store32_lane( (void*)(ptr), reg, 0 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2004, + "column": 3, + "source_line": " #define stbir__simdi_store1( ptr, reg ) wasm_v128_store32_lane( (void*)(ptr), reg, 0 )" + } + }, + { + "name": "stbir__simdi_store2", + "value": "wasm_v128_store64_lane( (void*)(ptr), reg, 0 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2005, + "column": 3, + "source_line": " #define stbir__simdi_store2( ptr, reg ) wasm_v128_store64_lane( (void*)(ptr), reg, 0 )" + } + }, + { + "name": "stbir__prefetch", + "value": null, + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2007, + "column": 3, + "source_line": " #define stbir__prefetch( ptr )" + } + }, + { + "name": "stbir__simdi_expand_u8_to_u32", + "value": "{ v128_t l = wasm_u16x8_extend_low_u8x16 ( ireg ); v128_t h = wasm_u16x8_extend_high_u8x16( ireg ); out0 = wasm_u32x4_extend_low_u16x8 ( l ); out1 = wasm_u32x4_extend_high_u16x8( l ); out2 = wasm_u32x4_extend_low_u16x8 ( h ); out3 = wasm_u32x4_extend_high_u16x8( h ); }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2009, + "column": 3, + "source_line": " #define stbir__simdi_expand_u8_to_u32(out0,out1,out2,out3,ireg) \\" + } + }, + { + "name": "stbir__simdi_expand_u8_to_1u32", + "value": "{ v128_t tmp = wasm_u16x8_extend_low_u8x16(ireg); out = wasm_u32x4_extend_low_u16x8(tmp); }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2019, + "column": 3, + "source_line": " #define stbir__simdi_expand_u8_to_1u32(out,ireg) \\" + } + }, + { + "name": "stbir__simdi_expand_u16_to_u32", + "value": "{ out0 = wasm_u32x4_extend_low_u16x8 ( ireg ); out1 = wasm_u32x4_extend_high_u16x8( ireg ); }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2025, + "column": 3, + "source_line": " #define stbir__simdi_expand_u16_to_u32(out0,out1,ireg) \\" + } + }, + { + "name": "stbir__simdf_convert_float_to_i32", + "value": "(i) = wasm_i32x4_trunc_sat_f32x4(f)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2031, + "column": 3, + "source_line": " #define stbir__simdf_convert_float_to_i32( i, f ) (i) = wasm_i32x4_trunc_sat_f32x4(f)" + } + }, + { + "name": "stbir__simdf_convert_float_to_int", + "value": "wasm_i32x4_extract_lane(wasm_i32x4_trunc_sat_f32x4(f), 0)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2032, + "column": 3, + "source_line": " #define stbir__simdf_convert_float_to_int( f ) wasm_i32x4_extract_lane(wasm_i32x4_trunc_sat_f32x4(f), 0)" + } + }, + { + "name": "stbir__simdi_to_int", + "value": "wasm_i32x4_extract_lane(i, 0)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2033, + "column": 3, + "source_line": " #define stbir__simdi_to_int( i ) wasm_i32x4_extract_lane(i, 0)" + } + }, + { + "name": "stbir__simdf_convert_float_to_uint8", + "value": "((unsigned char)wasm_i32x4_extract_lane(wasm_i32x4_trunc_sat_f32x4(wasm_f32x4_max(wasm_f32x4_min(f,STBIR_max_uint8_as_float),wasm_f32x4_const_splat(0))), 0))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2034, + "column": 3, + "source_line": " #define stbir__simdf_convert_float_to_uint8( f ) ((unsigned char)wasm_i32x4_extract_lane(wasm_i32x4_trunc_sat_f32x4(wasm_f32x4_max(wasm_f32x4_min(f,STBIR_max_uint8_as_float),wasm_f32x4_const_splat(0))), 0))" + } + }, + { + "name": "stbir__simdf_convert_float_to_short", + "value": "((unsigned short)wasm_i32x4_extract_lane(wasm_i32x4_trunc_sat_f32x4(wasm_f32x4_max(wasm_f32x4_min(f,STBIR_max_uint16_as_float),wasm_f32x4_const_splat(0))), 0))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2035, + "column": 3, + "source_line": " #define stbir__simdf_convert_float_to_short( f ) ((unsigned short)wasm_i32x4_extract_lane(wasm_i32x4_trunc_sat_f32x4(wasm_f32x4_max(wasm_f32x4_min(f,STBIR_max_uint16_as_float),wasm_f32x4_const_splat(0))), 0))" + } + }, + { + "name": "stbir__simdi_convert_i32_to_float", + "value": "(out) = wasm_f32x4_convert_i32x4(ireg)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2036, + "column": 3, + "source_line": " #define stbir__simdi_convert_i32_to_float(out, ireg) (out) = wasm_f32x4_convert_i32x4(ireg)" + } + }, + { + "name": "stbir__simdf_add", + "value": "(out) = wasm_f32x4_add( reg0, reg1 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2037, + "column": 3, + "source_line": " #define stbir__simdf_add( out, reg0, reg1 ) (out) = wasm_f32x4_add( reg0, reg1 )" + } + }, + { + "name": "stbir__simdf_mult", + "value": "(out) = wasm_f32x4_mul( reg0, reg1 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2038, + "column": 3, + "source_line": " #define stbir__simdf_mult( out, reg0, reg1 ) (out) = wasm_f32x4_mul( reg0, reg1 )" + } + }, + { + "name": "stbir__simdf_mult_mem", + "value": "(out) = wasm_f32x4_mul( reg, wasm_v128_load( (void const*)(ptr) ) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2039, + "column": 3, + "source_line": " #define stbir__simdf_mult_mem( out, reg, ptr ) (out) = wasm_f32x4_mul( reg, wasm_v128_load( (void const*)(ptr) ) )" + } + }, + { + "name": "stbir__simdf_mult1_mem", + "value": "(out) = wasm_f32x4_mul( reg, wasm_v128_load32_splat( (void const*)(ptr) ) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2040, + "column": 3, + "source_line": " #define stbir__simdf_mult1_mem( out, reg, ptr ) (out) = wasm_f32x4_mul( reg, wasm_v128_load32_splat( (void const*)(ptr) ) )" + } + }, + { + "name": "stbir__simdf_add_mem", + "value": "(out) = wasm_f32x4_add( reg, wasm_v128_load( (void const*)(ptr) ) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2041, + "column": 3, + "source_line": " #define stbir__simdf_add_mem( out, reg, ptr ) (out) = wasm_f32x4_add( reg, wasm_v128_load( (void const*)(ptr) ) )" + } + }, + { + "name": "stbir__simdf_add1_mem", + "value": "(out) = wasm_f32x4_add( reg, wasm_v128_load32_splat( (void const*)(ptr) ) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2042, + "column": 3, + "source_line": " #define stbir__simdf_add1_mem( out, reg, ptr ) (out) = wasm_f32x4_add( reg, wasm_v128_load32_splat( (void const*)(ptr) ) )" + } + }, + { + "name": "stbir__simdf_madd", + "value": "(out) = wasm_f32x4_add( add, wasm_f32x4_mul( mul1, mul2 ) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2044, + "column": 3, + "source_line": " #define stbir__simdf_madd( out, add, mul1, mul2 ) (out) = wasm_f32x4_add( add, wasm_f32x4_mul( mul1, mul2 ) )" + } + }, + { + "name": "stbir__simdf_madd1", + "value": "(out) = wasm_f32x4_add( add, wasm_f32x4_mul( mul1, mul2 ) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2045, + "column": 3, + "source_line": " #define stbir__simdf_madd1( out, add, mul1, mul2 ) (out) = wasm_f32x4_add( add, wasm_f32x4_mul( mul1, mul2 ) )" + } + }, + { + "name": "stbir__simdf_madd_mem", + "value": "(out) = wasm_f32x4_add( add, wasm_f32x4_mul( mul, wasm_v128_load( (void const*)(ptr) ) ) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2046, + "column": 3, + "source_line": " #define stbir__simdf_madd_mem( out, add, mul, ptr ) (out) = wasm_f32x4_add( add, wasm_f32x4_mul( mul, wasm_v128_load( (void const*)(ptr) ) ) )" + } + }, + { + "name": "stbir__simdf_madd1_mem", + "value": "(out) = wasm_f32x4_add( add, wasm_f32x4_mul( mul, wasm_v128_load32_splat( (void const*)(ptr) ) ) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2047, + "column": 3, + "source_line": " #define stbir__simdf_madd1_mem( out, add, mul, ptr ) (out) = wasm_f32x4_add( add, wasm_f32x4_mul( mul, wasm_v128_load32_splat( (void const*)(ptr) ) ) )" + } + }, + { + "name": "stbir__simdf_add1", + "value": "(out) = wasm_f32x4_add( reg0, reg1 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2049, + "column": 3, + "source_line": " #define stbir__simdf_add1( out, reg0, reg1 ) (out) = wasm_f32x4_add( reg0, reg1 )" + } + }, + { + "name": "stbir__simdf_mult1", + "value": "(out) = wasm_f32x4_mul( reg0, reg1 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2050, + "column": 3, + "source_line": " #define stbir__simdf_mult1( out, reg0, reg1 ) (out) = wasm_f32x4_mul( reg0, reg1 )" + } + }, + { + "name": "stbir__simdf_and", + "value": "(out) = wasm_v128_and( reg0, reg1 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2052, + "column": 3, + "source_line": " #define stbir__simdf_and( out, reg0, reg1 ) (out) = wasm_v128_and( reg0, reg1 )" + } + }, + { + "name": "stbir__simdf_or", + "value": "(out) = wasm_v128_or( reg0, reg1 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2053, + "column": 3, + "source_line": " #define stbir__simdf_or( out, reg0, reg1 ) (out) = wasm_v128_or( reg0, reg1 )" + } + }, + { + "name": "stbir__simdf_min", + "value": "(out) = wasm_f32x4_min( reg0, reg1 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2055, + "column": 3, + "source_line": " #define stbir__simdf_min( out, reg0, reg1 ) (out) = wasm_f32x4_min( reg0, reg1 )" + } + }, + { + "name": "stbir__simdf_max", + "value": "(out) = wasm_f32x4_max( reg0, reg1 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2056, + "column": 3, + "source_line": " #define stbir__simdf_max( out, reg0, reg1 ) (out) = wasm_f32x4_max( reg0, reg1 )" + } + }, + { + "name": "stbir__simdf_min1", + "value": "(out) = wasm_f32x4_min( reg0, reg1 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2057, + "column": 3, + "source_line": " #define stbir__simdf_min1( out, reg0, reg1 ) (out) = wasm_f32x4_min( reg0, reg1 )" + } + }, + { + "name": "stbir__simdf_max1", + "value": "(out) = wasm_f32x4_max( reg0, reg1 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2058, + "column": 3, + "source_line": " #define stbir__simdf_max1( out, reg0, reg1 ) (out) = wasm_f32x4_max( reg0, reg1 )" + } + }, + { + "name": "stbir__simdf_0123ABCDto3ABx", + "value": "(out) = wasm_i32x4_shuffle( reg0, reg1, 3, 4, 5, -1 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2060, + "column": 3, + "source_line": " #define stbir__simdf_0123ABCDto3ABx( out, reg0, reg1 ) (out) = wasm_i32x4_shuffle( reg0, reg1, 3, 4, 5, -1 )" + } + }, + { + "name": "stbir__simdf_0123ABCDto23Ax", + "value": "(out) = wasm_i32x4_shuffle( reg0, reg1, 2, 3, 4, -1 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2061, + "column": 3, + "source_line": " #define stbir__simdf_0123ABCDto23Ax( out, reg0, reg1 ) (out) = wasm_i32x4_shuffle( reg0, reg1, 2, 3, 4, -1 )" + } + }, + { + "name": "stbir__simdf_aaa1", + "value": "(out) = wasm_i32x4_shuffle(alp, ones, 3, 3, 3, 4)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2063, + "column": 3, + "source_line": " #define stbir__simdf_aaa1(out,alp,ones) (out) = wasm_i32x4_shuffle(alp, ones, 3, 3, 3, 4)" + } + }, + { + "name": "stbir__simdf_1aaa", + "value": "(out) = wasm_i32x4_shuffle(alp, ones, 4, 0, 0, 0)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2064, + "column": 3, + "source_line": " #define stbir__simdf_1aaa(out,alp,ones) (out) = wasm_i32x4_shuffle(alp, ones, 4, 0, 0, 0)" + } + }, + { + "name": "stbir__simdf_a1a1", + "value": "(out) = wasm_i32x4_shuffle(alp, ones, 1, 4, 3, 4)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2065, + "column": 3, + "source_line": " #define stbir__simdf_a1a1(out,alp,ones) (out) = wasm_i32x4_shuffle(alp, ones, 1, 4, 3, 4)" + } + }, + { + "name": "stbir__simdf_1a1a", + "value": "(out) = wasm_i32x4_shuffle(alp, ones, 4, 0, 4, 2)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2066, + "column": 3, + "source_line": " #define stbir__simdf_1a1a(out,alp,ones) (out) = wasm_i32x4_shuffle(alp, ones, 4, 0, 4, 2)" + } + }, + { + "name": "stbir__simdf_swiz", + "value": "wasm_i32x4_shuffle(reg, reg, one, two, three, four)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2068, + "column": 3, + "source_line": " #define stbir__simdf_swiz( reg, one, two, three, four ) wasm_i32x4_shuffle(reg, reg, one, two, three, four)" + } + }, + { + "name": "stbir__simdi_and", + "value": "(out) = wasm_v128_and( reg0, reg1 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2070, + "column": 3, + "source_line": " #define stbir__simdi_and( out, reg0, reg1 ) (out) = wasm_v128_and( reg0, reg1 )" + } + }, + { + "name": "stbir__simdi_or", + "value": "(out) = wasm_v128_or( reg0, reg1 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2071, + "column": 3, + "source_line": " #define stbir__simdi_or( out, reg0, reg1 ) (out) = wasm_v128_or( reg0, reg1 )" + } + }, + { + "name": "stbir__simdi_16madd", + "value": "(out) = wasm_i32x4_dot_i16x8( reg0, reg1 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2072, + "column": 3, + "source_line": " #define stbir__simdi_16madd( out, reg0, reg1 ) (out) = wasm_i32x4_dot_i16x8( reg0, reg1 )" + } + }, + { + "name": "stbir__simdf_pack_to_8bytes", + "value": "{ v128_t af = wasm_f32x4_max( wasm_f32x4_min(aa, STBIR_max_uint8_as_float), wasm_f32x4_const_splat(0) ); v128_t bf = wasm_f32x4_max( wasm_f32x4_min(bb, STBIR_max_uint8_as_float), wasm_f32x4_const_splat(0) ); v128_t ai = wasm_i32x4_trunc_sat_f32x4( af ); v128_t bi = wasm_i32x4_trunc_sat_f32x4( bf ); v128_t out16 = wasm_i16x8_narrow_i32x4( ai, bi ); out = wasm_u8x16_narrow_i16x8( out16, out16 ); }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2074, + "column": 3, + "source_line": " #define stbir__simdf_pack_to_8bytes(out,aa,bb) \\" + } + }, + { + "name": "stbir__simdf_pack_to_8words", + "value": "{ v128_t af = wasm_f32x4_max( wasm_f32x4_min(aa, STBIR_max_uint16_as_float), wasm_f32x4_const_splat(0)); v128_t bf = wasm_f32x4_max( wasm_f32x4_min(bb, STBIR_max_uint16_as_float), wasm_f32x4_const_splat(0)); v128_t ai = wasm_i32x4_trunc_sat_f32x4( af ); v128_t bi = wasm_i32x4_trunc_sat_f32x4( bf ); out = wasm_u16x8_narrow_i32x4( ai, bi ); }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2084, + "column": 3, + "source_line": " #define stbir__simdf_pack_to_8words(out,aa,bb) \\" + } + }, + { + "name": "stbir__interleave_pack_and_store_16_u8", + "value": "{ v128_t tmp0 = wasm_i16x8_narrow_i32x4(r0, r1); v128_t tmp1 = wasm_i16x8_narrow_i32x4(r2, r3); v128_t tmp = wasm_u8x16_narrow_i16x8(tmp0, tmp1); tmp = wasm_i8x16_shuffle(tmp, tmp, 0, 4, 8, 12, 1, 5, 9, 13, 2, 6, 10, 14, 3, 7, 11, 15); wasm_v128_store( (void*)(ptr), tmp); }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2093, + "column": 3, + "source_line": " #define stbir__interleave_pack_and_store_16_u8( ptr, r0, r1, r2, r3 ) \\" + } + }, + { + "name": "stbir__simdf_load4_transposed", + "value": "{ v128_t t0 = wasm_v128_load( ptr ); v128_t t1 = wasm_v128_load( ptr+4 ); v128_t t2 = wasm_v128_load( ptr+8 ); v128_t t3 = wasm_v128_load( ptr+12 ); v128_t s0 = wasm_i32x4_shuffle(t0, t1, 0, 4, 2, 6); v128_t s1 = wasm_i32x4_shuffle(t0, t1, 1, 5, 3, 7); v128_t s2 = wasm_i32x4_shuffle(t2, t3, 0, 4, 2, 6); v128_t s3 = wasm_i32x4_shuffle(t2, t3, 1, 5, 3, 7); o0 = wasm_i32x4_shuffle(s0, s2, 0, 1, 4, 5); o1 = wasm_i32x4_shuffle(s1, s3, 0, 1, 4, 5); o2 = wasm_i32x4_shuffle(s0, s2, 2, 3, 6, 7); o3 = wasm_i32x4_shuffle(s1, s3, 2, 3, 6, 7); }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2102, + "column": 3, + "source_line": " #define stbir__simdf_load4_transposed( o0, o1, o2, o3, ptr ) \\" + } + }, + { + "name": "stbir__simdi_32shr", + "value": "out = wasm_u32x4_shr( reg, imm )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2118, + "column": 3, + "source_line": " #define stbir__simdi_32shr( out, reg, imm ) out = wasm_u32x4_shr( reg, imm )" + } + }, + { + "name": "STBIR__SIMDF_CONST", + "value": "stbir__simdf var = (v128_t)(stbir__f32x4){ x, x, x, x }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2121, + "column": 3, + "source_line": " #define STBIR__SIMDF_CONST(var, x) stbir__simdf var = (v128_t)(stbir__f32x4){ x, x, x, x }" + } + }, + { + "name": "STBIR__SIMDI_CONST", + "value": "stbir__simdi var = { x, x, x, x }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2122, + "column": 3, + "source_line": " #define STBIR__SIMDI_CONST(var, x) stbir__simdi var = { x, x, x, x }" + } + }, + { + "name": "STBIR__CONSTF", + "value": "(var)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2123, + "column": 3, + "source_line": " #define STBIR__CONSTF(var) (var)" + } + }, + { + "name": "STBIR__CONSTI", + "value": "(var)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2124, + "column": 3, + "source_line": " #define STBIR__CONSTI(var) (var)" + } + }, + { + "name": "STBIR_FLOORF", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2127, + "column": 3, + "source_line": " #undef STBIR_FLOORF" + } + }, + { + "name": "STBIR_FLOORF", + "value": "stbir_simd_floorf", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2129, + "column": 3, + "source_line": " #define STBIR_FLOORF stbir_simd_floorf" + } + }, + { + "name": "STBIR_CEILF", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2136, + "column": 3, + "source_line": " #undef STBIR_CEILF" + } + }, + { + "name": "STBIR_CEILF", + "value": "stbir_simd_ceilf", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2138, + "column": 3, + "source_line": " #define STBIR_CEILF stbir_simd_ceilf" + } + }, + { + "name": "STBIR_SIMD", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2144, + "column": 3, + "source_line": " #define STBIR_SIMD" + } + }, + { + "name": "stbir__simdfX", + "value": "stbir__simdf8", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2151, + "column": 3, + "source_line": " #define stbir__simdfX stbir__simdf8" + } + }, + { + "name": "stbir__simdiX", + "value": "stbir__simdi8", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2152, + "column": 3, + "source_line": " #define stbir__simdiX stbir__simdi8" + } + }, + { + "name": "stbir__simdfX_load", + "value": "stbir__simdf8_load", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2153, + "column": 3, + "source_line": " #define stbir__simdfX_load stbir__simdf8_load" + } + }, + { + "name": "stbir__simdiX_load", + "value": "stbir__simdi8_load", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2154, + "column": 3, + "source_line": " #define stbir__simdiX_load stbir__simdi8_load" + } + }, + { + "name": "stbir__simdfX_mult", + "value": "stbir__simdf8_mult", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2155, + "column": 3, + "source_line": " #define stbir__simdfX_mult stbir__simdf8_mult" + } + }, + { + "name": "stbir__simdfX_add_mem", + "value": "stbir__simdf8_add_mem", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2156, + "column": 3, + "source_line": " #define stbir__simdfX_add_mem stbir__simdf8_add_mem" + } + }, + { + "name": "stbir__simdfX_madd_mem", + "value": "stbir__simdf8_madd_mem", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2157, + "column": 3, + "source_line": " #define stbir__simdfX_madd_mem stbir__simdf8_madd_mem" + } + }, + { + "name": "stbir__simdfX_store", + "value": "stbir__simdf8_store", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2158, + "column": 3, + "source_line": " #define stbir__simdfX_store stbir__simdf8_store" + } + }, + { + "name": "stbir__simdiX_store", + "value": "stbir__simdi8_store", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2159, + "column": 3, + "source_line": " #define stbir__simdiX_store stbir__simdi8_store" + } + }, + { + "name": "stbir__simdf_frepX", + "value": "stbir__simdf8_frep8", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2160, + "column": 3, + "source_line": " #define stbir__simdf_frepX stbir__simdf8_frep8" + } + }, + { + "name": "stbir__simdfX_madd", + "value": "stbir__simdf8_madd", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2161, + "column": 3, + "source_line": " #define stbir__simdfX_madd stbir__simdf8_madd" + } + }, + { + "name": "stbir__simdfX_min", + "value": "stbir__simdf8_min", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2162, + "column": 3, + "source_line": " #define stbir__simdfX_min stbir__simdf8_min" + } + }, + { + "name": "stbir__simdfX_max", + "value": "stbir__simdf8_max", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2163, + "column": 3, + "source_line": " #define stbir__simdfX_max stbir__simdf8_max" + } + }, + { + "name": "stbir__simdfX_aaa1", + "value": "stbir__simdf8_aaa1", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2164, + "column": 3, + "source_line": " #define stbir__simdfX_aaa1 stbir__simdf8_aaa1" + } + }, + { + "name": "stbir__simdfX_1aaa", + "value": "stbir__simdf8_1aaa", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2165, + "column": 3, + "source_line": " #define stbir__simdfX_1aaa stbir__simdf8_1aaa" + } + }, + { + "name": "stbir__simdfX_a1a1", + "value": "stbir__simdf8_a1a1", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2166, + "column": 3, + "source_line": " #define stbir__simdfX_a1a1 stbir__simdf8_a1a1" + } + }, + { + "name": "stbir__simdfX_1a1a", + "value": "stbir__simdf8_1a1a", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2167, + "column": 3, + "source_line": " #define stbir__simdfX_1a1a stbir__simdf8_1a1a" + } + }, + { + "name": "stbir__simdfX_convert_float_to_i32", + "value": "stbir__simdf8_convert_float_to_i32", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2168, + "column": 3, + "source_line": " #define stbir__simdfX_convert_float_to_i32 stbir__simdf8_convert_float_to_i32" + } + }, + { + "name": "stbir__simdfX_pack_to_words", + "value": "stbir__simdf8_pack_to_16words", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2169, + "column": 3, + "source_line": " #define stbir__simdfX_pack_to_words stbir__simdf8_pack_to_16words" + } + }, + { + "name": "stbir__simdfX_zero", + "value": "stbir__simdf8_zero", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2170, + "column": 3, + "source_line": " #define stbir__simdfX_zero stbir__simdf8_zero" + } + }, + { + "name": "STBIR_onesX", + "value": "STBIR_ones8", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2171, + "column": 3, + "source_line": " #define STBIR_onesX STBIR_ones8" + } + }, + { + "name": "STBIR_max_uint8_as_floatX", + "value": "STBIR_max_uint8_as_float8", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2172, + "column": 3, + "source_line": " #define STBIR_max_uint8_as_floatX STBIR_max_uint8_as_float8" + } + }, + { + "name": "STBIR_max_uint16_as_floatX", + "value": "STBIR_max_uint16_as_float8", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2173, + "column": 3, + "source_line": " #define STBIR_max_uint16_as_floatX STBIR_max_uint16_as_float8" + } + }, + { + "name": "STBIR_simd_point5X", + "value": "STBIR_simd_point58", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2174, + "column": 3, + "source_line": " #define STBIR_simd_point5X STBIR_simd_point58" + } + }, + { + "name": "stbir__simdfX_float_count", + "value": "8", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2175, + "column": 3, + "source_line": " #define stbir__simdfX_float_count 8" + } + }, + { + "name": "stbir__simdfX_0123to1230", + "value": "stbir__simdf8_0123to12301230", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2176, + "column": 3, + "source_line": " #define stbir__simdfX_0123to1230 stbir__simdf8_0123to12301230" + } + }, + { + "name": "stbir__simdfX_0123to2103", + "value": "stbir__simdf8_0123to21032103", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2177, + "column": 3, + "source_line": " #define stbir__simdfX_0123to2103 stbir__simdf8_0123to21032103" + } + }, + { + "name": "stbir__simdfX", + "value": "stbir__simdf", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2185, + "column": 3, + "source_line": " #define stbir__simdfX stbir__simdf" + } + }, + { + "name": "stbir__simdiX", + "value": "stbir__simdi", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2186, + "column": 3, + "source_line": " #define stbir__simdiX stbir__simdi" + } + }, + { + "name": "stbir__simdfX_load", + "value": "stbir__simdf_load", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2187, + "column": 3, + "source_line": " #define stbir__simdfX_load stbir__simdf_load" + } + }, + { + "name": "stbir__simdiX_load", + "value": "stbir__simdi_load", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2188, + "column": 3, + "source_line": " #define stbir__simdiX_load stbir__simdi_load" + } + }, + { + "name": "stbir__simdfX_mult", + "value": "stbir__simdf_mult", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2189, + "column": 3, + "source_line": " #define stbir__simdfX_mult stbir__simdf_mult" + } + }, + { + "name": "stbir__simdfX_add_mem", + "value": "stbir__simdf_add_mem", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2190, + "column": 3, + "source_line": " #define stbir__simdfX_add_mem stbir__simdf_add_mem" + } + }, + { + "name": "stbir__simdfX_madd_mem", + "value": "stbir__simdf_madd_mem", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2191, + "column": 3, + "source_line": " #define stbir__simdfX_madd_mem stbir__simdf_madd_mem" + } + }, + { + "name": "stbir__simdfX_store", + "value": "stbir__simdf_store", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2192, + "column": 3, + "source_line": " #define stbir__simdfX_store stbir__simdf_store" + } + }, + { + "name": "stbir__simdiX_store", + "value": "stbir__simdi_store", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2193, + "column": 3, + "source_line": " #define stbir__simdiX_store stbir__simdi_store" + } + }, + { + "name": "stbir__simdf_frepX", + "value": "stbir__simdf_frep4", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2194, + "column": 3, + "source_line": " #define stbir__simdf_frepX stbir__simdf_frep4" + } + }, + { + "name": "stbir__simdfX_madd", + "value": "stbir__simdf_madd", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2195, + "column": 3, + "source_line": " #define stbir__simdfX_madd stbir__simdf_madd" + } + }, + { + "name": "stbir__simdfX_min", + "value": "stbir__simdf_min", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2196, + "column": 3, + "source_line": " #define stbir__simdfX_min stbir__simdf_min" + } + }, + { + "name": "stbir__simdfX_max", + "value": "stbir__simdf_max", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2197, + "column": 3, + "source_line": " #define stbir__simdfX_max stbir__simdf_max" + } + }, + { + "name": "stbir__simdfX_aaa1", + "value": "stbir__simdf_aaa1", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2198, + "column": 3, + "source_line": " #define stbir__simdfX_aaa1 stbir__simdf_aaa1" + } + }, + { + "name": "stbir__simdfX_1aaa", + "value": "stbir__simdf_1aaa", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2199, + "column": 3, + "source_line": " #define stbir__simdfX_1aaa stbir__simdf_1aaa" + } + }, + { + "name": "stbir__simdfX_a1a1", + "value": "stbir__simdf_a1a1", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2200, + "column": 3, + "source_line": " #define stbir__simdfX_a1a1 stbir__simdf_a1a1" + } + }, + { + "name": "stbir__simdfX_1a1a", + "value": "stbir__simdf_1a1a", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2201, + "column": 3, + "source_line": " #define stbir__simdfX_1a1a stbir__simdf_1a1a" + } + }, + { + "name": "stbir__simdfX_convert_float_to_i32", + "value": "stbir__simdf_convert_float_to_i32", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2202, + "column": 3, + "source_line": " #define stbir__simdfX_convert_float_to_i32 stbir__simdf_convert_float_to_i32" + } + }, + { + "name": "stbir__simdfX_pack_to_words", + "value": "stbir__simdf_pack_to_8words", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2203, + "column": 3, + "source_line": " #define stbir__simdfX_pack_to_words stbir__simdf_pack_to_8words" + } + }, + { + "name": "stbir__simdfX_zero", + "value": "stbir__simdf_zero", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2204, + "column": 3, + "source_line": " #define stbir__simdfX_zero stbir__simdf_zero" + } + }, + { + "name": "STBIR_onesX", + "value": "STBIR__CONSTF(STBIR_ones)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2205, + "column": 3, + "source_line": " #define STBIR_onesX STBIR__CONSTF(STBIR_ones)" + } + }, + { + "name": "STBIR_simd_point5X", + "value": "STBIR__CONSTF(STBIR_simd_point5)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2206, + "column": 3, + "source_line": " #define STBIR_simd_point5X STBIR__CONSTF(STBIR_simd_point5)" + } + }, + { + "name": "STBIR_max_uint8_as_floatX", + "value": "STBIR__CONSTF(STBIR_max_uint8_as_float)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2207, + "column": 3, + "source_line": " #define STBIR_max_uint8_as_floatX STBIR__CONSTF(STBIR_max_uint8_as_float)" + } + }, + { + "name": "STBIR_max_uint16_as_floatX", + "value": "STBIR__CONSTF(STBIR_max_uint16_as_float)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2208, + "column": 3, + "source_line": " #define STBIR_max_uint16_as_floatX STBIR__CONSTF(STBIR_max_uint16_as_float)" + } + }, + { + "name": "stbir__simdfX_float_count", + "value": "4", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2209, + "column": 3, + "source_line": " #define stbir__simdfX_float_count 4" + } + }, + { + "name": "stbir__if_simdf8_cast_to_simdf4", + "value": "( val )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2210, + "column": 3, + "source_line": " #define stbir__if_simdf8_cast_to_simdf4( val ) ( val )" + } + }, + { + "name": "stbir__simdfX_0123to1230", + "value": "stbir__simdf_0123to1230", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2211, + "column": 3, + "source_line": " #define stbir__simdfX_0123to1230 stbir__simdf_0123to1230" + } + }, + { + "name": "stbir__simdfX_0123to2103", + "value": "stbir__simdf_0123to2103", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2212, + "column": 3, + "source_line": " #define stbir__simdfX_0123to2103 stbir__simdf_0123to2103" + } + }, + { + "name": "stbir__simdf_0123to3333", + "value": "(out) = stbir__simdf_swiz( reg, 3,3,3,3 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2536, + "column": 1, + "source_line": "#define stbir__simdf_0123to3333( out, reg ) (out) = stbir__simdf_swiz( reg, 3,3,3,3 )" + } + }, + { + "name": "stbir__simdf_0123to2222", + "value": "(out) = stbir__simdf_swiz( reg, 2,2,2,2 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2537, + "column": 1, + "source_line": "#define stbir__simdf_0123to2222( out, reg ) (out) = stbir__simdf_swiz( reg, 2,2,2,2 )" + } + }, + { + "name": "stbir__simdf_0123to1111", + "value": "(out) = stbir__simdf_swiz( reg, 1,1,1,1 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2538, + "column": 1, + "source_line": "#define stbir__simdf_0123to1111( out, reg ) (out) = stbir__simdf_swiz( reg, 1,1,1,1 )" + } + }, + { + "name": "stbir__simdf_0123to0000", + "value": "(out) = stbir__simdf_swiz( reg, 0,0,0,0 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2539, + "column": 1, + "source_line": "#define stbir__simdf_0123to0000( out, reg ) (out) = stbir__simdf_swiz( reg, 0,0,0,0 )" + } + }, + { + "name": "stbir__simdf_0123to0003", + "value": "(out) = stbir__simdf_swiz( reg, 0,0,0,3 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2540, + "column": 1, + "source_line": "#define stbir__simdf_0123to0003( out, reg ) (out) = stbir__simdf_swiz( reg, 0,0,0,3 )" + } + }, + { + "name": "stbir__simdf_0123to0001", + "value": "(out) = stbir__simdf_swiz( reg, 0,0,0,1 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2541, + "column": 1, + "source_line": "#define stbir__simdf_0123to0001( out, reg ) (out) = stbir__simdf_swiz( reg, 0,0,0,1 )" + } + }, + { + "name": "stbir__simdf_0123to1122", + "value": "(out) = stbir__simdf_swiz( reg, 1,1,2,2 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2542, + "column": 1, + "source_line": "#define stbir__simdf_0123to1122( out, reg ) (out) = stbir__simdf_swiz( reg, 1,1,2,2 )" + } + }, + { + "name": "stbir__simdf_0123to2333", + "value": "(out) = stbir__simdf_swiz( reg, 2,3,3,3 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2543, + "column": 1, + "source_line": "#define stbir__simdf_0123to2333( out, reg ) (out) = stbir__simdf_swiz( reg, 2,3,3,3 )" + } + }, + { + "name": "stbir__simdf_0123to0023", + "value": "(out) = stbir__simdf_swiz( reg, 0,0,2,3 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2544, + "column": 1, + "source_line": "#define stbir__simdf_0123to0023( out, reg ) (out) = stbir__simdf_swiz( reg, 0,0,2,3 )" + } + }, + { + "name": "stbir__simdf_0123to1230", + "value": "(out) = stbir__simdf_swiz( reg, 1,2,3,0 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2545, + "column": 1, + "source_line": "#define stbir__simdf_0123to1230( out, reg ) (out) = stbir__simdf_swiz( reg, 1,2,3,0 )" + } + }, + { + "name": "stbir__simdf_0123to2103", + "value": "(out) = stbir__simdf_swiz( reg, 2,1,0,3 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2546, + "column": 1, + "source_line": "#define stbir__simdf_0123to2103( out, reg ) (out) = stbir__simdf_swiz( reg, 2,1,0,3 )" + } + }, + { + "name": "stbir__simdf_0123to3210", + "value": "(out) = stbir__simdf_swiz( reg, 3,2,1,0 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2547, + "column": 1, + "source_line": "#define stbir__simdf_0123to3210( out, reg ) (out) = stbir__simdf_swiz( reg, 3,2,1,0 )" + } + }, + { + "name": "stbir__simdf_0123to2301", + "value": "(out) = stbir__simdf_swiz( reg, 2,3,0,1 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2548, + "column": 1, + "source_line": "#define stbir__simdf_0123to2301( out, reg ) (out) = stbir__simdf_swiz( reg, 2,3,0,1 )" + } + }, + { + "name": "stbir__simdf_0123to3012", + "value": "(out) = stbir__simdf_swiz( reg, 3,0,1,2 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2549, + "column": 1, + "source_line": "#define stbir__simdf_0123to3012( out, reg ) (out) = stbir__simdf_swiz( reg, 3,0,1,2 )" + } + }, + { + "name": "stbir__simdf_0123to0011", + "value": "(out) = stbir__simdf_swiz( reg, 0,0,1,1 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2550, + "column": 1, + "source_line": "#define stbir__simdf_0123to0011( out, reg ) (out) = stbir__simdf_swiz( reg, 0,0,1,1 )" + } + }, + { + "name": "stbir__simdf_0123to1100", + "value": "(out) = stbir__simdf_swiz( reg, 1,1,0,0 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2551, + "column": 1, + "source_line": "#define stbir__simdf_0123to1100( out, reg ) (out) = stbir__simdf_swiz( reg, 1,1,0,0 )" + } + }, + { + "name": "stbir__simdf_0123to2233", + "value": "(out) = stbir__simdf_swiz( reg, 2,2,3,3 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2552, + "column": 1, + "source_line": "#define stbir__simdf_0123to2233( out, reg ) (out) = stbir__simdf_swiz( reg, 2,2,3,3 )" + } + }, + { + "name": "stbir__simdf_0123to1133", + "value": "(out) = stbir__simdf_swiz( reg, 1,1,3,3 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2553, + "column": 1, + "source_line": "#define stbir__simdf_0123to1133( out, reg ) (out) = stbir__simdf_swiz( reg, 1,1,3,3 )" + } + }, + { + "name": "stbir__simdf_0123to0022", + "value": "(out) = stbir__simdf_swiz( reg, 0,0,2,2 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2554, + "column": 1, + "source_line": "#define stbir__simdf_0123to0022( out, reg ) (out) = stbir__simdf_swiz( reg, 0,0,2,2 )" + } + }, + { + "name": "stbir__simdf_0123to1032", + "value": "(out) = stbir__simdf_swiz( reg, 1,0,3,2 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2555, + "column": 1, + "source_line": "#define stbir__simdf_0123to1032( out, reg ) (out) = stbir__simdf_swiz( reg, 1,0,3,2 )" + } + }, + { + "name": "STBIR_SIMD_STREAMOUT_PTR", + "value": "STBIR_STREAMOUT_PTR( star )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2581, + "column": 1, + "source_line": "#define STBIR_SIMD_STREAMOUT_PTR( star ) STBIR_STREAMOUT_PTR( star )" + } + }, + { + "name": "STBIR_SIMD_NO_UNROLL", + "value": "STBIR_NO_UNROLL(ptr)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2582, + "column": 1, + "source_line": "#define STBIR_SIMD_NO_UNROLL(ptr) STBIR_NO_UNROLL(ptr)" + } + }, + { + "name": "STBIR_SIMD_NO_UNROLL_LOOP_START", + "value": "STBIR_NO_UNROLL_LOOP_START", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2583, + "column": 1, + "source_line": "#define STBIR_SIMD_NO_UNROLL_LOOP_START STBIR_NO_UNROLL_LOOP_START" + } + }, + { + "name": "STBIR_SIMD_NO_UNROLL_LOOP_START_INF_FOR", + "value": "STBIR_NO_UNROLL_LOOP_START_INF_FOR", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2584, + "column": 1, + "source_line": "#define STBIR_SIMD_NO_UNROLL_LOOP_START_INF_FOR STBIR_NO_UNROLL_LOOP_START_INF_FOR" + } + }, + { + "name": "STBIR_MEMCPY", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2587, + "column": 1, + "source_line": "#undef STBIR_MEMCPY" + } + }, + { + "name": "STBIR_MEMCPY", + "value": "stbir_simd_memcpy", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2589, + "column": 1, + "source_line": "#define STBIR_MEMCPY stbir_simd_memcpy" + } + }, + { + "name": "STBIR_SIMD_STREAMOUT_PTR", + "value": "STBIR_STREAMOUT_PTR( star )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2719, + "column": 1, + "source_line": "#define STBIR_SIMD_STREAMOUT_PTR( star ) STBIR_STREAMOUT_PTR( star )" + } + }, + { + "name": "STBIR_SIMD_NO_UNROLL", + "value": null, + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2720, + "column": 1, + "source_line": "#define STBIR_SIMD_NO_UNROLL(ptr)" + } + }, + { + "name": "STBIR_SIMD_NO_UNROLL_LOOP_START", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2721, + "column": 1, + "source_line": "#define STBIR_SIMD_NO_UNROLL_LOOP_START" + } + }, + { + "name": "STBIR_SIMD_NO_UNROLL_LOOP_START_INF_FOR", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2722, + "column": 1, + "source_line": "#define STBIR_SIMD_NO_UNROLL_LOOP_START_INF_FOR" + } + }, + { + "name": "STBIR_PROFILE_FUNC", + "value": "__rdtsc()", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2736, + "column": 3, + "source_line": " #define STBIR_PROFILE_FUNC() __rdtsc()" + } + }, + { + "name": "STBIR_PROFILE_FUNC", + "value": "_ReadStatusReg(ARM64_CNTVCT)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2753, + "column": 3, + "source_line": " #define STBIR_PROFILE_FUNC() _ReadStatusReg(ARM64_CNTVCT)" + } + }, + { + "name": "STBIR_ONLY_PROFILE_GET_SPLIT_INFO", + "value": ",stbir__per_split_info * split_info", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2774, + "column": 1, + "source_line": "#define STBIR_ONLY_PROFILE_GET_SPLIT_INFO ,stbir__per_split_info * split_info" + } + }, + { + "name": "STBIR_ONLY_PROFILE_SET_SPLIT_INFO", + "value": ",split_info", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2775, + "column": 1, + "source_line": "#define STBIR_ONLY_PROFILE_SET_SPLIT_INFO ,split_info" + } + }, + { + "name": "STBIR_ONLY_PROFILE_BUILD_GET_INFO", + "value": ",stbir__info * profile_info", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2777, + "column": 1, + "source_line": "#define STBIR_ONLY_PROFILE_BUILD_GET_INFO ,stbir__info * profile_info" + } + }, + { + "name": "STBIR_ONLY_PROFILE_BUILD_SET_INFO", + "value": ",profile_info", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2778, + "column": 1, + "source_line": "#define STBIR_ONLY_PROFILE_BUILD_SET_INFO ,profile_info" + } + }, + { + "name": "STBIR_PROFILE_START_ll", + "value": "{ stbir_uint64 wh##thiszonetime = STBIR_PROFILE_FUNC(); stbir_uint64 * wh##save_parent_excluded_ptr = info->current_zone_excluded_ptr; stbir_uint64 wh##current_zone_excluded = 0; info->current_zone_excluded_ptr = &wh##current_zone_excluded;", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2781, + "column": 1, + "source_line": "#define STBIR_PROFILE_START_ll( info, wh ) { stbir_uint64 wh##thiszonetime = STBIR_PROFILE_FUNC(); stbir_uint64 * wh##save_parent_excluded_ptr = info->current_zone_excluded_ptr; stbir_uint64 wh##current_zone_excluded = 0; info->current_zone_excluded_ptr = &wh##current_zone_excluded;" + } + }, + { + "name": "STBIR_PROFILE_END_ll", + "value": "wh##thiszonetime = STBIR_PROFILE_FUNC() - wh##thiszonetime; info->profile.named.wh += wh##thiszonetime - wh##current_zone_excluded; *wh##save_parent_excluded_ptr += wh##thiszonetime; info->current_zone_excluded_ptr = wh##save_parent_excluded_ptr; }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2782, + "column": 1, + "source_line": "#define STBIR_PROFILE_END_ll( info, wh ) wh##thiszonetime = STBIR_PROFILE_FUNC() - wh##thiszonetime; info->profile.named.wh += wh##thiszonetime - wh##current_zone_excluded; *wh##save_parent_excluded_ptr += wh##thiszonetime; info->current_zone_excluded_ptr = wh##save_parent_excluded_ptr; }" + } + }, + { + "name": "STBIR_PROFILE_FIRST_START_ll", + "value": "{ int i; info->current_zone_excluded_ptr = &info->profile.named.total; for(i=0;iprofile.array);i++) info->profile.array[i]=0; } STBIR_PROFILE_START_ll( info, wh );", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2783, + "column": 1, + "source_line": "#define STBIR_PROFILE_FIRST_START_ll( info, wh ) { int i; info->current_zone_excluded_ptr = &info->profile.named.total; for(i=0;iprofile.array);i++) info->profile.array[i]=0; } STBIR_PROFILE_START_ll( info, wh );" + } + }, + { + "name": "STBIR_PROFILE_CLEAR_EXTRAS_ll", + "value": "{ int extra; for(extra=1;extra<(num);extra++) { int i; for(i=0;iprofile.array);i++) (info)[extra].profile.array[i]=0; } }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2784, + "column": 1, + "source_line": "#define STBIR_PROFILE_CLEAR_EXTRAS_ll( info, num ) { int extra; for(extra=1;extra<(num);extra++) { int i; for(i=0;iprofile.array);i++) (info)[extra].profile.array[i]=0; } }" + } + }, + { + "name": "STBIR_PROFILE_START", + "value": "STBIR_PROFILE_START_ll( split_info, wh )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2787, + "column": 1, + "source_line": "#define STBIR_PROFILE_START( wh ) STBIR_PROFILE_START_ll( split_info, wh )" + } + }, + { + "name": "STBIR_PROFILE_END", + "value": "STBIR_PROFILE_END_ll( split_info, wh )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2788, + "column": 1, + "source_line": "#define STBIR_PROFILE_END( wh ) STBIR_PROFILE_END_ll( split_info, wh )" + } + }, + { + "name": "STBIR_PROFILE_FIRST_START", + "value": "STBIR_PROFILE_FIRST_START_ll( split_info, wh )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2789, + "column": 1, + "source_line": "#define STBIR_PROFILE_FIRST_START( wh ) STBIR_PROFILE_FIRST_START_ll( split_info, wh )" + } + }, + { + "name": "STBIR_PROFILE_CLEAR_EXTRAS", + "value": "STBIR_PROFILE_CLEAR_EXTRAS_ll( split_info, split_count )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2790, + "column": 1, + "source_line": "#define STBIR_PROFILE_CLEAR_EXTRAS() STBIR_PROFILE_CLEAR_EXTRAS_ll( split_info, split_count )" + } + }, + { + "name": "STBIR_PROFILE_BUILD_START", + "value": "STBIR_PROFILE_START_ll( profile_info, wh )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2793, + "column": 1, + "source_line": "#define STBIR_PROFILE_BUILD_START( wh ) STBIR_PROFILE_START_ll( profile_info, wh )" + } + }, + { + "name": "STBIR_PROFILE_BUILD_END", + "value": "STBIR_PROFILE_END_ll( profile_info, wh )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2794, + "column": 1, + "source_line": "#define STBIR_PROFILE_BUILD_END( wh ) STBIR_PROFILE_END_ll( profile_info, wh )" + } + }, + { + "name": "STBIR_PROFILE_BUILD_FIRST_START", + "value": "STBIR_PROFILE_FIRST_START_ll( profile_info, wh )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2795, + "column": 1, + "source_line": "#define STBIR_PROFILE_BUILD_FIRST_START( wh ) STBIR_PROFILE_FIRST_START_ll( profile_info, wh )" + } + }, + { + "name": "STBIR_PROFILE_BUILD_CLEAR", + "value": "{ int i; for(i=0;iprofile.array);i++) info->profile.array[i]=0; }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2796, + "column": 1, + "source_line": "#define STBIR_PROFILE_BUILD_CLEAR( info ) { int i; for(i=0;iprofile.array);i++) info->profile.array[i]=0; }" + } + }, + { + "name": "STBIR_ONLY_PROFILE_GET_SPLIT_INFO", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2800, + "column": 1, + "source_line": "#define STBIR_ONLY_PROFILE_GET_SPLIT_INFO" + } + }, + { + "name": "STBIR_ONLY_PROFILE_SET_SPLIT_INFO", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2801, + "column": 1, + "source_line": "#define STBIR_ONLY_PROFILE_SET_SPLIT_INFO" + } + }, + { + "name": "STBIR_ONLY_PROFILE_BUILD_GET_INFO", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2803, + "column": 1, + "source_line": "#define STBIR_ONLY_PROFILE_BUILD_GET_INFO" + } + }, + { + "name": "STBIR_ONLY_PROFILE_BUILD_SET_INFO", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2804, + "column": 1, + "source_line": "#define STBIR_ONLY_PROFILE_BUILD_SET_INFO" + } + }, + { + "name": "STBIR_PROFILE_START", + "value": null, + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2806, + "column": 1, + "source_line": "#define STBIR_PROFILE_START( wh )" + } + }, + { + "name": "STBIR_PROFILE_END", + "value": null, + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2807, + "column": 1, + "source_line": "#define STBIR_PROFILE_END( wh )" + } + }, + { + "name": "STBIR_PROFILE_FIRST_START", + "value": null, + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2808, + "column": 1, + "source_line": "#define STBIR_PROFILE_FIRST_START( wh )" + } + }, + { + "name": "STBIR_PROFILE_CLEAR_EXTRAS", + "value": null, + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2809, + "column": 1, + "source_line": "#define STBIR_PROFILE_CLEAR_EXTRAS( )" + } + }, + { + "name": "STBIR_PROFILE_BUILD_START", + "value": null, + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2811, + "column": 1, + "source_line": "#define STBIR_PROFILE_BUILD_START( wh )" + } + }, + { + "name": "STBIR_PROFILE_BUILD_END", + "value": null, + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2812, + "column": 1, + "source_line": "#define STBIR_PROFILE_BUILD_END( wh )" + } + }, + { + "name": "STBIR_PROFILE_BUILD_FIRST_START", + "value": null, + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2813, + "column": 1, + "source_line": "#define STBIR_PROFILE_BUILD_FIRST_START( wh )" + } + }, + { + "name": "STBIR_PROFILE_BUILD_CLEAR", + "value": null, + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2814, + "column": 1, + "source_line": "#define STBIR_PROFILE_BUILD_CLEAR( info )" + } + }, + { + "name": "STBIR_CEILF", + "value": "((float)ceil((float)(x)))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2821, + "column": 1, + "source_line": "#define STBIR_CEILF(x) ((float)ceil((float)(x)))" + } + }, + { + "name": "STBIR_FLOORF", + "value": "((float)floor((float)(x)))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2822, + "column": 1, + "source_line": "#define STBIR_FLOORF(x) ((float)floor((float)(x)))" + } + }, + { + "name": "STBIR_CEILF", + "value": "ceilf(x)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2824, + "column": 1, + "source_line": "#define STBIR_CEILF(x) ceilf(x)" + } + }, + { + "name": "STBIR_FLOORF", + "value": "floorf(x)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2825, + "column": 1, + "source_line": "#define STBIR_FLOORF(x) floorf(x)" + } + }, + { + "name": "STBIR_MEMCPY", + "value": "memcpy( dest, src, len )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2832, + "column": 1, + "source_line": "#define STBIR_MEMCPY( dest, src, len ) memcpy( dest, src, len )" + } + }, + { + "name": "STBIR__MERGE_RUNS_PIXEL_THRESHOLD", + "value": "16", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 3118, + "column": 1, + "source_line": "#define STBIR__MERGE_RUNS_PIXEL_THRESHOLD 16" + } + }, + { + "name": "STBIR_RENORM_TYPE", + "value": "float", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 3518, + "column": 1, + "source_line": "#define STBIR_RENORM_TYPE float" + } + }, + { + "name": "STBIR_RENORM_TYPE", + "value": "double", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 3520, + "column": 1, + "source_line": "#define STBIR_RENORM_TYPE double" + } + }, + { + "name": "STBIR_RENORM_TYPE", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 3694, + "column": 1, + "source_line": "#undef STBIR_RENORM_TYPE " + } + }, + { + "name": "STBIR_MOVE_1", + "value": "{ STBIR_NO_UNROLL(dest); ((stbir_uint32*)(dest))[0] = ((stbir_uint32*)(src))[0]; }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 3698, + "column": 3, + "source_line": " #define STBIR_MOVE_1( dest, src ) { STBIR_NO_UNROLL(dest); ((stbir_uint32*)(dest))[0] = ((stbir_uint32*)(src))[0]; }" + } + }, + { + "name": "STBIR_MOVE_2", + "value": "{ STBIR_NO_UNROLL(dest); ((stbir_uint64*)(dest))[0] = ((stbir_uint64*)(src))[0]; }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 3699, + "column": 3, + "source_line": " #define STBIR_MOVE_2( dest, src ) { STBIR_NO_UNROLL(dest); ((stbir_uint64*)(dest))[0] = ((stbir_uint64*)(src))[0]; }" + } + }, + { + "name": "STBIR_MOVE_4", + "value": "{ stbir__simdf t; STBIR_NO_UNROLL(dest); stbir__simdf_load( t, src ); stbir__simdf_store( dest, t ); }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 3701, + "column": 3, + "source_line": " #define STBIR_MOVE_4( dest, src ) { stbir__simdf t; STBIR_NO_UNROLL(dest); stbir__simdf_load( t, src ); stbir__simdf_store( dest, t ); }" + } + }, + { + "name": "STBIR_MOVE_4", + "value": "{ STBIR_NO_UNROLL(dest); ((stbir_uint64*)(dest))[0] = ((stbir_uint64*)(src))[0]; ((stbir_uint64*)(dest))[1] = ((stbir_uint64*)(src))[1]; }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 3703, + "column": 3, + "source_line": " #define STBIR_MOVE_4( dest, src ) { STBIR_NO_UNROLL(dest); ((stbir_uint64*)(dest))[0] = ((stbir_uint64*)(src))[0]; ((stbir_uint64*)(dest))[1] = ((stbir_uint64*)(src))[1]; }" + } + }, + { + "name": "STBIR_MOVE_1", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 3926, + "column": 3, + "source_line": " #undef STBIR_MOVE_1" + } + }, + { + "name": "STBIR_MOVE_2", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 3927, + "column": 3, + "source_line": " #undef STBIR_MOVE_2" + } + }, + { + "name": "STBIR_MOVE_4", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 3928, + "column": 3, + "source_line": " #undef STBIR_MOVE_4" + } + }, + { + "name": "stbir__coder_min_num", + "value": "1", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4076, + "column": 1, + "source_line": "#define stbir__coder_min_num 1" + } + }, + { + "name": "STB_IMAGE_RESIZE_DO_CODERS", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4077, + "column": 1, + "source_line": "#define STB_IMAGE_RESIZE_DO_CODERS" + } + }, + { + "name": "stbir__decode_suffix", + "value": "BGRA", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4080, + "column": 1, + "source_line": "#define stbir__decode_suffix BGRA" + } + }, + { + "name": "stbir__decode_swizzle", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4081, + "column": 1, + "source_line": "#define stbir__decode_swizzle" + } + }, + { + "name": "stbir__decode_order0", + "value": "2", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4082, + "column": 1, + "source_line": "#define stbir__decode_order0 2" + } + }, + { + "name": "stbir__decode_order1", + "value": "1", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4083, + "column": 1, + "source_line": "#define stbir__decode_order1 1" + } + }, + { + "name": "stbir__decode_order2", + "value": "0", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4084, + "column": 1, + "source_line": "#define stbir__decode_order2 0" + } + }, + { + "name": "stbir__decode_order3", + "value": "3", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4085, + "column": 1, + "source_line": "#define stbir__decode_order3 3" + } + }, + { + "name": "stbir__encode_order0", + "value": "2", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4086, + "column": 1, + "source_line": "#define stbir__encode_order0 2" + } + }, + { + "name": "stbir__encode_order1", + "value": "1", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4087, + "column": 1, + "source_line": "#define stbir__encode_order1 1" + } + }, + { + "name": "stbir__encode_order2", + "value": "0", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4088, + "column": 1, + "source_line": "#define stbir__encode_order2 0" + } + }, + { + "name": "stbir__encode_order3", + "value": "3", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4089, + "column": 1, + "source_line": "#define stbir__encode_order3 3" + } + }, + { + "name": "stbir__coder_min_num", + "value": "4", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4090, + "column": 1, + "source_line": "#define stbir__coder_min_num 4" + } + }, + { + "name": "STB_IMAGE_RESIZE_DO_CODERS", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4091, + "column": 1, + "source_line": "#define STB_IMAGE_RESIZE_DO_CODERS" + } + }, + { + "name": "stbir__decode_suffix", + "value": "ARGB", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4094, + "column": 1, + "source_line": "#define stbir__decode_suffix ARGB" + } + }, + { + "name": "stbir__decode_swizzle", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4095, + "column": 1, + "source_line": "#define stbir__decode_swizzle" + } + }, + { + "name": "stbir__decode_order0", + "value": "1", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4096, + "column": 1, + "source_line": "#define stbir__decode_order0 1" + } + }, + { + "name": "stbir__decode_order1", + "value": "2", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4097, + "column": 1, + "source_line": "#define stbir__decode_order1 2" + } + }, + { + "name": "stbir__decode_order2", + "value": "3", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4098, + "column": 1, + "source_line": "#define stbir__decode_order2 3" + } + }, + { + "name": "stbir__decode_order3", + "value": "0", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4099, + "column": 1, + "source_line": "#define stbir__decode_order3 0" + } + }, + { + "name": "stbir__encode_order0", + "value": "3", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4100, + "column": 1, + "source_line": "#define stbir__encode_order0 3" + } + }, + { + "name": "stbir__encode_order1", + "value": "0", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4101, + "column": 1, + "source_line": "#define stbir__encode_order1 0" + } + }, + { + "name": "stbir__encode_order2", + "value": "1", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4102, + "column": 1, + "source_line": "#define stbir__encode_order2 1" + } + }, + { + "name": "stbir__encode_order3", + "value": "2", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4103, + "column": 1, + "source_line": "#define stbir__encode_order3 2" + } + }, + { + "name": "stbir__coder_min_num", + "value": "4", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4104, + "column": 1, + "source_line": "#define stbir__coder_min_num 4" + } + }, + { + "name": "STB_IMAGE_RESIZE_DO_CODERS", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4105, + "column": 1, + "source_line": "#define STB_IMAGE_RESIZE_DO_CODERS" + } + }, + { + "name": "stbir__decode_suffix", + "value": "ABGR", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4108, + "column": 1, + "source_line": "#define stbir__decode_suffix ABGR" + } + }, + { + "name": "stbir__decode_swizzle", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4109, + "column": 1, + "source_line": "#define stbir__decode_swizzle" + } + }, + { + "name": "stbir__decode_order0", + "value": "3", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4110, + "column": 1, + "source_line": "#define stbir__decode_order0 3" + } + }, + { + "name": "stbir__decode_order1", + "value": "2", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4111, + "column": 1, + "source_line": "#define stbir__decode_order1 2" + } + }, + { + "name": "stbir__decode_order2", + "value": "1", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4112, + "column": 1, + "source_line": "#define stbir__decode_order2 1" + } + }, + { + "name": "stbir__decode_order3", + "value": "0", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4113, + "column": 1, + "source_line": "#define stbir__decode_order3 0" + } + }, + { + "name": "stbir__encode_order0", + "value": "3", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4114, + "column": 1, + "source_line": "#define stbir__encode_order0 3" + } + }, + { + "name": "stbir__encode_order1", + "value": "2", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4115, + "column": 1, + "source_line": "#define stbir__encode_order1 2" + } + }, + { + "name": "stbir__encode_order2", + "value": "1", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4116, + "column": 1, + "source_line": "#define stbir__encode_order2 1" + } + }, + { + "name": "stbir__encode_order3", + "value": "0", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4117, + "column": 1, + "source_line": "#define stbir__encode_order3 0" + } + }, + { + "name": "stbir__coder_min_num", + "value": "4", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4118, + "column": 1, + "source_line": "#define stbir__coder_min_num 4" + } + }, + { + "name": "STB_IMAGE_RESIZE_DO_CODERS", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4119, + "column": 1, + "source_line": "#define STB_IMAGE_RESIZE_DO_CODERS" + } + }, + { + "name": "stbir__decode_suffix", + "value": "AR", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4122, + "column": 1, + "source_line": "#define stbir__decode_suffix AR" + } + }, + { + "name": "stbir__decode_swizzle", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4123, + "column": 1, + "source_line": "#define stbir__decode_swizzle" + } + }, + { + "name": "stbir__decode_order0", + "value": "1", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4124, + "column": 1, + "source_line": "#define stbir__decode_order0 1" + } + }, + { + "name": "stbir__decode_order1", + "value": "0", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4125, + "column": 1, + "source_line": "#define stbir__decode_order1 0" + } + }, + { + "name": "stbir__decode_order2", + "value": "3", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4126, + "column": 1, + "source_line": "#define stbir__decode_order2 3" + } + }, + { + "name": "stbir__decode_order3", + "value": "2", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4127, + "column": 1, + "source_line": "#define stbir__decode_order3 2" + } + }, + { + "name": "stbir__encode_order0", + "value": "1", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4128, + "column": 1, + "source_line": "#define stbir__encode_order0 1" + } + }, + { + "name": "stbir__encode_order1", + "value": "0", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4129, + "column": 1, + "source_line": "#define stbir__encode_order1 0" + } + }, + { + "name": "stbir__encode_order2", + "value": "3", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4130, + "column": 1, + "source_line": "#define stbir__encode_order2 3" + } + }, + { + "name": "stbir__encode_order3", + "value": "2", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4131, + "column": 1, + "source_line": "#define stbir__encode_order3 2" + } + }, + { + "name": "stbir__coder_min_num", + "value": "2", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4132, + "column": 1, + "source_line": "#define stbir__coder_min_num 2" + } + }, + { + "name": "STB_IMAGE_RESIZE_DO_CODERS", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4133, + "column": 1, + "source_line": "#define STB_IMAGE_RESIZE_DO_CODERS" + } + }, + { + "name": "stbir__1_coeff_only", + "value": "stbir__simdf tot,c; STBIR_SIMD_NO_UNROLL(decode); stbir__simdf_load1( c, hc ); stbir__simdf_mult1_mem( tot, c, decode );", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4710, + "column": 1, + "source_line": "#define stbir__1_coeff_only() \\" + } + }, + { + "name": "stbir__2_coeff_only", + "value": "stbir__simdf tot,c,d; STBIR_SIMD_NO_UNROLL(decode); stbir__simdf_load2z( c, hc ); stbir__simdf_load2( d, decode ); stbir__simdf_mult( tot, c, d ); stbir__simdf_0123to1230( c, tot ); stbir__simdf_add1( tot, tot, c );", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4716, + "column": 1, + "source_line": "#define stbir__2_coeff_only() \\" + } + }, + { + "name": "stbir__3_coeff_only", + "value": "stbir__simdf tot,c,t; STBIR_SIMD_NO_UNROLL(decode); stbir__simdf_load( c, hc ); stbir__simdf_mult_mem( tot, c, decode ); stbir__simdf_0123to1230( c, tot ); stbir__simdf_0123to2301( t, tot ); stbir__simdf_add1( tot, tot, c ); stbir__simdf_add1( tot, tot, t );", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4725, + "column": 1, + "source_line": "#define stbir__3_coeff_only() \\" + } + }, + { + "name": "stbir__store_output_tiny", + "value": "stbir__simdf_store1( output, tot ); horizontal_coefficients += coefficient_width; ++horizontal_contributors; output += 1;", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4735, + "column": 1, + "source_line": "#define stbir__store_output_tiny() \\" + } + }, + { + "name": "stbir__4_coeff_start", + "value": "stbir__simdf tot,c; STBIR_SIMD_NO_UNROLL(decode); stbir__simdf_load( c, hc ); stbir__simdf_mult_mem( tot, c, decode );", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4741, + "column": 1, + "source_line": "#define stbir__4_coeff_start() \\" + } + }, + { + "name": "stbir__4_coeff_continue_from_4", + "value": "STBIR_SIMD_NO_UNROLL(decode); stbir__simdf_load( c, hc + (ofs) ); stbir__simdf_madd_mem( tot, tot, c, decode+(ofs) );", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4747, + "column": 1, + "source_line": "#define stbir__4_coeff_continue_from_4( ofs ) \\" + } + }, + { + "name": "stbir__1_coeff_remnant", + "value": "{ stbir__simdf d; stbir__simdf_load1z( c, hc + (ofs) ); stbir__simdf_load1( d, decode + (ofs) ); stbir__simdf_madd( tot, tot, d, c ); }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4752, + "column": 1, + "source_line": "#define stbir__1_coeff_remnant( ofs ) \\" + } + }, + { + "name": "stbir__2_coeff_remnant", + "value": "{ stbir__simdf d; stbir__simdf_load2z( c, hc+(ofs) ); stbir__simdf_load2( d, decode+(ofs) ); stbir__simdf_madd( tot, tot, d, c ); }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4758, + "column": 1, + "source_line": "#define stbir__2_coeff_remnant( ofs ) \\" + } + }, + { + "name": "stbir__3_coeff_setup", + "value": "stbir__simdf mask; stbir__simdf_load( mask, STBIR_mask + 3 );", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4764, + "column": 1, + "source_line": "#define stbir__3_coeff_setup() \\" + } + }, + { + "name": "stbir__3_coeff_remnant", + "value": "stbir__simdf_load( c, hc+(ofs) ); stbir__simdf_and( c, c, mask ); stbir__simdf_madd_mem( tot, tot, c, decode+(ofs) );", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4768, + "column": 1, + "source_line": "#define stbir__3_coeff_remnant( ofs ) \\" + } + }, + { + "name": "stbir__store_output", + "value": "stbir__simdf_0123to2301( c, tot ); stbir__simdf_add( tot, tot, c ); stbir__simdf_0123to1230( c, tot ); stbir__simdf_add1( tot, tot, c ); stbir__simdf_store1( output, tot ); horizontal_coefficients += coefficient_width; ++horizontal_contributors; output += 1;", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4773, + "column": 1, + "source_line": "#define stbir__store_output() \\" + } + }, + { + "name": "stbir__1_coeff_only", + "value": "float tot; tot = decode[0]*hc[0];", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4785, + "column": 1, + "source_line": "#define stbir__1_coeff_only() \\" + } + }, + { + "name": "stbir__2_coeff_only", + "value": "float tot; tot = decode[0] * hc[0]; tot += decode[1] * hc[1];", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4789, + "column": 1, + "source_line": "#define stbir__2_coeff_only() \\" + } + }, + { + "name": "stbir__3_coeff_only", + "value": "float tot; tot = decode[0] * hc[0]; tot += decode[1] * hc[1]; tot += decode[2] * hc[2];", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4794, + "column": 1, + "source_line": "#define stbir__3_coeff_only() \\" + } + }, + { + "name": "stbir__store_output_tiny", + "value": "output[0] = tot; horizontal_coefficients += coefficient_width; ++horizontal_contributors; output += 1;", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4800, + "column": 1, + "source_line": "#define stbir__store_output_tiny() \\" + } + }, + { + "name": "stbir__4_coeff_start", + "value": "float tot0,tot1,tot2,tot3; tot0 = decode[0] * hc[0]; tot1 = decode[1] * hc[1]; tot2 = decode[2] * hc[2]; tot3 = decode[3] * hc[3];", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4806, + "column": 1, + "source_line": "#define stbir__4_coeff_start() \\" + } + }, + { + "name": "stbir__4_coeff_continue_from_4", + "value": "tot0 += decode[0+(ofs)] * hc[0+(ofs)]; tot1 += decode[1+(ofs)] * hc[1+(ofs)]; tot2 += decode[2+(ofs)] * hc[2+(ofs)]; tot3 += decode[3+(ofs)] * hc[3+(ofs)];", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4813, + "column": 1, + "source_line": "#define stbir__4_coeff_continue_from_4( ofs ) \\" + } + }, + { + "name": "stbir__1_coeff_remnant", + "value": "tot0 += decode[0+(ofs)] * hc[0+(ofs)];", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4819, + "column": 1, + "source_line": "#define stbir__1_coeff_remnant( ofs ) \\" + } + }, + { + "name": "stbir__2_coeff_remnant", + "value": "tot0 += decode[0+(ofs)] * hc[0+(ofs)]; tot1 += decode[1+(ofs)] * hc[1+(ofs)];", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4822, + "column": 1, + "source_line": "#define stbir__2_coeff_remnant( ofs ) \\" + } + }, + { + "name": "stbir__3_coeff_remnant", + "value": "tot0 += decode[0+(ofs)] * hc[0+(ofs)]; tot1 += decode[1+(ofs)] * hc[1+(ofs)]; tot2 += decode[2+(ofs)] * hc[2+(ofs)];", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4826, + "column": 1, + "source_line": "#define stbir__3_coeff_remnant( ofs ) \\" + } + }, + { + "name": "stbir__store_output", + "value": "output[0] = (tot0+tot2)+(tot1+tot3); horizontal_coefficients += coefficient_width; ++horizontal_contributors; output += 1;", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4831, + "column": 1, + "source_line": "#define stbir__store_output() \\" + } + }, + { + "name": "STBIR__horizontal_channels", + "value": "1", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4839, + "column": 1, + "source_line": "#define STBIR__horizontal_channels 1" + } + }, + { + "name": "STB_IMAGE_RESIZE_DO_HORIZONTALS", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4840, + "column": 1, + "source_line": "#define STB_IMAGE_RESIZE_DO_HORIZONTALS" + } + }, + { + "name": "stbir__1_coeff_only", + "value": "stbir__simdf tot,c,d; STBIR_SIMD_NO_UNROLL(decode); stbir__simdf_load1z( c, hc ); stbir__simdf_0123to0011( c, c ); stbir__simdf_load2( d, decode ); stbir__simdf_mult( tot, d, c );", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4849, + "column": 1, + "source_line": "#define stbir__1_coeff_only() \\" + } + }, + { + "name": "stbir__2_coeff_only", + "value": "stbir__simdf tot,c; STBIR_SIMD_NO_UNROLL(decode); stbir__simdf_load2( c, hc ); stbir__simdf_0123to0011( c, c ); stbir__simdf_mult_mem( tot, c, decode );", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4857, + "column": 1, + "source_line": "#define stbir__2_coeff_only() \\" + } + }, + { + "name": "stbir__3_coeff_only", + "value": "stbir__simdf tot,c,cs,d; STBIR_SIMD_NO_UNROLL(decode); stbir__simdf_load( cs, hc ); stbir__simdf_0123to0011( c, cs ); stbir__simdf_mult_mem( tot, c, decode ); stbir__simdf_0123to2222( c, cs ); stbir__simdf_load2z( d, decode+4 ); stbir__simdf_madd( tot, tot, d, c );", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4864, + "column": 1, + "source_line": "#define stbir__3_coeff_only() \\" + } + }, + { + "name": "stbir__store_output_tiny", + "value": "stbir__simdf_0123to2301( c, tot ); stbir__simdf_add( tot, tot, c ); stbir__simdf_store2( output, tot ); horizontal_coefficients += coefficient_width; ++horizontal_contributors; output += 2;", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4874, + "column": 1, + "source_line": "#define stbir__store_output_tiny() \\" + } + }, + { + "name": "stbir__4_coeff_start", + "value": "stbir__simdf8 tot0,c,cs; STBIR_SIMD_NO_UNROLL(decode); stbir__simdf8_load4b( cs, hc ); stbir__simdf8_0123to00112233( c, cs ); stbir__simdf8_mult_mem( tot0, c, decode );", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4884, + "column": 1, + "source_line": "#define stbir__4_coeff_start() \\" + } + }, + { + "name": "stbir__4_coeff_continue_from_4", + "value": "STBIR_SIMD_NO_UNROLL(decode); stbir__simdf8_load4b( cs, hc + (ofs) ); stbir__simdf8_0123to00112233( c, cs ); stbir__simdf8_madd_mem( tot0, tot0, c, decode+(ofs)*2 );", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4891, + "column": 1, + "source_line": "#define stbir__4_coeff_continue_from_4( ofs ) \\" + } + }, + { + "name": "stbir__1_coeff_remnant", + "value": "{ stbir__simdf t,d; stbir__simdf_load1z( t, hc + (ofs) ); stbir__simdf_load2( d, decode + (ofs) * 2 ); stbir__simdf_0123to0011( t, t ); stbir__simdf_mult( t, t, d ); stbir__simdf8_add4( tot0, tot0, t ); }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4897, + "column": 1, + "source_line": "#define stbir__1_coeff_remnant( ofs ) \\" + } + }, + { + "name": "stbir__2_coeff_remnant", + "value": "{ stbir__simdf t; stbir__simdf_load2( t, hc + (ofs) ); stbir__simdf_0123to0011( t, t ); stbir__simdf_mult_mem( t, t, decode+(ofs)*2 ); stbir__simdf8_add4( tot0, tot0, t ); }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4905, + "column": 1, + "source_line": "#define stbir__2_coeff_remnant( ofs ) \\" + } + }, + { + "name": "stbir__3_coeff_remnant", + "value": "{ stbir__simdf8 d; stbir__simdf8_load4b( cs, hc + (ofs) ); stbir__simdf8_0123to00112233( c, cs ); stbir__simdf8_load6z( d, decode+(ofs)*2 ); stbir__simdf8_madd( tot0, tot0, c, d ); }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4912, + "column": 1, + "source_line": "#define stbir__3_coeff_remnant( ofs ) \\" + } + }, + { + "name": "stbir__store_output", + "value": "{ stbir__simdf t,d; stbir__simdf8_add4halves( t, stbir__if_simdf8_cast_to_simdf4(tot0), tot0 ); stbir__simdf_0123to2301( d, t ); stbir__simdf_add( t, t, d ); stbir__simdf_store2( output, t ); horizontal_coefficients += coefficient_width; ++horizontal_contributors; output += 2; }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4919, + "column": 1, + "source_line": "#define stbir__store_output() \\" + } + }, + { + "name": "stbir__4_coeff_start", + "value": "stbir__simdf tot0,tot1,c,cs; STBIR_SIMD_NO_UNROLL(decode); stbir__simdf_load( cs, hc ); stbir__simdf_0123to0011( c, cs ); stbir__simdf_mult_mem( tot0, c, decode ); stbir__simdf_0123to2233( c, cs ); stbir__simdf_mult_mem( tot1, c, decode+4 );", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4931, + "column": 1, + "source_line": "#define stbir__4_coeff_start() \\" + } + }, + { + "name": "stbir__4_coeff_continue_from_4", + "value": "STBIR_SIMD_NO_UNROLL(decode); stbir__simdf_load( cs, hc + (ofs) ); stbir__simdf_0123to0011( c, cs ); stbir__simdf_madd_mem( tot0, tot0, c, decode+(ofs)*2 ); stbir__simdf_0123to2233( c, cs ); stbir__simdf_madd_mem( tot1, tot1, c, decode+(ofs)*2+4 );", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4940, + "column": 1, + "source_line": "#define stbir__4_coeff_continue_from_4( ofs ) \\" + } + }, + { + "name": "stbir__1_coeff_remnant", + "value": "{ stbir__simdf d; stbir__simdf_load1z( cs, hc + (ofs) ); stbir__simdf_0123to0011( c, cs ); stbir__simdf_load2( d, decode + (ofs) * 2 ); stbir__simdf_madd( tot0, tot0, d, c ); }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4948, + "column": 1, + "source_line": "#define stbir__1_coeff_remnant( ofs ) \\" + } + }, + { + "name": "stbir__2_coeff_remnant", + "value": "stbir__simdf_load2( cs, hc + (ofs) ); stbir__simdf_0123to0011( c, cs ); stbir__simdf_madd_mem( tot0, tot0, c, decode+(ofs)*2 );", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4955, + "column": 1, + "source_line": "#define stbir__2_coeff_remnant( ofs ) \\" + } + }, + { + "name": "stbir__3_coeff_remnant", + "value": "{ stbir__simdf d; stbir__simdf_load( cs, hc + (ofs) ); stbir__simdf_0123to0011( c, cs ); stbir__simdf_madd_mem( tot0, tot0, c, decode+(ofs)*2 ); stbir__simdf_0123to2222( c, cs ); stbir__simdf_load2z( d, decode + (ofs) * 2 + 4 ); stbir__simdf_madd( tot1, tot1, d, c ); }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4960, + "column": 1, + "source_line": "#define stbir__3_coeff_remnant( ofs ) \\" + } + }, + { + "name": "stbir__store_output", + "value": "stbir__simdf_add( tot0, tot0, tot1 ); stbir__simdf_0123to2301( c, tot0 ); stbir__simdf_add( tot0, tot0, c ); stbir__simdf_store2( output, tot0 ); horizontal_coefficients += coefficient_width; ++horizontal_contributors; output += 2;", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4969, + "column": 1, + "source_line": "#define stbir__store_output() \\" + } + }, + { + "name": "stbir__1_coeff_only", + "value": "float tota,totb,c; c = hc[0]; tota = decode[0]*c; totb = decode[1]*c;", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4982, + "column": 1, + "source_line": "#define stbir__1_coeff_only() \\" + } + }, + { + "name": "stbir__2_coeff_only", + "value": "float tota,totb,c; c = hc[0]; tota = decode[0]*c; totb = decode[1]*c; c = hc[1]; tota += decode[2]*c; totb += decode[3]*c;", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4988, + "column": 1, + "source_line": "#define stbir__2_coeff_only() \\" + } + }, + { + "name": "stbir__3_coeff_only", + "value": "float tota,totb,c; c = hc[0]; tota = decode[0]*c; totb = decode[1]*c; c = hc[2]; tota += decode[4]*c; totb += decode[5]*c; c = hc[1]; tota += decode[2]*c; totb += decode[3]*c;", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4998, + "column": 1, + "source_line": "#define stbir__3_coeff_only() \\" + } + }, + { + "name": "stbir__store_output_tiny", + "value": "output[0] = tota; output[1] = totb; horizontal_coefficients += coefficient_width; ++horizontal_contributors; output += 2;", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5010, + "column": 1, + "source_line": "#define stbir__store_output_tiny() \\" + } + }, + { + "name": "stbir__4_coeff_start", + "value": "float tota0,tota1,tota2,tota3,totb0,totb1,totb2,totb3,c; c = hc[0]; tota0 = decode[0]*c; totb0 = decode[1]*c; c = hc[1]; tota1 = decode[2]*c; totb1 = decode[3]*c; c = hc[2]; tota2 = decode[4]*c; totb2 = decode[5]*c; c = hc[3]; tota3 = decode[6]*c; totb3 = decode[7]*c;", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5017, + "column": 1, + "source_line": "#define stbir__4_coeff_start() \\" + } + }, + { + "name": "stbir__4_coeff_continue_from_4", + "value": "c = hc[0+(ofs)]; tota0 += decode[0+(ofs)*2]*c; totb0 += decode[1+(ofs)*2]*c; c = hc[1+(ofs)]; tota1 += decode[2+(ofs)*2]*c; totb1 += decode[3+(ofs)*2]*c; c = hc[2+(ofs)]; tota2 += decode[4+(ofs)*2]*c; totb2 += decode[5+(ofs)*2]*c; c = hc[3+(ofs)]; tota3 += decode[6+(ofs)*2]*c; totb3 += decode[7+(ofs)*2]*c;", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5032, + "column": 1, + "source_line": "#define stbir__4_coeff_continue_from_4( ofs ) \\" + } + }, + { + "name": "stbir__1_coeff_remnant", + "value": "c = hc[0+(ofs)]; tota0 += decode[0+(ofs)*2] * c; totb0 += decode[1+(ofs)*2] * c;", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5046, + "column": 1, + "source_line": "#define stbir__1_coeff_remnant( ofs ) \\" + } + }, + { + "name": "stbir__2_coeff_remnant", + "value": "c = hc[0+(ofs)]; tota0 += decode[0+(ofs)*2] * c; totb0 += decode[1+(ofs)*2] * c; c = hc[1+(ofs)]; tota1 += decode[2+(ofs)*2] * c; totb1 += decode[3+(ofs)*2] * c;", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5051, + "column": 1, + "source_line": "#define stbir__2_coeff_remnant( ofs ) \\" + } + }, + { + "name": "stbir__3_coeff_remnant", + "value": "c = hc[0+(ofs)]; tota0 += decode[0+(ofs)*2] * c; totb0 += decode[1+(ofs)*2] * c; c = hc[1+(ofs)]; tota1 += decode[2+(ofs)*2] * c; totb1 += decode[3+(ofs)*2] * c; c = hc[2+(ofs)]; tota2 += decode[4+(ofs)*2] * c; totb2 += decode[5+(ofs)*2] * c;", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5059, + "column": 1, + "source_line": "#define stbir__3_coeff_remnant( ofs ) \\" + } + }, + { + "name": "stbir__store_output", + "value": "output[0] = (tota0+tota2)+(tota1+tota3); output[1] = (totb0+totb2)+(totb1+totb3); horizontal_coefficients += coefficient_width; ++horizontal_contributors; output += 2;", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5070, + "column": 1, + "source_line": "#define stbir__store_output() \\" + } + }, + { + "name": "STBIR__horizontal_channels", + "value": "2", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5079, + "column": 1, + "source_line": "#define STBIR__horizontal_channels 2" + } + }, + { + "name": "STB_IMAGE_RESIZE_DO_HORIZONTALS", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5080, + "column": 1, + "source_line": "#define STB_IMAGE_RESIZE_DO_HORIZONTALS" + } + }, + { + "name": "stbir__1_coeff_only", + "value": "stbir__simdf tot,c,d; STBIR_SIMD_NO_UNROLL(decode); stbir__simdf_load1z( c, hc ); stbir__simdf_0123to0001( c, c ); stbir__simdf_load( d, decode ); stbir__simdf_mult( tot, d, c );", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5089, + "column": 1, + "source_line": "#define stbir__1_coeff_only() \\" + } + }, + { + "name": "stbir__2_coeff_only", + "value": "stbir__simdf tot,c,cs,d; STBIR_SIMD_NO_UNROLL(decode); stbir__simdf_load2( cs, hc ); stbir__simdf_0123to0000( c, cs ); stbir__simdf_load( d, decode ); stbir__simdf_mult( tot, d, c ); stbir__simdf_0123to1111( c, cs ); stbir__simdf_load( d, decode+3 ); stbir__simdf_madd( tot, tot, d, c );", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5097, + "column": 1, + "source_line": "#define stbir__2_coeff_only() \\" + } + }, + { + "name": "stbir__3_coeff_only", + "value": "stbir__simdf tot,c,d,cs; STBIR_SIMD_NO_UNROLL(decode); stbir__simdf_load( cs, hc ); stbir__simdf_0123to0000( c, cs ); stbir__simdf_load( d, decode ); stbir__simdf_mult( tot, d, c ); stbir__simdf_0123to1111( c, cs ); stbir__simdf_load( d, decode+3 ); stbir__simdf_madd( tot, tot, d, c ); stbir__simdf_0123to2222( c, cs ); stbir__simdf_load( d, decode+6 ); stbir__simdf_madd( tot, tot, d, c );", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5108, + "column": 1, + "source_line": "#define stbir__3_coeff_only() \\" + } + }, + { + "name": "stbir__store_output_tiny", + "value": "stbir__simdf_store2( output, tot ); stbir__simdf_0123to2301( tot, tot ); stbir__simdf_store1( output+2, tot ); horizontal_coefficients += coefficient_width; ++horizontal_contributors; output += 3;", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5122, + "column": 1, + "source_line": "#define stbir__store_output_tiny() \\" + } + }, + { + "name": "stbir__4_coeff_start", + "value": "stbir__simdf8 tot0,tot1,c,cs; stbir__simdf t; STBIR_SIMD_NO_UNROLL(decode); stbir__simdf8_load4b( cs, hc ); stbir__simdf8_0123to00001111( c, cs ); stbir__simdf8_mult_mem( tot0, c, decode - 1 ); stbir__simdf8_0123to22223333( c, cs ); stbir__simdf8_mult_mem( tot1, c, decode+6 - 1 );", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5133, + "column": 1, + "source_line": "#define stbir__4_coeff_start() \\" + } + }, + { + "name": "stbir__4_coeff_continue_from_4", + "value": "STBIR_SIMD_NO_UNROLL(decode); stbir__simdf8_load4b( cs, hc + (ofs) ); stbir__simdf8_0123to00001111( c, cs ); stbir__simdf8_madd_mem( tot0, tot0, c, decode+(ofs)*3 - 1 ); stbir__simdf8_0123to22223333( c, cs ); stbir__simdf8_madd_mem( tot1, tot1, c, decode+(ofs)*3 + 6 - 1 );", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5142, + "column": 1, + "source_line": "#define stbir__4_coeff_continue_from_4( ofs ) \\" + } + }, + { + "name": "stbir__1_coeff_remnant", + "value": "STBIR_SIMD_NO_UNROLL(decode); stbir__simdf_load1rep4( t, hc + (ofs) ); stbir__simdf8_madd_mem4( tot0, tot0, t, decode+(ofs)*3 - 1 );", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5150, + "column": 1, + "source_line": "#define stbir__1_coeff_remnant( ofs ) \\" + } + }, + { + "name": "stbir__2_coeff_remnant", + "value": "STBIR_SIMD_NO_UNROLL(decode); stbir__simdf8_load4b( cs, hc + (ofs) - 2 ); stbir__simdf8_0123to22223333( c, cs ); stbir__simdf8_madd_mem( tot0, tot0, c, decode+(ofs)*3 - 1 );", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5155, + "column": 1, + "source_line": "#define stbir__2_coeff_remnant( ofs ) \\" + } + }, + { + "name": "stbir__3_coeff_remnant", + "value": "STBIR_SIMD_NO_UNROLL(decode); stbir__simdf8_load4b( cs, hc + (ofs) ); stbir__simdf8_0123to00001111( c, cs ); stbir__simdf8_madd_mem( tot0, tot0, c, decode+(ofs)*3 - 1 ); stbir__simdf8_0123to2222( t, cs ); stbir__simdf8_madd_mem4( tot1, tot1, t, decode+(ofs)*3 + 6 - 1 );", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5161, + "column": 2, + "source_line": " #define stbir__3_coeff_remnant( ofs ) \\" + } + }, + { + "name": "stbir__store_output", + "value": "stbir__simdf8_add( tot0, tot0, tot1 ); stbir__simdf_0123to1230( t, stbir__if_simdf8_cast_to_simdf4( tot0 ) ); stbir__simdf8_add4halves( t, t, tot0 ); horizontal_coefficients += coefficient_width; ++horizontal_contributors; output += 3; if ( output < output_end ) { stbir__simdf_store( output-3, t ); continue; } { stbir__simdf tt; stbir__simdf_0123to2301( tt, t ); stbir__simdf_store2( output-3, t ); stbir__simdf_store1( output+2-3, tt ); } break;", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5169, + "column": 1, + "source_line": "#define stbir__store_output() \\" + } + }, + { + "name": "stbir__4_coeff_start", + "value": "stbir__simdf tot0,tot1,tot2,c,cs; STBIR_SIMD_NO_UNROLL(decode); stbir__simdf_load( cs, hc ); stbir__simdf_0123to0001( c, cs ); stbir__simdf_mult_mem( tot0, c, decode ); stbir__simdf_0123to1122( c, cs ); stbir__simdf_mult_mem( tot1, c, decode+4 ); stbir__simdf_0123to2333( c, cs ); stbir__simdf_mult_mem( tot2, c, decode+8 );", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5189, + "column": 1, + "source_line": "#define stbir__4_coeff_start() \\" + } + }, + { + "name": "stbir__4_coeff_continue_from_4", + "value": "STBIR_SIMD_NO_UNROLL(decode); stbir__simdf_load( cs, hc + (ofs) ); stbir__simdf_0123to0001( c, cs ); stbir__simdf_madd_mem( tot0, tot0, c, decode+(ofs)*3 ); stbir__simdf_0123to1122( c, cs ); stbir__simdf_madd_mem( tot1, tot1, c, decode+(ofs)*3+4 ); stbir__simdf_0123to2333( c, cs ); stbir__simdf_madd_mem( tot2, tot2, c, decode+(ofs)*3+8 );", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5200, + "column": 1, + "source_line": "#define stbir__4_coeff_continue_from_4( ofs ) \\" + } + }, + { + "name": "stbir__1_coeff_remnant", + "value": "STBIR_SIMD_NO_UNROLL(decode); stbir__simdf_load1z( c, hc + (ofs) ); stbir__simdf_0123to0001( c, c ); stbir__simdf_madd_mem( tot0, tot0, c, decode+(ofs)*3 );", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5210, + "column": 1, + "source_line": "#define stbir__1_coeff_remnant( ofs ) \\" + } + }, + { + "name": "stbir__2_coeff_remnant", + "value": "{ stbir__simdf d; STBIR_SIMD_NO_UNROLL(decode); stbir__simdf_load2z( cs, hc + (ofs) ); stbir__simdf_0123to0001( c, cs ); stbir__simdf_madd_mem( tot0, tot0, c, decode+(ofs)*3 ); stbir__simdf_0123to1122( c, cs ); stbir__simdf_load2z( d, decode+(ofs)*3+4 ); stbir__simdf_madd( tot1, tot1, c, d ); }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5216, + "column": 1, + "source_line": "#define stbir__2_coeff_remnant( ofs ) \\" + } + }, + { + "name": "stbir__3_coeff_remnant", + "value": "{ stbir__simdf d; STBIR_SIMD_NO_UNROLL(decode); stbir__simdf_load( cs, hc + (ofs) ); stbir__simdf_0123to0001( c, cs ); stbir__simdf_madd_mem( tot0, tot0, c, decode+(ofs)*3 ); stbir__simdf_0123to1122( c, cs ); stbir__simdf_madd_mem( tot1, tot1, c, decode+(ofs)*3+4 ); stbir__simdf_0123to2222( c, cs ); stbir__simdf_load1z( d, decode+(ofs)*3+8 ); stbir__simdf_madd( tot2, tot2, c, d ); }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5226, + "column": 1, + "source_line": "#define stbir__3_coeff_remnant( ofs ) \\" + } + }, + { + "name": "stbir__store_output", + "value": "stbir__simdf_0123ABCDto3ABx( c, tot0, tot1 ); stbir__simdf_0123ABCDto23Ax( cs, tot1, tot2 ); stbir__simdf_0123to1230( tot2, tot2 ); stbir__simdf_add( tot0, tot0, cs ); stbir__simdf_add( c, c, tot2 ); stbir__simdf_add( tot0, tot0, c ); horizontal_coefficients += coefficient_width; ++horizontal_contributors; output += 3; if ( output < output_end ) { stbir__simdf_store( output-3, tot0 ); continue; } stbir__simdf_0123to2301( tot1, tot0 ); stbir__simdf_store2( output-3, tot0 ); stbir__simdf_store1( output+2-3, tot1 ); break;", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5238, + "column": 1, + "source_line": "#define stbir__store_output() \\" + } + }, + { + "name": "stbir__1_coeff_only", + "value": "float tot0, tot1, tot2, c; c = hc[0]; tot0 = decode[0]*c; tot1 = decode[1]*c; tot2 = decode[2]*c;", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5262, + "column": 1, + "source_line": "#define stbir__1_coeff_only() \\" + } + }, + { + "name": "stbir__2_coeff_only", + "value": "float tot0, tot1, tot2, c; c = hc[0]; tot0 = decode[0]*c; tot1 = decode[1]*c; tot2 = decode[2]*c; c = hc[1]; tot0 += decode[3]*c; tot1 += decode[4]*c; tot2 += decode[5]*c;", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5269, + "column": 1, + "source_line": "#define stbir__2_coeff_only() \\" + } + }, + { + "name": "stbir__3_coeff_only", + "value": "float tot0, tot1, tot2, c; c = hc[0]; tot0 = decode[0]*c; tot1 = decode[1]*c; tot2 = decode[2]*c; c = hc[1]; tot0 += decode[3]*c; tot1 += decode[4]*c; tot2 += decode[5]*c; c = hc[2]; tot0 += decode[6]*c; tot1 += decode[7]*c; tot2 += decode[8]*c;", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5280, + "column": 1, + "source_line": "#define stbir__3_coeff_only() \\" + } + }, + { + "name": "stbir__store_output_tiny", + "value": "output[0] = tot0; output[1] = tot1; output[2] = tot2; horizontal_coefficients += coefficient_width; ++horizontal_contributors; output += 3;", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5295, + "column": 1, + "source_line": "#define stbir__store_output_tiny() \\" + } + }, + { + "name": "stbir__4_coeff_start", + "value": "float tota0,tota1,tota2,totb0,totb1,totb2,totc0,totc1,totc2,totd0,totd1,totd2,c; c = hc[0]; tota0 = decode[0]*c; tota1 = decode[1]*c; tota2 = decode[2]*c; c = hc[1]; totb0 = decode[3]*c; totb1 = decode[4]*c; totb2 = decode[5]*c; c = hc[2]; totc0 = decode[6]*c; totc1 = decode[7]*c; totc2 = decode[8]*c; c = hc[3]; totd0 = decode[9]*c; totd1 = decode[10]*c; totd2 = decode[11]*c;", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5303, + "column": 1, + "source_line": "#define stbir__4_coeff_start() \\" + } + }, + { + "name": "stbir__4_coeff_continue_from_4", + "value": "c = hc[0+(ofs)]; tota0 += decode[0+(ofs)*3]*c; tota1 += decode[1+(ofs)*3]*c; tota2 += decode[2+(ofs)*3]*c; c = hc[1+(ofs)]; totb0 += decode[3+(ofs)*3]*c; totb1 += decode[4+(ofs)*3]*c; totb2 += decode[5+(ofs)*3]*c; c = hc[2+(ofs)]; totc0 += decode[6+(ofs)*3]*c; totc1 += decode[7+(ofs)*3]*c; totc2 += decode[8+(ofs)*3]*c; c = hc[3+(ofs)]; totd0 += decode[9+(ofs)*3]*c; totd1 += decode[10+(ofs)*3]*c; totd2 += decode[11+(ofs)*3]*c;", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5322, + "column": 1, + "source_line": "#define stbir__4_coeff_continue_from_4( ofs ) \\" + } + }, + { + "name": "stbir__1_coeff_remnant", + "value": "c = hc[0+(ofs)]; tota0 += decode[0+(ofs)*3]*c; tota1 += decode[1+(ofs)*3]*c; tota2 += decode[2+(ofs)*3]*c;", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5340, + "column": 1, + "source_line": "#define stbir__1_coeff_remnant( ofs ) \\" + } + }, + { + "name": "stbir__2_coeff_remnant", + "value": "c = hc[0+(ofs)]; tota0 += decode[0+(ofs)*3]*c; tota1 += decode[1+(ofs)*3]*c; tota2 += decode[2+(ofs)*3]*c; c = hc[1+(ofs)]; totb0 += decode[3+(ofs)*3]*c; totb1 += decode[4+(ofs)*3]*c; totb2 += decode[5+(ofs)*3]*c;", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5346, + "column": 1, + "source_line": "#define stbir__2_coeff_remnant( ofs ) \\" + } + }, + { + "name": "stbir__3_coeff_remnant", + "value": "c = hc[0+(ofs)]; tota0 += decode[0+(ofs)*3]*c; tota1 += decode[1+(ofs)*3]*c; tota2 += decode[2+(ofs)*3]*c; c = hc[1+(ofs)]; totb0 += decode[3+(ofs)*3]*c; totb1 += decode[4+(ofs)*3]*c; totb2 += decode[5+(ofs)*3]*c; c = hc[2+(ofs)]; totc0 += decode[6+(ofs)*3]*c; totc1 += decode[7+(ofs)*3]*c; totc2 += decode[8+(ofs)*3]*c;", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5356, + "column": 1, + "source_line": "#define stbir__3_coeff_remnant( ofs ) \\" + } + }, + { + "name": "stbir__store_output", + "value": "output[0] = (tota0+totc0)+(totb0+totd0); output[1] = (tota1+totc1)+(totb1+totd1); output[2] = (tota2+totc2)+(totb2+totd2); horizontal_coefficients += coefficient_width; ++horizontal_contributors; output += 3;", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5370, + "column": 1, + "source_line": "#define stbir__store_output() \\" + } + }, + { + "name": "STBIR__horizontal_channels", + "value": "3", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5380, + "column": 1, + "source_line": "#define STBIR__horizontal_channels 3" + } + }, + { + "name": "STB_IMAGE_RESIZE_DO_HORIZONTALS", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5381, + "column": 1, + "source_line": "#define STB_IMAGE_RESIZE_DO_HORIZONTALS" + } + }, + { + "name": "stbir__1_coeff_only", + "value": "stbir__simdf tot,c; STBIR_SIMD_NO_UNROLL(decode); stbir__simdf_load1( c, hc ); stbir__simdf_0123to0000( c, c ); stbir__simdf_mult_mem( tot, c, decode );", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5389, + "column": 1, + "source_line": "#define stbir__1_coeff_only() \\" + } + }, + { + "name": "stbir__2_coeff_only", + "value": "stbir__simdf tot,c,cs; STBIR_SIMD_NO_UNROLL(decode); stbir__simdf_load2( cs, hc ); stbir__simdf_0123to0000( c, cs ); stbir__simdf_mult_mem( tot, c, decode ); stbir__simdf_0123to1111( c, cs ); stbir__simdf_madd_mem( tot, tot, c, decode+4 );", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5396, + "column": 1, + "source_line": "#define stbir__2_coeff_only() \\" + } + }, + { + "name": "stbir__3_coeff_only", + "value": "stbir__simdf tot,c,cs; STBIR_SIMD_NO_UNROLL(decode); stbir__simdf_load( cs, hc ); stbir__simdf_0123to0000( c, cs ); stbir__simdf_mult_mem( tot, c, decode ); stbir__simdf_0123to1111( c, cs ); stbir__simdf_madd_mem( tot, tot, c, decode+4 ); stbir__simdf_0123to2222( c, cs ); stbir__simdf_madd_mem( tot, tot, c, decode+8 );", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5405, + "column": 1, + "source_line": "#define stbir__3_coeff_only() \\" + } + }, + { + "name": "stbir__store_output_tiny", + "value": "stbir__simdf_store( output, tot ); horizontal_coefficients += coefficient_width; ++horizontal_contributors; output += 4;", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5416, + "column": 1, + "source_line": "#define stbir__store_output_tiny() \\" + } + }, + { + "name": "stbir__4_coeff_start", + "value": "stbir__simdf8 tot0,c,cs; stbir__simdf t; STBIR_SIMD_NO_UNROLL(decode); stbir__simdf8_load4b( cs, hc ); stbir__simdf8_0123to00001111( c, cs ); stbir__simdf8_mult_mem( tot0, c, decode ); stbir__simdf8_0123to22223333( c, cs ); stbir__simdf8_madd_mem( tot0, tot0, c, decode+8 );", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5424, + "column": 1, + "source_line": "#define stbir__4_coeff_start() \\" + } + }, + { + "name": "stbir__4_coeff_continue_from_4", + "value": "STBIR_SIMD_NO_UNROLL(decode); stbir__simdf8_load4b( cs, hc + (ofs) ); stbir__simdf8_0123to00001111( c, cs ); stbir__simdf8_madd_mem( tot0, tot0, c, decode+(ofs)*4 ); stbir__simdf8_0123to22223333( c, cs ); stbir__simdf8_madd_mem( tot0, tot0, c, decode+(ofs)*4+8 );", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5433, + "column": 1, + "source_line": "#define stbir__4_coeff_continue_from_4( ofs ) \\" + } + }, + { + "name": "stbir__1_coeff_remnant", + "value": "STBIR_SIMD_NO_UNROLL(decode); stbir__simdf_load1rep4( t, hc + (ofs) ); stbir__simdf8_madd_mem4( tot0, tot0, t, decode+(ofs)*4 );", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5441, + "column": 1, + "source_line": "#define stbir__1_coeff_remnant( ofs ) \\" + } + }, + { + "name": "stbir__2_coeff_remnant", + "value": "STBIR_SIMD_NO_UNROLL(decode); stbir__simdf8_load4b( cs, hc + (ofs) - 2 ); stbir__simdf8_0123to22223333( c, cs ); stbir__simdf8_madd_mem( tot0, tot0, c, decode+(ofs)*4 );", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5446, + "column": 1, + "source_line": "#define stbir__2_coeff_remnant( ofs ) \\" + } + }, + { + "name": "stbir__3_coeff_remnant", + "value": "STBIR_SIMD_NO_UNROLL(decode); stbir__simdf8_load4b( cs, hc + (ofs) ); stbir__simdf8_0123to00001111( c, cs ); stbir__simdf8_madd_mem( tot0, tot0, c, decode+(ofs)*4 ); stbir__simdf8_0123to2222( t, cs ); stbir__simdf8_madd_mem4( tot0, tot0, t, decode+(ofs)*4+8 );", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5452, + "column": 2, + "source_line": " #define stbir__3_coeff_remnant( ofs ) \\" + } + }, + { + "name": "stbir__store_output", + "value": "stbir__simdf8_add4halves( t, stbir__if_simdf8_cast_to_simdf4(tot0), tot0 ); stbir__simdf_store( output, t ); horizontal_coefficients += coefficient_width; ++horizontal_contributors; output += 4;", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5460, + "column": 1, + "source_line": "#define stbir__store_output() \\" + } + }, + { + "name": "stbir__4_coeff_start", + "value": "stbir__simdf tot0,tot1,c,cs; STBIR_SIMD_NO_UNROLL(decode); stbir__simdf_load( cs, hc ); stbir__simdf_0123to0000( c, cs ); stbir__simdf_mult_mem( tot0, c, decode ); stbir__simdf_0123to1111( c, cs ); stbir__simdf_mult_mem( tot1, c, decode+4 ); stbir__simdf_0123to2222( c, cs ); stbir__simdf_madd_mem( tot0, tot0, c, decode+8 ); stbir__simdf_0123to3333( c, cs ); stbir__simdf_madd_mem( tot1, tot1, c, decode+12 );", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5469, + "column": 1, + "source_line": "#define stbir__4_coeff_start() \\" + } + }, + { + "name": "stbir__4_coeff_continue_from_4", + "value": "STBIR_SIMD_NO_UNROLL(decode); stbir__simdf_load( cs, hc + (ofs) ); stbir__simdf_0123to0000( c, cs ); stbir__simdf_madd_mem( tot0, tot0, c, decode+(ofs)*4 ); stbir__simdf_0123to1111( c, cs ); stbir__simdf_madd_mem( tot1, tot1, c, decode+(ofs)*4+4 ); stbir__simdf_0123to2222( c, cs ); stbir__simdf_madd_mem( tot0, tot0, c, decode+(ofs)*4+8 ); stbir__simdf_0123to3333( c, cs ); stbir__simdf_madd_mem( tot1, tot1, c, decode+(ofs)*4+12 );", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5482, + "column": 1, + "source_line": "#define stbir__4_coeff_continue_from_4( ofs ) \\" + } + }, + { + "name": "stbir__1_coeff_remnant", + "value": "STBIR_SIMD_NO_UNROLL(decode); stbir__simdf_load1( c, hc + (ofs) ); stbir__simdf_0123to0000( c, c ); stbir__simdf_madd_mem( tot0, tot0, c, decode+(ofs)*4 );", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5494, + "column": 1, + "source_line": "#define stbir__1_coeff_remnant( ofs ) \\" + } + }, + { + "name": "stbir__2_coeff_remnant", + "value": "STBIR_SIMD_NO_UNROLL(decode); stbir__simdf_load2( cs, hc + (ofs) ); stbir__simdf_0123to0000( c, cs ); stbir__simdf_madd_mem( tot0, tot0, c, decode+(ofs)*4 ); stbir__simdf_0123to1111( c, cs ); stbir__simdf_madd_mem( tot1, tot1, c, decode+(ofs)*4+4 );", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5500, + "column": 1, + "source_line": "#define stbir__2_coeff_remnant( ofs ) \\" + } + }, + { + "name": "stbir__3_coeff_remnant", + "value": "STBIR_SIMD_NO_UNROLL(decode); stbir__simdf_load( cs, hc + (ofs) ); stbir__simdf_0123to0000( c, cs ); stbir__simdf_madd_mem( tot0, tot0, c, decode+(ofs)*4 ); stbir__simdf_0123to1111( c, cs ); stbir__simdf_madd_mem( tot1, tot1, c, decode+(ofs)*4+4 ); stbir__simdf_0123to2222( c, cs ); stbir__simdf_madd_mem( tot0, tot0, c, decode+(ofs)*4+8 );", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5508, + "column": 1, + "source_line": "#define stbir__3_coeff_remnant( ofs ) \\" + } + }, + { + "name": "stbir__store_output", + "value": "stbir__simdf_add( tot0, tot0, tot1 ); stbir__simdf_store( output, tot0 ); horizontal_coefficients += coefficient_width; ++horizontal_contributors; output += 4;", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5518, + "column": 1, + "source_line": "#define stbir__store_output() \\" + } + }, + { + "name": "stbir__1_coeff_only", + "value": "float p0,p1,p2,p3,c; STBIR_SIMD_NO_UNROLL(decode); c = hc[0]; p0 = decode[0] * c; p1 = decode[1] * c; p2 = decode[2] * c; p3 = decode[3] * c;", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5529, + "column": 1, + "source_line": "#define stbir__1_coeff_only() \\" + } + }, + { + "name": "stbir__2_coeff_only", + "value": "float p0,p1,p2,p3,c; STBIR_SIMD_NO_UNROLL(decode); c = hc[0]; p0 = decode[0] * c; p1 = decode[1] * c; p2 = decode[2] * c; p3 = decode[3] * c; c = hc[1]; p0 += decode[4] * c; p1 += decode[5] * c; p2 += decode[6] * c; p3 += decode[7] * c;", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5538, + "column": 1, + "source_line": "#define stbir__2_coeff_only() \\" + } + }, + { + "name": "stbir__3_coeff_only", + "value": "float p0,p1,p2,p3,c; STBIR_SIMD_NO_UNROLL(decode); c = hc[0]; p0 = decode[0] * c; p1 = decode[1] * c; p2 = decode[2] * c; p3 = decode[3] * c; c = hc[1]; p0 += decode[4] * c; p1 += decode[5] * c; p2 += decode[6] * c; p3 += decode[7] * c; c = hc[2]; p0 += decode[8] * c; p1 += decode[9] * c; p2 += decode[10] * c; p3 += decode[11] * c;", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5552, + "column": 1, + "source_line": "#define stbir__3_coeff_only() \\" + } + }, + { + "name": "stbir__store_output_tiny", + "value": "output[0] = p0; output[1] = p1; output[2] = p2; output[3] = p3; horizontal_coefficients += coefficient_width; ++horizontal_contributors; output += 4;", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5571, + "column": 1, + "source_line": "#define stbir__store_output_tiny() \\" + } + }, + { + "name": "stbir__4_coeff_start", + "value": "float x0,x1,x2,x3,y0,y1,y2,y3,c; STBIR_SIMD_NO_UNROLL(decode); c = hc[0]; x0 = decode[0] * c; x1 = decode[1] * c; x2 = decode[2] * c; x3 = decode[3] * c; c = hc[1]; y0 = decode[4] * c; y1 = decode[5] * c; y2 = decode[6] * c; y3 = decode[7] * c; c = hc[2]; x0 += decode[8] * c; x1 += decode[9] * c; x2 += decode[10] * c; x3 += decode[11] * c; c = hc[3]; y0 += decode[12] * c; y1 += decode[13] * c; y2 += decode[14] * c; y3 += decode[15] * c;", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5580, + "column": 1, + "source_line": "#define stbir__4_coeff_start() \\" + } + }, + { + "name": "stbir__4_coeff_continue_from_4", + "value": "STBIR_SIMD_NO_UNROLL(decode); c = hc[0+(ofs)]; x0 += decode[0+(ofs)*4] * c; x1 += decode[1+(ofs)*4] * c; x2 += decode[2+(ofs)*4] * c; x3 += decode[3+(ofs)*4] * c; c = hc[1+(ofs)]; y0 += decode[4+(ofs)*4] * c; y1 += decode[5+(ofs)*4] * c; y2 += decode[6+(ofs)*4] * c; y3 += decode[7+(ofs)*4] * c; c = hc[2+(ofs)]; x0 += decode[8+(ofs)*4] * c; x1 += decode[9+(ofs)*4] * c; x2 += decode[10+(ofs)*4] * c; x3 += decode[11+(ofs)*4] * c; c = hc[3+(ofs)]; y0 += decode[12+(ofs)*4] * c; y1 += decode[13+(ofs)*4] * c; y2 += decode[14+(ofs)*4] * c; y3 += decode[15+(ofs)*4] * c;", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5604, + "column": 1, + "source_line": "#define stbir__4_coeff_continue_from_4( ofs ) \\" + } + }, + { + "name": "stbir__1_coeff_remnant", + "value": "STBIR_SIMD_NO_UNROLL(decode); c = hc[0+(ofs)]; x0 += decode[0+(ofs)*4] * c; x1 += decode[1+(ofs)*4] * c; x2 += decode[2+(ofs)*4] * c; x3 += decode[3+(ofs)*4] * c;", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5627, + "column": 1, + "source_line": "#define stbir__1_coeff_remnant( ofs ) \\" + } + }, + { + "name": "stbir__2_coeff_remnant", + "value": "STBIR_SIMD_NO_UNROLL(decode); c = hc[0+(ofs)]; x0 += decode[0+(ofs)*4] * c; x1 += decode[1+(ofs)*4] * c; x2 += decode[2+(ofs)*4] * c; x3 += decode[3+(ofs)*4] * c; c = hc[1+(ofs)]; y0 += decode[4+(ofs)*4] * c; y1 += decode[5+(ofs)*4] * c; y2 += decode[6+(ofs)*4] * c; y3 += decode[7+(ofs)*4] * c;", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5635, + "column": 1, + "source_line": "#define stbir__2_coeff_remnant( ofs ) \\" + } + }, + { + "name": "stbir__3_coeff_remnant", + "value": "STBIR_SIMD_NO_UNROLL(decode); c = hc[0+(ofs)]; x0 += decode[0+(ofs)*4] * c; x1 += decode[1+(ofs)*4] * c; x2 += decode[2+(ofs)*4] * c; x3 += decode[3+(ofs)*4] * c; c = hc[1+(ofs)]; y0 += decode[4+(ofs)*4] * c; y1 += decode[5+(ofs)*4] * c; y2 += decode[6+(ofs)*4] * c; y3 += decode[7+(ofs)*4] * c; c = hc[2+(ofs)]; x0 += decode[8+(ofs)*4] * c; x1 += decode[9+(ofs)*4] * c; x2 += decode[10+(ofs)*4] * c; x3 += decode[11+(ofs)*4] * c;", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5648, + "column": 1, + "source_line": "#define stbir__3_coeff_remnant( ofs ) \\" + } + }, + { + "name": "stbir__store_output", + "value": "output[0] = x0 + y0; output[1] = x1 + y1; output[2] = x2 + y2; output[3] = x3 + y3; horizontal_coefficients += coefficient_width; ++horizontal_contributors; output += 4;", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5666, + "column": 1, + "source_line": "#define stbir__store_output() \\" + } + }, + { + "name": "STBIR__horizontal_channels", + "value": "4", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5677, + "column": 1, + "source_line": "#define STBIR__horizontal_channels 4" + } + }, + { + "name": "STB_IMAGE_RESIZE_DO_HORIZONTALS", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5678, + "column": 1, + "source_line": "#define STB_IMAGE_RESIZE_DO_HORIZONTALS" + } + }, + { + "name": "stbir__1_coeff_only", + "value": "stbir__simdf tot0,tot1,c; STBIR_SIMD_NO_UNROLL(decode); stbir__simdf_load1( c, hc ); stbir__simdf_0123to0000( c, c ); stbir__simdf_mult_mem( tot0, c, decode ); stbir__simdf_mult_mem( tot1, c, decode+3 );", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5688, + "column": 1, + "source_line": "#define stbir__1_coeff_only() \\" + } + }, + { + "name": "stbir__2_coeff_only", + "value": "stbir__simdf tot0,tot1,c,cs; STBIR_SIMD_NO_UNROLL(decode); stbir__simdf_load2( cs, hc ); stbir__simdf_0123to0000( c, cs ); stbir__simdf_mult_mem( tot0, c, decode ); stbir__simdf_mult_mem( tot1, c, decode+3 ); stbir__simdf_0123to1111( c, cs ); stbir__simdf_madd_mem( tot0, tot0, c, decode+7 ); stbir__simdf_madd_mem( tot1, tot1, c,decode+10 );", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5696, + "column": 1, + "source_line": "#define stbir__2_coeff_only() \\" + } + }, + { + "name": "stbir__3_coeff_only", + "value": "stbir__simdf tot0,tot1,c,cs; STBIR_SIMD_NO_UNROLL(decode); stbir__simdf_load( cs, hc ); stbir__simdf_0123to0000( c, cs ); stbir__simdf_mult_mem( tot0, c, decode ); stbir__simdf_mult_mem( tot1, c, decode+3 ); stbir__simdf_0123to1111( c, cs ); stbir__simdf_madd_mem( tot0, tot0, c, decode+7 ); stbir__simdf_madd_mem( tot1, tot1, c, decode+10 ); stbir__simdf_0123to2222( c, cs ); stbir__simdf_madd_mem( tot0, tot0, c, decode+14 ); stbir__simdf_madd_mem( tot1, tot1, c, decode+17 );", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5707, + "column": 1, + "source_line": "#define stbir__3_coeff_only() \\" + } + }, + { + "name": "stbir__store_output_tiny", + "value": "stbir__simdf_store( output+3, tot1 ); stbir__simdf_store( output, tot0 ); horizontal_coefficients += coefficient_width; ++horizontal_contributors; output += 7;", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5721, + "column": 1, + "source_line": "#define stbir__store_output_tiny() \\" + } + }, + { + "name": "stbir__4_coeff_start", + "value": "stbir__simdf8 tot0,tot1,c,cs; STBIR_SIMD_NO_UNROLL(decode); stbir__simdf8_load4b( cs, hc ); stbir__simdf8_0123to00000000( c, cs ); stbir__simdf8_mult_mem( tot0, c, decode ); stbir__simdf8_0123to11111111( c, cs ); stbir__simdf8_mult_mem( tot1, c, decode+7 ); stbir__simdf8_0123to22222222( c, cs ); stbir__simdf8_madd_mem( tot0, tot0, c, decode+14 ); stbir__simdf8_0123to33333333( c, cs ); stbir__simdf8_madd_mem( tot1, tot1, c, decode+21 );", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5730, + "column": 1, + "source_line": "#define stbir__4_coeff_start() \\" + } + }, + { + "name": "stbir__4_coeff_continue_from_4", + "value": "STBIR_SIMD_NO_UNROLL(decode); stbir__simdf8_load4b( cs, hc + (ofs) ); stbir__simdf8_0123to00000000( c, cs ); stbir__simdf8_madd_mem( tot0, tot0, c, decode+(ofs)*7 ); stbir__simdf8_0123to11111111( c, cs ); stbir__simdf8_madd_mem( tot1, tot1, c, decode+(ofs)*7+7 ); stbir__simdf8_0123to22222222( c, cs ); stbir__simdf8_madd_mem( tot0, tot0, c, decode+(ofs)*7+14 ); stbir__simdf8_0123to33333333( c, cs ); stbir__simdf8_madd_mem( tot1, tot1, c, decode+(ofs)*7+21 );", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5743, + "column": 1, + "source_line": "#define stbir__4_coeff_continue_from_4( ofs ) \\" + } + }, + { + "name": "stbir__1_coeff_remnant", + "value": "STBIR_SIMD_NO_UNROLL(decode); stbir__simdf8_load1b( c, hc + (ofs) ); stbir__simdf8_madd_mem( tot0, tot0, c, decode+(ofs)*7 );", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5755, + "column": 1, + "source_line": "#define stbir__1_coeff_remnant( ofs ) \\" + } + }, + { + "name": "stbir__2_coeff_remnant", + "value": "STBIR_SIMD_NO_UNROLL(decode); stbir__simdf8_load1b( c, hc + (ofs) ); stbir__simdf8_madd_mem( tot0, tot0, c, decode+(ofs)*7 ); stbir__simdf8_load1b( c, hc + (ofs)+1 ); stbir__simdf8_madd_mem( tot1, tot1, c, decode+(ofs)*7+7 );", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5760, + "column": 1, + "source_line": "#define stbir__2_coeff_remnant( ofs ) \\" + } + }, + { + "name": "stbir__3_coeff_remnant", + "value": "STBIR_SIMD_NO_UNROLL(decode); stbir__simdf8_load4b( cs, hc + (ofs) ); stbir__simdf8_0123to00000000( c, cs ); stbir__simdf8_madd_mem( tot0, tot0, c, decode+(ofs)*7 ); stbir__simdf8_0123to11111111( c, cs ); stbir__simdf8_madd_mem( tot1, tot1, c, decode+(ofs)*7+7 ); stbir__simdf8_0123to22222222( c, cs ); stbir__simdf8_madd_mem( tot0, tot0, c, decode+(ofs)*7+14 );", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5767, + "column": 1, + "source_line": "#define stbir__3_coeff_remnant( ofs ) \\" + } + }, + { + "name": "stbir__store_output", + "value": "stbir__simdf8_add( tot0, tot0, tot1 ); horizontal_coefficients += coefficient_width; ++horizontal_contributors; output += 7; if ( output < output_end ) { stbir__simdf8_store( output-7, tot0 ); continue; } stbir__simdf_store( output-7+3, stbir__simdf_swiz(stbir__simdf8_gettop4(tot0),0,0,1,2) ); stbir__simdf_store( output-7, stbir__if_simdf8_cast_to_simdf4(tot0) ); break;", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5777, + "column": 1, + "source_line": "#define stbir__store_output() \\" + } + }, + { + "name": "stbir__4_coeff_start", + "value": "stbir__simdf tot0,tot1,tot2,tot3,c,cs; STBIR_SIMD_NO_UNROLL(decode); stbir__simdf_load( cs, hc ); stbir__simdf_0123to0000( c, cs ); stbir__simdf_mult_mem( tot0, c, decode ); stbir__simdf_mult_mem( tot1, c, decode+3 ); stbir__simdf_0123to1111( c, cs ); stbir__simdf_mult_mem( tot2, c, decode+7 ); stbir__simdf_mult_mem( tot3, c, decode+10 ); stbir__simdf_0123to2222( c, cs ); stbir__simdf_madd_mem( tot0, tot0, c, decode+14 ); stbir__simdf_madd_mem( tot1, tot1, c, decode+17 ); stbir__simdf_0123to3333( c, cs ); stbir__simdf_madd_mem( tot2, tot2, c, decode+21 ); stbir__simdf_madd_mem( tot3, tot3, c, decode+24 );", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5793, + "column": 1, + "source_line": "#define stbir__4_coeff_start() \\" + } + }, + { + "name": "stbir__4_coeff_continue_from_4", + "value": "STBIR_SIMD_NO_UNROLL(decode); stbir__simdf_load( cs, hc + (ofs) ); stbir__simdf_0123to0000( c, cs ); stbir__simdf_madd_mem( tot0, tot0, c, decode+(ofs)*7 ); stbir__simdf_madd_mem( tot1, tot1, c, decode+(ofs)*7+3 ); stbir__simdf_0123to1111( c, cs ); stbir__simdf_madd_mem( tot2, tot2, c, decode+(ofs)*7+7 ); stbir__simdf_madd_mem( tot3, tot3, c, decode+(ofs)*7+10 ); stbir__simdf_0123to2222( c, cs ); stbir__simdf_madd_mem( tot0, tot0, c, decode+(ofs)*7+14 ); stbir__simdf_madd_mem( tot1, tot1, c, decode+(ofs)*7+17 ); stbir__simdf_0123to3333( c, cs ); stbir__simdf_madd_mem( tot2, tot2, c, decode+(ofs)*7+21 ); stbir__simdf_madd_mem( tot3, tot3, c, decode+(ofs)*7+24 );", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5810, + "column": 1, + "source_line": "#define stbir__4_coeff_continue_from_4( ofs ) \\" + } + }, + { + "name": "stbir__1_coeff_remnant", + "value": "STBIR_SIMD_NO_UNROLL(decode); stbir__simdf_load1( c, hc + (ofs) ); stbir__simdf_0123to0000( c, c ); stbir__simdf_madd_mem( tot0, tot0, c, decode+(ofs)*7 ); stbir__simdf_madd_mem( tot1, tot1, c, decode+(ofs)*7+3 );", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5826, + "column": 1, + "source_line": "#define stbir__1_coeff_remnant( ofs ) \\" + } + }, + { + "name": "stbir__2_coeff_remnant", + "value": "STBIR_SIMD_NO_UNROLL(decode); stbir__simdf_load2( cs, hc + (ofs) ); stbir__simdf_0123to0000( c, cs ); stbir__simdf_madd_mem( tot0, tot0, c, decode+(ofs)*7 ); stbir__simdf_madd_mem( tot1, tot1, c, decode+(ofs)*7+3 ); stbir__simdf_0123to1111( c, cs ); stbir__simdf_madd_mem( tot2, tot2, c, decode+(ofs)*7+7 ); stbir__simdf_madd_mem( tot3, tot3, c, decode+(ofs)*7+10 );", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5833, + "column": 1, + "source_line": "#define stbir__2_coeff_remnant( ofs ) \\" + } + }, + { + "name": "stbir__3_coeff_remnant", + "value": "STBIR_SIMD_NO_UNROLL(decode); stbir__simdf_load( cs, hc + (ofs) ); stbir__simdf_0123to0000( c, cs ); stbir__simdf_madd_mem( tot0, tot0, c, decode+(ofs)*7 ); stbir__simdf_madd_mem( tot1, tot1, c, decode+(ofs)*7+3 ); stbir__simdf_0123to1111( c, cs ); stbir__simdf_madd_mem( tot2, tot2, c, decode+(ofs)*7+7 ); stbir__simdf_madd_mem( tot3, tot3, c, decode+(ofs)*7+10 ); stbir__simdf_0123to2222( c, cs ); stbir__simdf_madd_mem( tot0, tot0, c, decode+(ofs)*7+14 ); stbir__simdf_madd_mem( tot1, tot1, c, decode+(ofs)*7+17 );", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5843, + "column": 1, + "source_line": "#define stbir__3_coeff_remnant( ofs ) \\" + } + }, + { + "name": "stbir__store_output", + "value": "stbir__simdf_add( tot0, tot0, tot2 ); stbir__simdf_add( tot1, tot1, tot3 ); stbir__simdf_store( output+3, tot1 ); stbir__simdf_store( output, tot0 ); horizontal_coefficients += coefficient_width; ++horizontal_contributors; output += 7;", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5856, + "column": 1, + "source_line": "#define stbir__store_output() \\" + } + }, + { + "name": "stbir__1_coeff_only", + "value": "float tot0, tot1, tot2, tot3, tot4, tot5, tot6, c; c = hc[0]; tot0 = decode[0]*c; tot1 = decode[1]*c; tot2 = decode[2]*c; tot3 = decode[3]*c; tot4 = decode[4]*c; tot5 = decode[5]*c; tot6 = decode[6]*c;", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5869, + "column": 1, + "source_line": "#define stbir__1_coeff_only() \\" + } + }, + { + "name": "stbir__2_coeff_only", + "value": "float tot0, tot1, tot2, tot3, tot4, tot5, tot6, c; c = hc[0]; tot0 = decode[0]*c; tot1 = decode[1]*c; tot2 = decode[2]*c; tot3 = decode[3]*c; tot4 = decode[4]*c; tot5 = decode[5]*c; tot6 = decode[6]*c; c = hc[1]; tot0 += decode[7]*c; tot1 += decode[8]*c; tot2 += decode[9]*c; tot3 += decode[10]*c; tot4 += decode[11]*c; tot5 += decode[12]*c; tot6 += decode[13]*c;", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5880, + "column": 1, + "source_line": "#define stbir__2_coeff_only() \\" + } + }, + { + "name": "stbir__3_coeff_only", + "value": "float tot0, tot1, tot2, tot3, tot4, tot5, tot6, c; c = hc[0]; tot0 = decode[0]*c; tot1 = decode[1]*c; tot2 = decode[2]*c; tot3 = decode[3]*c; tot4 = decode[4]*c; tot5 = decode[5]*c; tot6 = decode[6]*c; c = hc[1]; tot0 += decode[7]*c; tot1 += decode[8]*c; tot2 += decode[9]*c; tot3 += decode[10]*c; tot4 += decode[11]*c; tot5 += decode[12]*c; tot6 += decode[13]*c; c = hc[2]; tot0 += decode[14]*c; tot1 += decode[15]*c; tot2 += decode[16]*c; tot3 += decode[17]*c; tot4 += decode[18]*c; tot5 += decode[19]*c; tot6 += decode[20]*c;", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5899, + "column": 1, + "source_line": "#define stbir__3_coeff_only() \\" + } + }, + { + "name": "stbir__store_output_tiny", + "value": "output[0] = tot0; output[1] = tot1; output[2] = tot2; output[3] = tot3; output[4] = tot4; output[5] = tot5; output[6] = tot6; horizontal_coefficients += coefficient_width; ++horizontal_contributors; output += 7;", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5926, + "column": 1, + "source_line": "#define stbir__store_output_tiny() \\" + } + }, + { + "name": "stbir__4_coeff_start", + "value": "float x0,x1,x2,x3,x4,x5,x6,y0,y1,y2,y3,y4,y5,y6,c; STBIR_SIMD_NO_UNROLL(decode); c = hc[0]; x0 = decode[0] * c; x1 = decode[1] * c; x2 = decode[2] * c; x3 = decode[3] * c; x4 = decode[4] * c; x5 = decode[5] * c; x6 = decode[6] * c; c = hc[1]; y0 = decode[7] * c; y1 = decode[8] * c; y2 = decode[9] * c; y3 = decode[10] * c; y4 = decode[11] * c; y5 = decode[12] * c; y6 = decode[13] * c; c = hc[2]; x0 += decode[14] * c; x1 += decode[15] * c; x2 += decode[16] * c; x3 += decode[17] * c; x4 += decode[18] * c; x5 += decode[19] * c; x6 += decode[20] * c; c = hc[3]; y0 += decode[21] * c; y1 += decode[22] * c; y2 += decode[23] * c; y3 += decode[24] * c; y4 += decode[25] * c; y5 += decode[26] * c; y6 += decode[27] * c;", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5938, + "column": 1, + "source_line": "#define stbir__4_coeff_start() \\" + } + }, + { + "name": "stbir__4_coeff_continue_from_4", + "value": "STBIR_SIMD_NO_UNROLL(decode); c = hc[0+(ofs)]; x0 += decode[0+(ofs)*7] * c; x1 += decode[1+(ofs)*7] * c; x2 += decode[2+(ofs)*7] * c; x3 += decode[3+(ofs)*7] * c; x4 += decode[4+(ofs)*7] * c; x5 += decode[5+(ofs)*7] * c; x6 += decode[6+(ofs)*7] * c; c = hc[1+(ofs)]; y0 += decode[7+(ofs)*7] * c; y1 += decode[8+(ofs)*7] * c; y2 += decode[9+(ofs)*7] * c; y3 += decode[10+(ofs)*7] * c; y4 += decode[11+(ofs)*7] * c; y5 += decode[12+(ofs)*7] * c; y6 += decode[13+(ofs)*7] * c; c = hc[2+(ofs)]; x0 += decode[14+(ofs)*7] * c; x1 += decode[15+(ofs)*7] * c; x2 += decode[16+(ofs)*7] * c; x3 += decode[17+(ofs)*7] * c; x4 += decode[18+(ofs)*7] * c; x5 += decode[19+(ofs)*7] * c; x6 += decode[20+(ofs)*7] * c; c = hc[3+(ofs)]; y0 += decode[21+(ofs)*7] * c; y1 += decode[22+(ofs)*7] * c; y2 += decode[23+(ofs)*7] * c; y3 += decode[24+(ofs)*7] * c; y4 += decode[25+(ofs)*7] * c; y5 += decode[26+(ofs)*7] * c; y6 += decode[27+(ofs)*7] * c;", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5974, + "column": 1, + "source_line": "#define stbir__4_coeff_continue_from_4( ofs ) \\" + } + }, + { + "name": "stbir__1_coeff_remnant", + "value": "STBIR_SIMD_NO_UNROLL(decode); c = hc[0+(ofs)]; x0 += decode[0+(ofs)*7] * c; x1 += decode[1+(ofs)*7] * c; x2 += decode[2+(ofs)*7] * c; x3 += decode[3+(ofs)*7] * c; x4 += decode[4+(ofs)*7] * c; x5 += decode[5+(ofs)*7] * c; x6 += decode[6+(ofs)*7] * c;", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6009, + "column": 1, + "source_line": "#define stbir__1_coeff_remnant( ofs ) \\" + } + }, + { + "name": "stbir__2_coeff_remnant", + "value": "STBIR_SIMD_NO_UNROLL(decode); c = hc[0+(ofs)]; x0 += decode[0+(ofs)*7] * c; x1 += decode[1+(ofs)*7] * c; x2 += decode[2+(ofs)*7] * c; x3 += decode[3+(ofs)*7] * c; x4 += decode[4+(ofs)*7] * c; x5 += decode[5+(ofs)*7] * c; x6 += decode[6+(ofs)*7] * c; c = hc[1+(ofs)]; y0 += decode[7+(ofs)*7] * c; y1 += decode[8+(ofs)*7] * c; y2 += decode[9+(ofs)*7] * c; y3 += decode[10+(ofs)*7] * c; y4 += decode[11+(ofs)*7] * c; y5 += decode[12+(ofs)*7] * c; y6 += decode[13+(ofs)*7] * c;", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6020, + "column": 1, + "source_line": "#define stbir__2_coeff_remnant( ofs ) \\" + } + }, + { + "name": "stbir__3_coeff_remnant", + "value": "STBIR_SIMD_NO_UNROLL(decode); c = hc[0+(ofs)]; x0 += decode[0+(ofs)*7] * c; x1 += decode[1+(ofs)*7] * c; x2 += decode[2+(ofs)*7] * c; x3 += decode[3+(ofs)*7] * c; x4 += decode[4+(ofs)*7] * c; x5 += decode[5+(ofs)*7] * c; x6 += decode[6+(ofs)*7] * c; c = hc[1+(ofs)]; y0 += decode[7+(ofs)*7] * c; y1 += decode[8+(ofs)*7] * c; y2 += decode[9+(ofs)*7] * c; y3 += decode[10+(ofs)*7] * c; y4 += decode[11+(ofs)*7] * c; y5 += decode[12+(ofs)*7] * c; y6 += decode[13+(ofs)*7] * c; c = hc[2+(ofs)]; x0 += decode[14+(ofs)*7] * c; x1 += decode[15+(ofs)*7] * c; x2 += decode[16+(ofs)*7] * c; x3 += decode[17+(ofs)*7] * c; x4 += decode[18+(ofs)*7] * c; x5 += decode[19+(ofs)*7] * c; x6 += decode[20+(ofs)*7] * c;", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6039, + "column": 1, + "source_line": "#define stbir__3_coeff_remnant( ofs ) \\" + } + }, + { + "name": "stbir__store_output", + "value": "output[0] = x0 + y0; output[1] = x1 + y1; output[2] = x2 + y2; output[3] = x3 + y3; output[4] = x4 + y4; output[5] = x5 + y5; output[6] = x6 + y6; horizontal_coefficients += coefficient_width; ++horizontal_contributors; output += 7;", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6066, + "column": 1, + "source_line": "#define stbir__store_output() \\" + } + }, + { + "name": "STBIR__horizontal_channels", + "value": "7", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6080, + "column": 1, + "source_line": "#define STBIR__horizontal_channels 7" + } + }, + { + "name": "STB_IMAGE_RESIZE_DO_HORIZONTALS", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6081, + "column": 1, + "source_line": "#define STB_IMAGE_RESIZE_DO_HORIZONTALS" + } + }, + { + "name": "STBIR__vertical_channels", + "value": "1", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6087, + "column": 1, + "source_line": "#define STBIR__vertical_channels 1" + } + }, + { + "name": "STB_IMAGE_RESIZE_DO_VERTICALS", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6088, + "column": 1, + "source_line": "#define STB_IMAGE_RESIZE_DO_VERTICALS" + } + }, + { + "name": "STBIR__vertical_channels", + "value": "1", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6091, + "column": 1, + "source_line": "#define STBIR__vertical_channels 1" + } + }, + { + "name": "STB_IMAGE_RESIZE_DO_VERTICALS", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6092, + "column": 1, + "source_line": "#define STB_IMAGE_RESIZE_DO_VERTICALS" + } + }, + { + "name": "STB_IMAGE_RESIZE_VERTICAL_CONTINUE", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6093, + "column": 1, + "source_line": "#define STB_IMAGE_RESIZE_VERTICAL_CONTINUE" + } + }, + { + "name": "STBIR__vertical_channels", + "value": "2", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6096, + "column": 1, + "source_line": "#define STBIR__vertical_channels 2" + } + }, + { + "name": "STB_IMAGE_RESIZE_DO_VERTICALS", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6097, + "column": 1, + "source_line": "#define STB_IMAGE_RESIZE_DO_VERTICALS" + } + }, + { + "name": "STBIR__vertical_channels", + "value": "2", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6100, + "column": 1, + "source_line": "#define STBIR__vertical_channels 2" + } + }, + { + "name": "STB_IMAGE_RESIZE_DO_VERTICALS", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6101, + "column": 1, + "source_line": "#define STB_IMAGE_RESIZE_DO_VERTICALS" + } + }, + { + "name": "STB_IMAGE_RESIZE_VERTICAL_CONTINUE", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6102, + "column": 1, + "source_line": "#define STB_IMAGE_RESIZE_VERTICAL_CONTINUE" + } + }, + { + "name": "STBIR__vertical_channels", + "value": "3", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6105, + "column": 1, + "source_line": "#define STBIR__vertical_channels 3" + } + }, + { + "name": "STB_IMAGE_RESIZE_DO_VERTICALS", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6106, + "column": 1, + "source_line": "#define STB_IMAGE_RESIZE_DO_VERTICALS" + } + }, + { + "name": "STBIR__vertical_channels", + "value": "3", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6109, + "column": 1, + "source_line": "#define STBIR__vertical_channels 3" + } + }, + { + "name": "STB_IMAGE_RESIZE_DO_VERTICALS", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6110, + "column": 1, + "source_line": "#define STB_IMAGE_RESIZE_DO_VERTICALS" + } + }, + { + "name": "STB_IMAGE_RESIZE_VERTICAL_CONTINUE", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6111, + "column": 1, + "source_line": "#define STB_IMAGE_RESIZE_VERTICAL_CONTINUE" + } + }, + { + "name": "STBIR__vertical_channels", + "value": "4", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6114, + "column": 1, + "source_line": "#define STBIR__vertical_channels 4" + } + }, + { + "name": "STB_IMAGE_RESIZE_DO_VERTICALS", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6115, + "column": 1, + "source_line": "#define STB_IMAGE_RESIZE_DO_VERTICALS" + } + }, + { + "name": "STBIR__vertical_channels", + "value": "4", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6118, + "column": 1, + "source_line": "#define STBIR__vertical_channels 4" + } + }, + { + "name": "STB_IMAGE_RESIZE_DO_VERTICALS", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6119, + "column": 1, + "source_line": "#define STB_IMAGE_RESIZE_DO_VERTICALS" + } + }, + { + "name": "STB_IMAGE_RESIZE_VERTICAL_CONTINUE", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6120, + "column": 1, + "source_line": "#define STB_IMAGE_RESIZE_VERTICAL_CONTINUE" + } + }, + { + "name": "STBIR__vertical_channels", + "value": "5", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6123, + "column": 1, + "source_line": "#define STBIR__vertical_channels 5" + } + }, + { + "name": "STB_IMAGE_RESIZE_DO_VERTICALS", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6124, + "column": 1, + "source_line": "#define STB_IMAGE_RESIZE_DO_VERTICALS" + } + }, + { + "name": "STBIR__vertical_channels", + "value": "5", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6127, + "column": 1, + "source_line": "#define STBIR__vertical_channels 5" + } + }, + { + "name": "STB_IMAGE_RESIZE_DO_VERTICALS", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6128, + "column": 1, + "source_line": "#define STB_IMAGE_RESIZE_DO_VERTICALS" + } + }, + { + "name": "STB_IMAGE_RESIZE_VERTICAL_CONTINUE", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6129, + "column": 1, + "source_line": "#define STB_IMAGE_RESIZE_VERTICAL_CONTINUE" + } + }, + { + "name": "STBIR__vertical_channels", + "value": "6", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6132, + "column": 1, + "source_line": "#define STBIR__vertical_channels 6" + } + }, + { + "name": "STB_IMAGE_RESIZE_DO_VERTICALS", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6133, + "column": 1, + "source_line": "#define STB_IMAGE_RESIZE_DO_VERTICALS" + } + }, + { + "name": "STBIR__vertical_channels", + "value": "6", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6136, + "column": 1, + "source_line": "#define STBIR__vertical_channels 6" + } + }, + { + "name": "STB_IMAGE_RESIZE_DO_VERTICALS", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6137, + "column": 1, + "source_line": "#define STB_IMAGE_RESIZE_DO_VERTICALS" + } + }, + { + "name": "STB_IMAGE_RESIZE_VERTICAL_CONTINUE", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6138, + "column": 1, + "source_line": "#define STB_IMAGE_RESIZE_VERTICAL_CONTINUE" + } + }, + { + "name": "STBIR__vertical_channels", + "value": "7", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6141, + "column": 1, + "source_line": "#define STBIR__vertical_channels 7" + } + }, + { + "name": "STB_IMAGE_RESIZE_DO_VERTICALS", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6142, + "column": 1, + "source_line": "#define STB_IMAGE_RESIZE_DO_VERTICALS" + } + }, + { + "name": "STBIR__vertical_channels", + "value": "7", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6145, + "column": 1, + "source_line": "#define STBIR__vertical_channels 7" + } + }, + { + "name": "STB_IMAGE_RESIZE_DO_VERTICALS", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6146, + "column": 1, + "source_line": "#define STB_IMAGE_RESIZE_DO_VERTICALS" + } + }, + { + "name": "STB_IMAGE_RESIZE_VERTICAL_CONTINUE", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6147, + "column": 1, + "source_line": "#define STB_IMAGE_RESIZE_VERTICAL_CONTINUE" + } + }, + { + "name": "STBIR__vertical_channels", + "value": "8", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6150, + "column": 1, + "source_line": "#define STBIR__vertical_channels 8" + } + }, + { + "name": "STB_IMAGE_RESIZE_DO_VERTICALS", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6151, + "column": 1, + "source_line": "#define STB_IMAGE_RESIZE_DO_VERTICALS" + } + }, + { + "name": "STBIR__vertical_channels", + "value": "8", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6154, + "column": 1, + "source_line": "#define STBIR__vertical_channels 8" + } + }, + { + "name": "STB_IMAGE_RESIZE_DO_VERTICALS", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6155, + "column": 1, + "source_line": "#define STB_IMAGE_RESIZE_DO_VERTICALS" + } + }, + { + "name": "STB_IMAGE_RESIZE_VERTICAL_CONTINUE", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6156, + "column": 1, + "source_line": "#define STB_IMAGE_RESIZE_VERTICAL_CONTINUE" + } + }, + { + "name": "STBIR__FLOAT_EMPTY_MARKER", + "value": "3.0e+38F", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6371, + "column": 1, + "source_line": "#define STBIR__FLOAT_EMPTY_MARKER 3.0e+38F" + } + }, + { + "name": "STBIR__FLOAT_BUFFER_IS_EMPTY", + "value": "((ptr)[0]==STBIR__FLOAT_EMPTY_MARKER)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6372, + "column": 1, + "source_line": "#define STBIR__FLOAT_BUFFER_IS_EMPTY(ptr) ((ptr)[0]==STBIR__FLOAT_EMPTY_MARKER)" + } + }, + { + "name": "STBIR__FREE_AND_CLEAR", + "value": "{ if ( ptr ) { void * p = (ptr); (ptr) = 0; STBIR_FREE( p, info->user_data); } }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6819, + "column": 3, + "source_line": " #define STBIR__FREE_AND_CLEAR( ptr ) { if ( ptr ) { void * p = (ptr); (ptr) = 0; STBIR_FREE( p, info->user_data); } }" + } + }, + { + "name": "STBIR__FREE_AND_CLEAR", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6865, + "column": 3, + "source_line": " #undef STBIR__FREE_AND_CLEAR" + } + }, + { + "name": "STBIR_RESIZE_CLASSIFICATIONS", + "value": "8", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6894, + "column": 1, + "source_line": "#define STBIR_RESIZE_CLASSIFICATIONS 8" + } + }, + { + "name": "STBIR__V_FIRST_INFO_POINTER", + "value": "&STBIR__V_FIRST_INFO_BUFFER", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6958, + "column": 1, + "source_line": "#define STBIR__V_FIRST_INFO_POINTER &STBIR__V_FIRST_INFO_BUFFER" + } + }, + { + "name": "STBIR__V_FIRST_INFO_POINTER", + "value": "0", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6960, + "column": 1, + "source_line": "#define STBIR__V_FIRST_INFO_POINTER 0" + } + }, + { + "name": "STBIR__NEXT_PTR", + "value": "if ( alloced ) { void * p = STBIR_MALLOC( size, user_data); if ( p == 0 ) { stbir__free_internal_mem( info ); return 0; } (ptr) = (ntype*)p; }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 7143, + "column": 5, + "source_line": " #define STBIR__NEXT_PTR( ptr, size, ntype ) if ( alloced ) { void * p = STBIR_MALLOC( size, user_data); if ( p == 0 ) { stbir__free_internal_mem( info ); return 0; } (ptr) = (ntype*)p; }" + } + }, + { + "name": "STBIR__NEXT_PTR", + "value": "advance_mem = (void*) ( ( ((size_t)advance_mem) + 15 ) & ~15 ); if ( alloced ) ptr = (ntype*)advance_mem; advance_mem = (char*)(((size_t)advance_mem) + (size));", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 7145, + "column": 5, + "source_line": " #define STBIR__NEXT_PTR( ptr, size, ntype ) advance_mem = (void*) ( ( ((size_t)advance_mem) + 15 ) & ~15 ); if ( alloced ) ptr = (ntype*)advance_mem; advance_mem = (char*)(((size_t)advance_mem) + (size));" + } + }, + { + "name": "STBIR__NEXT_PTR", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 7364, + "column": 5, + "source_line": " #undef STBIR__NEXT_PTR" + } + }, + { + "name": "STBIR_RETURN_ERROR_AND_ASSERT", + "value": "STBIR_ASSERT( !(exp) ); if (exp) return 0;", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 7891, + "column": 3, + "source_line": " #define STBIR_RETURN_ERROR_AND_ASSERT( exp ) STBIR_ASSERT( !(exp) ); if (exp) return 0;" + } + }, + { + "name": "STBIR_RETURN_ERROR_AND_ASSERT", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 7894, + "column": 3, + "source_line": " #undef STBIR_RETURN_ERROR_AND_ASSERT" + } + }, + { + "name": "STBIR_BGR", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8226, + "column": 1, + "source_line": "#undef STBIR_BGR" + } + }, + { + "name": "STBIR_1CHANNEL", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8227, + "column": 1, + "source_line": "#undef STBIR_1CHANNEL" + } + }, + { + "name": "STBIR_2CHANNEL", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8228, + "column": 1, + "source_line": "#undef STBIR_2CHANNEL" + } + }, + { + "name": "STBIR_RGB", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8229, + "column": 1, + "source_line": "#undef STBIR_RGB" + } + }, + { + "name": "STBIR_RGBA", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8230, + "column": 1, + "source_line": "#undef STBIR_RGBA" + } + }, + { + "name": "STBIR_4CHANNEL", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8231, + "column": 1, + "source_line": "#undef STBIR_4CHANNEL" + } + }, + { + "name": "STBIR_BGRA", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8232, + "column": 1, + "source_line": "#undef STBIR_BGRA" + } + }, + { + "name": "STBIR_ARGB", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8233, + "column": 1, + "source_line": "#undef STBIR_ARGB" + } + }, + { + "name": "STBIR_ABGR", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8234, + "column": 1, + "source_line": "#undef STBIR_ABGR" + } + }, + { + "name": "STBIR_RA", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8235, + "column": 1, + "source_line": "#undef STBIR_RA" + } + }, + { + "name": "STBIR_AR", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8236, + "column": 1, + "source_line": "#undef STBIR_AR" + } + }, + { + "name": "STBIR_RGBA_PM", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8237, + "column": 1, + "source_line": "#undef STBIR_RGBA_PM" + } + }, + { + "name": "STBIR_BGRA_PM", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8238, + "column": 1, + "source_line": "#undef STBIR_BGRA_PM" + } + }, + { + "name": "STBIR_ARGB_PM", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8239, + "column": 1, + "source_line": "#undef STBIR_ARGB_PM" + } + }, + { + "name": "STBIR_ABGR_PM", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8240, + "column": 1, + "source_line": "#undef STBIR_ABGR_PM" + } + }, + { + "name": "STBIR_RA_PM", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8241, + "column": 1, + "source_line": "#undef STBIR_RA_PM" + } + }, + { + "name": "STBIR_AR_PM", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8242, + "column": 1, + "source_line": "#undef STBIR_AR_PM" + } + }, + { + "name": "STBIR_strs_join2", + "value": "start##mid##end", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8253, + "column": 1, + "source_line": "#define STBIR_strs_join2( start, mid, end ) start##mid##end" + } + }, + { + "name": "STBIR_strs_join1", + "value": "STBIR_strs_join2( start, mid, end )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8254, + "column": 1, + "source_line": "#define STBIR_strs_join1( start, mid, end ) STBIR_strs_join2( start, mid, end )" + } + }, + { + "name": "STBIR_strs_join24", + "value": "start##mid1##mid2##end", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8256, + "column": 1, + "source_line": "#define STBIR_strs_join24( start, mid1, mid2, end ) start##mid1##mid2##end" + } + }, + { + "name": "STBIR_strs_join14", + "value": "STBIR_strs_join24( start, mid1, mid2, end )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8257, + "column": 1, + "source_line": "#define STBIR_strs_join14( start, mid1, mid2, end ) STBIR_strs_join24( start, mid1, mid2, end )" + } + }, + { + "name": "STBIR__CODER_NAME", + "value": "STBIR_strs_join1( name, _, stbir__decode_suffix )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8262, + "column": 1, + "source_line": "#define STBIR__CODER_NAME( name ) STBIR_strs_join1( name, _, stbir__decode_suffix )" + } + }, + { + "name": "STBIR__CODER_NAME", + "value": "name", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8264, + "column": 1, + "source_line": "#define STBIR__CODER_NAME( name ) name" + } + }, + { + "name": "stbir__decode_simdf8_flip", + "value": "STBIR_strs_join1( STBIR_strs_join1( STBIR_strs_join1( STBIR_strs_join1( stbir__simdf8_0123to,stbir__decode_order0,stbir__decode_order1),stbir__decode_order2,stbir__decode_order3),stbir__decode_order0,stbir__decode_order1),stbir__decode_order2,stbir__decode_order3)(reg, reg)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8268, + "column": 1, + "source_line": "#define stbir__decode_simdf8_flip(reg) STBIR_strs_join1( STBIR_strs_join1( STBIR_strs_join1( STBIR_strs_join1( stbir__simdf8_0123to,stbir__decode_order0,stbir__decode_order1),stbir__decode_order2,stbir__decode_order3),stbir__decode_order0,stbir__decode_order1),stbir__decode_order2,stbir__decode_order3)(reg, reg)" + } + }, + { + "name": "stbir__decode_simdf4_flip", + "value": "STBIR_strs_join1( STBIR_strs_join1( stbir__simdf_0123to,stbir__decode_order0,stbir__decode_order1),stbir__decode_order2,stbir__decode_order3)(reg, reg)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8269, + "column": 1, + "source_line": "#define stbir__decode_simdf4_flip(reg) STBIR_strs_join1( STBIR_strs_join1( stbir__simdf_0123to,stbir__decode_order0,stbir__decode_order1),stbir__decode_order2,stbir__decode_order3)(reg, reg)" + } + }, + { + "name": "stbir__encode_simdf8_unflip", + "value": "STBIR_strs_join1( STBIR_strs_join1( STBIR_strs_join1( STBIR_strs_join1( stbir__simdf8_0123to,stbir__encode_order0,stbir__encode_order1),stbir__encode_order2,stbir__encode_order3),stbir__encode_order0,stbir__encode_order1),stbir__encode_order2,stbir__encode_order3)(reg, reg)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8270, + "column": 1, + "source_line": "#define stbir__encode_simdf8_unflip(reg) STBIR_strs_join1( STBIR_strs_join1( STBIR_strs_join1( STBIR_strs_join1( stbir__simdf8_0123to,stbir__encode_order0,stbir__encode_order1),stbir__encode_order2,stbir__encode_order3),stbir__encode_order0,stbir__encode_order1),stbir__encode_order2,stbir__encode_order3)(reg, reg)" + } + }, + { + "name": "stbir__encode_simdf4_unflip", + "value": "STBIR_strs_join1( STBIR_strs_join1( stbir__simdf_0123to,stbir__encode_order0,stbir__encode_order1),stbir__encode_order2,stbir__encode_order3)(reg, reg)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8271, + "column": 1, + "source_line": "#define stbir__encode_simdf4_unflip(reg) STBIR_strs_join1( STBIR_strs_join1( stbir__simdf_0123to,stbir__encode_order0,stbir__encode_order1),stbir__encode_order2,stbir__encode_order3)(reg, reg)" + } + }, + { + "name": "stbir__decode_order0", + "value": "0", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8273, + "column": 1, + "source_line": "#define stbir__decode_order0 0" + } + }, + { + "name": "stbir__decode_order1", + "value": "1", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8274, + "column": 1, + "source_line": "#define stbir__decode_order1 1" + } + }, + { + "name": "stbir__decode_order2", + "value": "2", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8275, + "column": 1, + "source_line": "#define stbir__decode_order2 2" + } + }, + { + "name": "stbir__decode_order3", + "value": "3", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8276, + "column": 1, + "source_line": "#define stbir__decode_order3 3" + } + }, + { + "name": "stbir__encode_order0", + "value": "0", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8277, + "column": 1, + "source_line": "#define stbir__encode_order0 0" + } + }, + { + "name": "stbir__encode_order1", + "value": "1", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8278, + "column": 1, + "source_line": "#define stbir__encode_order1 1" + } + }, + { + "name": "stbir__encode_order2", + "value": "2", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8279, + "column": 1, + "source_line": "#define stbir__encode_order2 2" + } + }, + { + "name": "stbir__encode_order3", + "value": "3", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8280, + "column": 1, + "source_line": "#define stbir__encode_order3 3" + } + }, + { + "name": "stbir__decode_simdf8_flip", + "value": null, + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8281, + "column": 1, + "source_line": "#define stbir__decode_simdf8_flip(reg)" + } + }, + { + "name": "stbir__decode_simdf4_flip", + "value": null, + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8282, + "column": 1, + "source_line": "#define stbir__decode_simdf4_flip(reg)" + } + }, + { + "name": "stbir__encode_simdf8_unflip", + "value": null, + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8283, + "column": 1, + "source_line": "#define stbir__encode_simdf8_unflip(reg)" + } + }, + { + "name": "stbir__encode_simdf4_unflip", + "value": null, + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8284, + "column": 1, + "source_line": "#define stbir__encode_simdf4_unflip(reg)" + } + }, + { + "name": "stbir__encode_simdfX_unflip", + "value": "stbir__encode_simdf8_unflip", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8288, + "column": 1, + "source_line": "#define stbir__encode_simdfX_unflip stbir__encode_simdf8_unflip" + } + }, + { + "name": "stbir__encode_simdfX_unflip", + "value": "stbir__encode_simdf4_unflip", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8290, + "column": 1, + "source_line": "#define stbir__encode_simdfX_unflip stbir__encode_simdf4_unflip" + } + }, + { + "name": "stbir__min_max_shift20", + "value": "stbir__simdf_max( f, f, stbir_simdf_casti(STBIR__CONSTI( STBIR_almost_zero )) ); stbir__simdf_min( f, f, stbir_simdf_casti(STBIR__CONSTI( STBIR_almost_one )) ); stbir__simdi_32shr( i, stbir_simdi_castf( f ), 20 );", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8747, + "column": 1, + "source_line": "#define stbir__min_max_shift20( i, f ) \\" + } + }, + { + "name": "stbir__scale_and_convert", + "value": "stbir__simdf_madd( f, STBIR__CONSTF( STBIR_simd_point5 ), STBIR__CONSTF( STBIR_max_uint8_as_float ), f ); stbir__simdf_max( f, f, stbir__simdf_zeroP() ); stbir__simdf_min( f, f, STBIR__CONSTF( STBIR_max_uint8_as_float ) ); stbir__simdf_convert_float_to_i32( i, f );", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8752, + "column": 1, + "source_line": "#define stbir__scale_and_convert( i, f ) \\" + } + }, + { + "name": "stbir__linear_to_srgb_finish", + "value": "{ stbir__simdi temp; stbir__simdi_32shr( temp, stbir_simdi_castf( f ), 12 ) ; stbir__simdi_and( temp, temp, STBIR__CONSTI(STBIR_mantissa_mask) ); stbir__simdi_or( temp, temp, STBIR__CONSTI(STBIR_topscale) ); stbir__simdi_16madd( i, i, temp ); stbir__simdi_32shr( i, i, 16 ); }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8758, + "column": 1, + "source_line": "#define stbir__linear_to_srgb_finish( i, f ) \\" + } + }, + { + "name": "stbir__simdi_table_lookup2", + "value": "{ stbir__simdi_u32 temp0,temp1; temp0.m128i_i128 = v0; temp1.m128i_i128 = v1; temp0.m128i_u32[0] = table[temp0.m128i_i32[0]]; temp0.m128i_u32[1] = table[temp0.m128i_i32[1]]; temp0.m128i_u32[2] = table[temp0.m128i_i32[2]]; temp0.m128i_u32[3] = table[temp0.m128i_i32[3]]; temp1.m128i_u32[0] = table[temp1.m128i_i32[0]]; temp1.m128i_u32[1] = table[temp1.m128i_i32[1]]; temp1.m128i_u32[2] = table[temp1.m128i_i32[2]]; temp1.m128i_u32[3] = table[temp1.m128i_i32[3]]; v0 = temp0.m128i_i128; v1 = temp1.m128i_i128; }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8768, + "column": 1, + "source_line": "#define stbir__simdi_table_lookup2( v0,v1, table ) \\" + } + }, + { + "name": "stbir__simdi_table_lookup3", + "value": "{ stbir__simdi_u32 temp0,temp1,temp2; temp0.m128i_i128 = v0; temp1.m128i_i128 = v1; temp2.m128i_i128 = v2; temp0.m128i_u32[0] = table[temp0.m128i_i32[0]]; temp0.m128i_u32[1] = table[temp0.m128i_i32[1]]; temp0.m128i_u32[2] = table[temp0.m128i_i32[2]]; temp0.m128i_u32[3] = table[temp0.m128i_i32[3]]; temp1.m128i_u32[0] = table[temp1.m128i_i32[0]]; temp1.m128i_u32[1] = table[temp1.m128i_i32[1]]; temp1.m128i_u32[2] = table[temp1.m128i_i32[2]]; temp1.m128i_u32[3] = table[temp1.m128i_i32[3]]; temp2.m128i_u32[0] = table[temp2.m128i_i32[0]]; temp2.m128i_u32[1] = table[temp2.m128i_i32[1]]; temp2.m128i_u32[2] = table[temp2.m128i_i32[2]]; temp2.m128i_u32[3] = table[temp2.m128i_i32[3]]; v0 = temp0.m128i_i128; v1 = temp1.m128i_i128; v2 = temp2.m128i_i128; }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8779, + "column": 1, + "source_line": "#define stbir__simdi_table_lookup3( v0,v1,v2, table ) \\" + } + }, + { + "name": "stbir__simdi_table_lookup4", + "value": "{ stbir__simdi_u32 temp0,temp1,temp2,temp3; temp0.m128i_i128 = v0; temp1.m128i_i128 = v1; temp2.m128i_i128 = v2; temp3.m128i_i128 = v3; temp0.m128i_u32[0] = table[temp0.m128i_i32[0]]; temp0.m128i_u32[1] = table[temp0.m128i_i32[1]]; temp0.m128i_u32[2] = table[temp0.m128i_i32[2]]; temp0.m128i_u32[3] = table[temp0.m128i_i32[3]]; temp1.m128i_u32[0] = table[temp1.m128i_i32[0]]; temp1.m128i_u32[1] = table[temp1.m128i_i32[1]]; temp1.m128i_u32[2] = table[temp1.m128i_i32[2]]; temp1.m128i_u32[3] = table[temp1.m128i_i32[3]]; temp2.m128i_u32[0] = table[temp2.m128i_i32[0]]; temp2.m128i_u32[1] = table[temp2.m128i_i32[1]]; temp2.m128i_u32[2] = table[temp2.m128i_i32[2]]; temp2.m128i_u32[3] = table[temp2.m128i_i32[3]]; temp3.m128i_u32[0] = table[temp3.m128i_i32[0]]; temp3.m128i_u32[1] = table[temp3.m128i_i32[1]]; temp3.m128i_u32[2] = table[temp3.m128i_i32[2]]; temp3.m128i_u32[3] = table[temp3.m128i_i32[3]]; v0 = temp0.m128i_i128; v1 = temp1.m128i_i128; v2 = temp2.m128i_i128; v3 = temp3.m128i_i128; }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8793, + "column": 1, + "source_line": "#define stbir__simdi_table_lookup4( v0,v1,v2,v3, table ) \\" + } + }, + { + "name": "stbir_scalar_hi_clamp", + "value": "if ( v > STBIR_FLOAT_HIGH_CLAMP ) v = STBIR_FLOAT_HIGH_CLAMP;", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9750, + "column": 3, + "source_line": " #define stbir_scalar_hi_clamp( v ) if ( v > STBIR_FLOAT_HIGH_CLAMP ) v = STBIR_FLOAT_HIGH_CLAMP;" + } + }, + { + "name": "stbir_scalar_hi_clamp", + "value": null, + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9752, + "column": 3, + "source_line": " #define stbir_scalar_hi_clamp( v )" + } + }, + { + "name": "stbir_scalar_lo_clamp", + "value": "if ( v < STBIR_FLOAT_LOW_CLAMP ) v = STBIR_FLOAT_LOW_CLAMP;", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9755, + "column": 3, + "source_line": " #define stbir_scalar_lo_clamp( v ) if ( v < STBIR_FLOAT_LOW_CLAMP ) v = STBIR_FLOAT_LOW_CLAMP;" + } + }, + { + "name": "stbir_scalar_lo_clamp", + "value": null, + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9757, + "column": 3, + "source_line": " #define stbir_scalar_lo_clamp( v )" + } + }, + { + "name": "stbir__decode_suffix", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9872, + "column": 1, + "source_line": "#undef stbir__decode_suffix" + } + }, + { + "name": "stbir__decode_simdf8_flip", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9873, + "column": 1, + "source_line": "#undef stbir__decode_simdf8_flip" + } + }, + { + "name": "stbir__decode_simdf4_flip", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9874, + "column": 1, + "source_line": "#undef stbir__decode_simdf4_flip" + } + }, + { + "name": "stbir__decode_order0", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9875, + "column": 1, + "source_line": "#undef stbir__decode_order0" + } + }, + { + "name": "stbir__decode_order1", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9876, + "column": 1, + "source_line": "#undef stbir__decode_order1" + } + }, + { + "name": "stbir__decode_order2", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9877, + "column": 1, + "source_line": "#undef stbir__decode_order2" + } + }, + { + "name": "stbir__decode_order3", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9878, + "column": 1, + "source_line": "#undef stbir__decode_order3" + } + }, + { + "name": "stbir__encode_order0", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9879, + "column": 1, + "source_line": "#undef stbir__encode_order0" + } + }, + { + "name": "stbir__encode_order1", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9880, + "column": 1, + "source_line": "#undef stbir__encode_order1" + } + }, + { + "name": "stbir__encode_order2", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9881, + "column": 1, + "source_line": "#undef stbir__encode_order2" + } + }, + { + "name": "stbir__encode_order3", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9882, + "column": 1, + "source_line": "#undef stbir__encode_order3" + } + }, + { + "name": "stbir__encode_simdf8_unflip", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9883, + "column": 1, + "source_line": "#undef stbir__encode_simdf8_unflip" + } + }, + { + "name": "stbir__encode_simdf4_unflip", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9884, + "column": 1, + "source_line": "#undef stbir__encode_simdf4_unflip" + } + }, + { + "name": "stbir__encode_simdfX_unflip", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9885, + "column": 1, + "source_line": "#undef stbir__encode_simdfX_unflip" + } + }, + { + "name": "STBIR__CODER_NAME", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9886, + "column": 1, + "source_line": "#undef STBIR__CODER_NAME" + } + }, + { + "name": "stbir__coder_min_num", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9887, + "column": 1, + "source_line": "#undef stbir__coder_min_num" + } + }, + { + "name": "stbir__decode_swizzle", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9888, + "column": 1, + "source_line": "#undef stbir__decode_swizzle" + } + }, + { + "name": "stbir_scalar_hi_clamp", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9889, + "column": 1, + "source_line": "#undef stbir_scalar_hi_clamp" + } + }, + { + "name": "stbir_scalar_lo_clamp", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9890, + "column": 1, + "source_line": "#undef stbir_scalar_lo_clamp" + } + }, + { + "name": "STB_IMAGE_RESIZE_DO_CODERS", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9891, + "column": 1, + "source_line": "#undef STB_IMAGE_RESIZE_DO_CODERS" + } + }, + { + "name": "STBIR_chans", + "value": "STBIR_strs_join14(start,STBIR__vertical_channels,end,_cont)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9896, + "column": 1, + "source_line": "#define STBIR_chans( start, end ) STBIR_strs_join14(start,STBIR__vertical_channels,end,_cont)" + } + }, + { + "name": "STBIR_chans", + "value": "STBIR_strs_join1(start,STBIR__vertical_channels,end)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9898, + "column": 1, + "source_line": "#define STBIR_chans( start, end ) STBIR_strs_join1(start,STBIR__vertical_channels,end)" + } + }, + { + "name": "stbIF0", + "value": "code", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9902, + "column": 1, + "source_line": "#define stbIF0( code ) code" + } + }, + { + "name": "stbIF0", + "value": null, + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9904, + "column": 1, + "source_line": "#define stbIF0( code )" + } + }, + { + "name": "stbIF1", + "value": "code", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9907, + "column": 1, + "source_line": "#define stbIF1( code ) code" + } + }, + { + "name": "stbIF1", + "value": null, + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9909, + "column": 1, + "source_line": "#define stbIF1( code )" + } + }, + { + "name": "stbIF2", + "value": "code", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9912, + "column": 1, + "source_line": "#define stbIF2( code ) code" + } + }, + { + "name": "stbIF2", + "value": null, + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9914, + "column": 1, + "source_line": "#define stbIF2( code )" + } + }, + { + "name": "stbIF3", + "value": "code", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9917, + "column": 1, + "source_line": "#define stbIF3( code ) code" + } + }, + { + "name": "stbIF3", + "value": null, + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9919, + "column": 1, + "source_line": "#define stbIF3( code )" + } + }, + { + "name": "stbIF4", + "value": "code", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9922, + "column": 1, + "source_line": "#define stbIF4( code ) code" + } + }, + { + "name": "stbIF4", + "value": null, + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9924, + "column": 1, + "source_line": "#define stbIF4( code )" + } + }, + { + "name": "stbIF5", + "value": "code", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9927, + "column": 1, + "source_line": "#define stbIF5( code ) code" + } + }, + { + "name": "stbIF5", + "value": null, + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9929, + "column": 1, + "source_line": "#define stbIF5( code )" + } + }, + { + "name": "stbIF6", + "value": "code", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9932, + "column": 1, + "source_line": "#define stbIF6( code ) code" + } + }, + { + "name": "stbIF6", + "value": null, + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9934, + "column": 1, + "source_line": "#define stbIF6( code )" + } + }, + { + "name": "stbIF7", + "value": "code", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9937, + "column": 1, + "source_line": "#define stbIF7( code ) code" + } + }, + { + "name": "stbIF7", + "value": null, + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9939, + "column": 1, + "source_line": "#define stbIF7( code )" + } + }, + { + "name": "stbIF0", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10262, + "column": 1, + "source_line": "#undef stbIF0" + } + }, + { + "name": "stbIF1", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10263, + "column": 1, + "source_line": "#undef stbIF1" + } + }, + { + "name": "stbIF2", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10264, + "column": 1, + "source_line": "#undef stbIF2" + } + }, + { + "name": "stbIF3", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10265, + "column": 1, + "source_line": "#undef stbIF3" + } + }, + { + "name": "stbIF4", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10266, + "column": 1, + "source_line": "#undef stbIF4" + } + }, + { + "name": "stbIF5", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10267, + "column": 1, + "source_line": "#undef stbIF5" + } + }, + { + "name": "stbIF6", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10268, + "column": 1, + "source_line": "#undef stbIF6" + } + }, + { + "name": "stbIF7", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10269, + "column": 1, + "source_line": "#undef stbIF7" + } + }, + { + "name": "STB_IMAGE_RESIZE_DO_VERTICALS", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10270, + "column": 1, + "source_line": "#undef STB_IMAGE_RESIZE_DO_VERTICALS" + } + }, + { + "name": "STBIR__vertical_channels", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10271, + "column": 1, + "source_line": "#undef STBIR__vertical_channels" + } + }, + { + "name": "STB_IMAGE_RESIZE_DO_HORIZONTALS", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10272, + "column": 1, + "source_line": "#undef STB_IMAGE_RESIZE_DO_HORIZONTALS" + } + }, + { + "name": "STBIR_strs_join24", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10273, + "column": 1, + "source_line": "#undef STBIR_strs_join24" + } + }, + { + "name": "STBIR_strs_join14", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10274, + "column": 1, + "source_line": "#undef STBIR_strs_join14" + } + }, + { + "name": "STBIR_chans", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10275, + "column": 1, + "source_line": "#undef STBIR_chans" + } + }, + { + "name": "STB_IMAGE_RESIZE_VERTICAL_CONTINUE", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10277, + "column": 1, + "source_line": "#undef STB_IMAGE_RESIZE_VERTICAL_CONTINUE" + } + }, + { + "name": "STBIR_chans", + "value": "STBIR_strs_join1(start,STBIR__horizontal_channels,end)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10282, + "column": 1, + "source_line": "#define STBIR_chans( start, end ) STBIR_strs_join1(start,STBIR__horizontal_channels,end)" + } + }, + { + "name": "stbir__2_coeff_only", + "value": "stbir__1_coeff_only(); stbir__1_coeff_remnant(1);", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10285, + "column": 1, + "source_line": "#define stbir__2_coeff_only() \\" + } + }, + { + "name": "stbir__2_coeff_remnant", + "value": "stbir__1_coeff_remnant(ofs); stbir__1_coeff_remnant((ofs)+1);", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10291, + "column": 1, + "source_line": "#define stbir__2_coeff_remnant( ofs ) \\" + } + }, + { + "name": "stbir__3_coeff_only", + "value": "stbir__2_coeff_only(); stbir__1_coeff_remnant(2);", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10297, + "column": 1, + "source_line": "#define stbir__3_coeff_only() \\" + } + }, + { + "name": "stbir__3_coeff_remnant", + "value": "stbir__2_coeff_remnant(ofs); stbir__1_coeff_remnant((ofs)+2);", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10303, + "column": 1, + "source_line": "#define stbir__3_coeff_remnant( ofs ) \\" + } + }, + { + "name": "stbir__3_coeff_setup", + "value": null, + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10309, + "column": 1, + "source_line": "#define stbir__3_coeff_setup()" + } + }, + { + "name": "stbir__4_coeff_start", + "value": "stbir__2_coeff_only(); stbir__2_coeff_remnant(2);", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10313, + "column": 1, + "source_line": "#define stbir__4_coeff_start() \\" + } + }, + { + "name": "stbir__4_coeff_continue_from_4", + "value": "stbir__2_coeff_remnant(ofs); stbir__2_coeff_remnant((ofs)+2);", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10319, + "column": 1, + "source_line": "#define stbir__4_coeff_continue_from_4( ofs ) \\" + } + }, + { + "name": "stbir__store_output_tiny", + "value": "stbir__store_output", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10325, + "column": 1, + "source_line": "#define stbir__store_output_tiny stbir__store_output" + } + }, + { + "name": "STBIR__horizontal_channels", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10617, + "column": 1, + "source_line": "#undef STBIR__horizontal_channels" + } + }, + { + "name": "STB_IMAGE_RESIZE_DO_HORIZONTALS", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10618, + "column": 1, + "source_line": "#undef STB_IMAGE_RESIZE_DO_HORIZONTALS" + } + }, + { + "name": "stbir__1_coeff_only", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10619, + "column": 1, + "source_line": "#undef stbir__1_coeff_only" + } + }, + { + "name": "stbir__1_coeff_remnant", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10620, + "column": 1, + "source_line": "#undef stbir__1_coeff_remnant" + } + }, + { + "name": "stbir__2_coeff_only", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10621, + "column": 1, + "source_line": "#undef stbir__2_coeff_only" + } + }, + { + "name": "stbir__2_coeff_remnant", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10622, + "column": 1, + "source_line": "#undef stbir__2_coeff_remnant" + } + }, + { + "name": "stbir__3_coeff_only", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10623, + "column": 1, + "source_line": "#undef stbir__3_coeff_only" + } + }, + { + "name": "stbir__3_coeff_remnant", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10624, + "column": 1, + "source_line": "#undef stbir__3_coeff_remnant" + } + }, + { + "name": "stbir__3_coeff_setup", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10625, + "column": 1, + "source_line": "#undef stbir__3_coeff_setup" + } + }, + { + "name": "stbir__4_coeff_start", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10626, + "column": 1, + "source_line": "#undef stbir__4_coeff_start" + } + }, + { + "name": "stbir__4_coeff_continue_from_4", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10627, + "column": 1, + "source_line": "#undef stbir__4_coeff_continue_from_4" + } + }, + { + "name": "stbir__store_output", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10628, + "column": 1, + "source_line": "#undef stbir__store_output" + } + }, + { + "name": "stbir__store_output_tiny", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10629, + "column": 1, + "source_line": "#undef stbir__store_output_tiny" + } + }, + { + "name": "STBIR_chans", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10630, + "column": 1, + "source_line": "#undef STBIR_chans" + } + }, + { + "name": "STBIR_strs_join2", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10634, + "column": 1, + "source_line": "#undef STBIR_strs_join2" + } + }, + { + "name": "STBIR_strs_join1", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10635, + "column": 1, + "source_line": "#undef STBIR_strs_join1" + } + } + ], + "includes": [ + { + "target": "stddef.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 391, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "stdint.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 398, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "assert.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 786, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "stdlib.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 791, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "emmintrin.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1306, + "column": 3, + "source_line": " #include " + } + }, + { + "target": "immintrin.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1379, + "column": 3, + "source_line": " #include " + } + }, + { + "target": "smmintrin.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1478, + "column": 5, + "source_line": " #include " + } + }, + { + "target": "immintrin.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1501, + "column": 5, + "source_line": " #include " + } + }, + { + "target": "arm_neon.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1711, + "column": 3, + "source_line": " #include " + } + }, + { + "target": "wasm_simd128.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1976, + "column": 3, + "source_line": " #include " + } + }, + { + "target": "immintrin.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2299, + "column": 3, + "source_line": " #include " + } + }, + { + "target": "math.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2819, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "string.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2831, + "column": 1, + "source_line": "#include " + } + } + ], + "raw_directives": [ + { + "directive": "if", + "argument": "!defined(STB_IMAGE_RESIZE_DO_HORIZONTALS) && !defined(STB_IMAGE_RESIZE_DO_VERTICALS) && !defined(STB_IMAGE_RESIZE_DO_CODERS)", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 386, + "column": 1, + "source_line": "#if !defined(STB_IMAGE_RESIZE_DO_HORIZONTALS) && !defined(STB_IMAGE_RESIZE_DO_VERTICALS) && !defined(STB_IMAGE_RESIZE_DO_CODERS) // for internal re-includes" + } + }, + { + "directive": "ifndef", + "argument": "STBIR_INCLUDE_STB_IMAGE_RESIZE2_H", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 388, + "column": 1, + "source_line": "#ifndef STBIR_INCLUDE_STB_IMAGE_RESIZE2_H" + } + }, + { + "directive": "ifdef", + "argument": "_MSC_VER", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 392, + "column": 1, + "source_line": "#ifdef _MSC_VER" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 397, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 403, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBIRDEF", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 405, + "column": 1, + "source_line": "#ifndef STBIRDEF" + } + }, + { + "directive": "ifdef", + "argument": "STB_IMAGE_RESIZE_STATIC", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 406, + "column": 1, + "source_line": "#ifdef STB_IMAGE_RESIZE_STATIC" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 408, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "ifdef", + "argument": "__cplusplus", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 409, + "column": 1, + "source_line": "#ifdef __cplusplus" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 411, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 413, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 414, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 415, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_PROFILE", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 751, + "column": 1, + "source_line": "#ifdef STBIR_PROFILE" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 777, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 781, + "column": 1, + "source_line": "#endif // STBIR_INCLUDE_STB_IMAGE_RESIZE2_H" + } + }, + { + "directive": "if", + "argument": "defined(STB_IMAGE_RESIZE_IMPLEMENTATION) || defined(STB_IMAGE_RESIZE2_IMPLEMENTATION)", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 783, + "column": 1, + "source_line": "#if defined(STB_IMAGE_RESIZE_IMPLEMENTATION) || defined(STB_IMAGE_RESIZE2_IMPLEMENTATION)" + } + }, + { + "directive": "ifndef", + "argument": "STBIR_ASSERT", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 785, + "column": 1, + "source_line": "#ifndef STBIR_ASSERT" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 788, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBIR_MALLOC", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 790, + "column": 1, + "source_line": "#ifndef STBIR_MALLOC" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 795, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "_MSC_VER", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 797, + "column": 1, + "source_line": "#ifdef _MSC_VER" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 801, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "if", + "argument": "defined(__has_feature)", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 806, + "column": 1, + "source_line": "#if defined(__has_feature)" + } + }, + { + "directive": "if", + "argument": "__has_feature(address_sanitizer) || __has_feature(memory_sanitizer)", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 807, + "column": 3, + "source_line": " #if __has_feature(address_sanitizer) || __has_feature(memory_sanitizer)" + } + }, + { + "directive": "ifndef", + "argument": "STBIR__SEPARATE_ALLOCATIONS", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 808, + "column": 5, + "source_line": " #ifndef STBIR__SEPARATE_ALLOCATIONS" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 810, + "column": 5, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 811, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 812, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 814, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "defined(__SANITIZE_ADDRESS__)", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 817, + "column": 1, + "source_line": "#if defined(__SANITIZE_ADDRESS__)" + } + }, + { + "directive": "ifndef", + "argument": "STBIR__SEPARATE_ALLOCATIONS", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 818, + "column": 3, + "source_line": " #ifndef STBIR__SEPARATE_ALLOCATIONS" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 820, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 821, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBIR_DONT_CHANGE_FP_CONTRACT", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 825, + "column": 1, + "source_line": "#ifndef STBIR_DONT_CHANGE_FP_CONTRACT // override in case you don't want this behavior" + } + }, + { + "directive": "if", + "argument": "defined(_MSC_VER) && !defined(__clang__)", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 826, + "column": 1, + "source_line": "#if defined(_MSC_VER) && !defined(__clang__)" + } + }, + { + "directive": "if", + "argument": "_MSC_VER > 1200", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 827, + "column": 1, + "source_line": "#if _MSC_VER > 1200" + } + }, + { + "directive": "pragma", + "argument": "fp_contract(off)", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 828, + "column": 1, + "source_line": "#pragma fp_contract(off)" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 829, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "elif", + "argument": "defined(__GNUC__) && !defined(__clang__)", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 830, + "column": 1, + "source_line": "#elif defined(__GNUC__) && !defined(__clang__)" + } + }, + { + "directive": "pragma", + "argument": "GCC optimize(\"fp-contract=off\")", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 831, + "column": 1, + "source_line": "#pragma GCC optimize(\"fp-contract=off\")" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 832, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "pragma", + "argument": "STDC FP_CONTRACT OFF", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 833, + "column": 1, + "source_line": "#pragma STDC FP_CONTRACT OFF" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 834, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 835, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "_MSC_VER", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 837, + "column": 1, + "source_line": "#ifdef _MSC_VER" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 839, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 841, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBIR_DEFAULT_FILTER_UPSAMPLE", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 846, + "column": 1, + "source_line": "#ifndef STBIR_DEFAULT_FILTER_UPSAMPLE" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 848, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBIR_DEFAULT_FILTER_DOWNSAMPLE", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 850, + "column": 1, + "source_line": "#ifndef STBIR_DEFAULT_FILTER_DOWNSAMPLE" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 852, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBIR__HEADER_FILENAME", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 855, + "column": 1, + "source_line": "#ifndef STBIR__HEADER_FILENAME" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 857, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_PROFILE", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 976, + "column": 1, + "source_line": "#ifdef STBIR_PROFILE" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 983, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBIR__SEPARATE_ALLOCATIONS", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 992, + "column": 3, + "source_line": " #ifdef STBIR__SEPARATE_ALLOCATIONS" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 994, + "column": 3, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 996, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_PROFILE", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1012, + "column": 1, + "source_line": "#ifdef STBIR_PROFILE" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1019, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBIR_FORCE_GATHER_FILTER_SCANLINES_AMOUNT", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1164, + "column": 1, + "source_line": "#ifndef STBIR_FORCE_GATHER_FILTER_SCANLINES_AMOUNT" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1166, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBIR_FORCE_MINIMUM_SCANLINES_FOR_SPLITS", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1168, + "column": 1, + "source_line": "#ifndef STBIR_FORCE_MINIMUM_SCANLINES_FOR_SPLITS" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1170, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "_M_IX86_FP", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1174, + "column": 1, + "source_line": "#ifdef _M_IX86_FP" + } + }, + { + "directive": "if", + "argument": "( _M_IX86_FP >= 1 )", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1175, + "column": 1, + "source_line": "#if ( _M_IX86_FP >= 1 )" + } + }, + { + "directive": "ifndef", + "argument": "STBIR_SSE", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1176, + "column": 1, + "source_line": "#ifndef STBIR_SSE" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1178, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1179, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1180, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "__TINYC__", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1182, + "column": 1, + "source_line": "#ifdef __TINYC__" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1185, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "defined(_x86_64) || defined( __x86_64__ ) || defined( _M_X64 ) || defined(__x86_64) || defined(_M_AMD64) || defined(__SSE2__) || defined(STBIR_SSE) || defined(STBIR_SSE2)", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1187, + "column": 1, + "source_line": "#if defined(_x86_64) || defined( __x86_64__ ) || defined( _M_X64 ) || defined(__x86_64) || defined(_M_AMD64) || defined(__SSE2__) || defined(STBIR_SSE) || defined(STBIR_SSE2)" + } + }, + { + "directive": "ifndef", + "argument": "STBIR_SSE2", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1188, + "column": 3, + "source_line": " #ifndef STBIR_SSE2" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1190, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "defined(__AVX__) || defined(STBIR_AVX2)", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1191, + "column": 3, + "source_line": " #if defined(__AVX__) || defined(STBIR_AVX2)" + } + }, + { + "directive": "ifndef", + "argument": "STBIR_AVX", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1192, + "column": 5, + "source_line": " #ifndef STBIR_AVX" + } + }, + { + "directive": "ifndef", + "argument": "STBIR_NO_AVX", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1193, + "column": 7, + "source_line": " #ifndef STBIR_NO_AVX" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1195, + "column": 7, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1196, + "column": 5, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1197, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "defined(__AVX2__) || defined(STBIR_AVX2)", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1198, + "column": 3, + "source_line": " #if defined(__AVX2__) || defined(STBIR_AVX2)" + } + }, + { + "directive": "ifndef", + "argument": "STBIR_NO_AVX2", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1199, + "column": 5, + "source_line": " #ifndef STBIR_NO_AVX2" + } + }, + { + "directive": "ifndef", + "argument": "STBIR_AVX2", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1200, + "column": 7, + "source_line": " #ifndef STBIR_AVX2" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1202, + "column": 7, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "defined( _MSC_VER ) && !defined(__clang__)", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1203, + "column": 7, + "source_line": " #if defined( _MSC_VER ) && !defined(__clang__)" + } + }, + { + "directive": "ifndef", + "argument": "STBIR_FP16C", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1204, + "column": 9, + "source_line": " #ifndef STBIR_FP16C // FP16C instructions are on all AVX2 cpus, so we can autoselect it here on microsoft - clang needs -mf16c" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1206, + "column": 9, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1207, + "column": 7, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1208, + "column": 5, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1209, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "__F16C__", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1210, + "column": 3, + "source_line": " #ifdef __F16C__" + } + }, + { + "directive": "ifndef", + "argument": "STBIR_FP16C", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1211, + "column": 5, + "source_line": " #ifndef STBIR_FP16C // turn on FP16C instructions if the define is set (for clang and gcc)" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1213, + "column": 5, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1214, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1215, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "defined( _M_ARM64 ) || defined( __aarch64__ ) || defined( __arm64__ ) || ((__ARM_NEON_FP & 4) != 0) || defined(__ARM_NEON__)", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1217, + "column": 1, + "source_line": "#if defined( _M_ARM64 ) || defined( __aarch64__ ) || defined( __arm64__ ) || ((__ARM_NEON_FP & 4) != 0) || defined(__ARM_NEON__)" + } + }, + { + "directive": "ifndef", + "argument": "STBIR_NEON", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1218, + "column": 1, + "source_line": "#ifndef STBIR_NEON" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1220, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1221, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "defined(_M_ARM) || defined(__arm__)", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1223, + "column": 1, + "source_line": "#if defined(_M_ARM) || defined(__arm__)" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_USE_FMA", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1224, + "column": 1, + "source_line": "#ifdef STBIR_USE_FMA" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1226, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1227, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "defined(__wasm__) && defined(__wasm_simd128__)", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1229, + "column": 1, + "source_line": "#if defined(__wasm__) && defined(__wasm_simd128__)" + } + }, + { + "directive": "ifndef", + "argument": "STBIR_WASM", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1230, + "column": 1, + "source_line": "#ifndef STBIR_WASM" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1232, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1233, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "defined( _MSC_VER ) && !defined(__clang__)", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1236, + "column": 1, + "source_line": "#if defined( _MSC_VER ) && !defined(__clang__)" + } + }, + { + "directive": "if", + "argument": "_MSC_VER >= 1900", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1239, + "column": 3, + "source_line": " #if _MSC_VER >= 1900" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1241, + "column": 3, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1243, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "elif", + "argument": "defined( __clang__ )", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1244, + "column": 1, + "source_line": "#elif defined( __clang__ )" + } + }, + { + "directive": "if", + "argument": "( __clang_major__ >= 4 ) || ( ( __clang_major__ >= 3 ) && ( __clang_minor__ >= 5 ) )", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1247, + "column": 3, + "source_line": " #if ( __clang_major__ >= 4 ) || ( ( __clang_major__ >= 3 ) && ( __clang_minor__ >= 5 ) )" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1249, + "column": 3, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1251, + "column": 3, + "source_line": " #endif " + } + }, + { + "directive": "elif", + "argument": "defined( __GNUC__ )", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1252, + "column": 1, + "source_line": "#elif defined( __GNUC__ )" + } + }, + { + "directive": "if", + "argument": "__GNUC__ >= 14", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1255, + "column": 3, + "source_line": " #if __GNUC__ >= 14" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1257, + "column": 3, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1259, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1261, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1265, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBIR_NO_UNROLL_LOOP_START_INF_FOR", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1267, + "column": 1, + "source_line": "#ifndef STBIR_NO_UNROLL_LOOP_START_INF_FOR" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1269, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_NO_SIMD", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1271, + "column": 1, + "source_line": "#ifdef STBIR_NO_SIMD // force simd off for whatever reason" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_SSE2", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1275, + "column": 1, + "source_line": "#ifdef STBIR_SSE2" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1277, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_AVX", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1279, + "column": 1, + "source_line": "#ifdef STBIR_AVX" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1281, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_NEON", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1283, + "column": 1, + "source_line": "#ifdef STBIR_NEON" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1285, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_AVX2", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1287, + "column": 1, + "source_line": "#ifdef STBIR_AVX2" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1289, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_FP16C", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1291, + "column": 1, + "source_line": "#ifdef STBIR_FP16C" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1293, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_WASM", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1295, + "column": 1, + "source_line": "#ifdef STBIR_WASM" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1297, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_SIMD", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1299, + "column": 1, + "source_line": "#ifdef STBIR_SIMD" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1301, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1303, + "column": 1, + "source_line": "#else // STBIR_SIMD" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_SSE2", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1305, + "column": 1, + "source_line": "#ifdef STBIR_SSE2" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_USE_FMA", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1378, + "column": 3, + "source_line": " #ifdef STBIR_USE_FMA // not on by default to maintain bit identical simd to non-simd" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1384, + "column": 3, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1389, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "defined(_MSC_VER) && !defined(__clang__)", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1461, + "column": 3, + "source_line": " #if defined(_MSC_VER) && !defined(__clang__)" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1466, + "column": 3, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1470, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "defined(STBIR_AVX) || defined(__SSE4_1__)", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1477, + "column": 3, + "source_line": " #if defined(STBIR_AVX) || defined(__SSE4_1__)" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1480, + "column": 3, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1495, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_AVX", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1500, + "column": 3, + "source_line": " #ifdef STBIR_AVX" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_AVX2", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1530, + "column": 5, + "source_line": " #ifdef STBIR_AVX2" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1570, + "column": 5, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1623, + "column": 5, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_USE_FMA", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1662, + "column": 5, + "source_line": " #ifdef STBIR_USE_FMA // not on by default to maintain bit identical simd to non-simd" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1666, + "column": 5, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1670, + "column": 5, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1673, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_FLOORF", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1675, + "column": 3, + "source_line": " #ifdef STBIR_FLOORF" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1677, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "defined(STBIR_AVX) || defined(__SSE4_1__) || defined(STBIR_SSE41)", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1681, + "column": 5, + "source_line": " #if defined(STBIR_AVX) || defined(__SSE4_1__) || defined(STBIR_SSE41)" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1684, + "column": 5, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1689, + "column": 5, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_CEILF", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1692, + "column": 3, + "source_line": " #ifdef STBIR_CEILF" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1694, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "defined(STBIR_AVX) || defined(__SSE4_1__) || defined(STBIR_SSE41)", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1698, + "column": 5, + "source_line": " #if defined(STBIR_AVX) || defined(__SSE4_1__) || defined(STBIR_SSE41)" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1701, + "column": 5, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1706, + "column": 5, + "source_line": " #endif" + } + }, + { + "directive": "elif", + "argument": "defined(STBIR_NEON)", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1709, + "column": 1, + "source_line": "#elif defined(STBIR_NEON)" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_USE_FMA", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1780, + "column": 3, + "source_line": " #ifdef STBIR_USE_FMA // not on by default to maintain bit identical simd to non-simd (and also x64 no madd to arm madd)" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1785, + "column": 3, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1790, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "defined( _M_ARM64 ) || defined( __aarch64__ ) || defined( __arm64__ )", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1809, + "column": 3, + "source_line": " #if defined( _M_ARM64 ) || defined( __aarch64__ ) || defined( __arm64__ )" + } + }, + { + "directive": "if", + "argument": "defined( _MSC_VER ) && !defined(__clang__)", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1814, + "column": 5, + "source_line": " #if defined( _MSC_VER ) && !defined(__clang__)" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1826, + "column": 5, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1829, + "column": 5, + "source_line": " #endif" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1843, + "column": 3, + "source_line": " #else" + } + }, + { + "directive": "if", + "argument": "defined( _MSC_VER ) && !defined(__clang__)", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1848, + "column": 5, + "source_line": " #if defined( _MSC_VER ) && !defined(__clang__)" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1857, + "column": 5, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1860, + "column": 5, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1877, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "defined( _MSC_VER ) && !defined(__clang__)", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1924, + "column": 3, + "source_line": " #if defined( _MSC_VER ) && !defined(__clang__)" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1929, + "column": 3, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1934, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_FLOORF", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1936, + "column": 3, + "source_line": " #ifdef STBIR_FLOORF" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1938, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "defined( _M_ARM64 ) || defined( __aarch64__ ) || defined( __arm64__ )", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1942, + "column": 5, + "source_line": " #if defined( _M_ARM64 ) || defined( __aarch64__ ) || defined( __arm64__ )" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1944, + "column": 5, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1951, + "column": 5, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_CEILF", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1954, + "column": 3, + "source_line": " #ifdef STBIR_CEILF" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1956, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "defined( _M_ARM64 ) || defined( __aarch64__ ) || defined( __arm64__ )", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1960, + "column": 5, + "source_line": " #if defined( _M_ARM64 ) || defined( __aarch64__ ) || defined( __arm64__ )" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1962, + "column": 5, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1969, + "column": 5, + "source_line": " #endif" + } + }, + { + "directive": "elif", + "argument": "defined(STBIR_WASM)", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1974, + "column": 1, + "source_line": "#elif defined(STBIR_WASM)" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_FLOORF", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2126, + "column": 3, + "source_line": " #ifdef STBIR_FLOORF" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2128, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_CEILF", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2135, + "column": 3, + "source_line": " #ifdef STBIR_CEILF" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2137, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2146, + "column": 1, + "source_line": "#endif // SSE2/NEON/WASM" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2148, + "column": 1, + "source_line": "#endif // NO SIMD" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_SIMD8", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2150, + "column": 1, + "source_line": "#ifdef STBIR_SIMD8" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2184, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2213, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "defined(STBIR_NEON) && !defined(_M_ARM) && !defined(__arm__)", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2216, + "column": 1, + "source_line": "#if defined(STBIR_NEON) && !defined(_M_ARM) && !defined(__arm__)" + } + }, + { + "directive": "if", + "argument": "defined( _MSC_VER ) && !defined(__clang__)", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2218, + "column": 3, + "source_line": " #if defined( _MSC_VER ) && !defined(__clang__)" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2220, + "column": 3, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2222, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2224, + "column": 1, + "source_line": "#else // no NEON, or 32-bit ARM for MSVC" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2231, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "(!defined(STBIR_NEON) && !defined(STBIR_FP16C)) || (defined(STBIR_NEON) && defined(_M_ARM)) || (defined(STBIR_NEON) && defined(__arm__))", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2233, + "column": 1, + "source_line": "#if (!defined(STBIR_NEON) && !defined(STBIR_FP16C)) || (defined(STBIR_NEON) && defined(_M_ARM)) || (defined(STBIR_NEON) && defined(__arm__))" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2294, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "defined(STBIR_FP16C)", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2297, + "column": 1, + "source_line": "#if defined(STBIR_FP16C)" + } + }, + { + "directive": "elif", + "argument": "defined(STBIR_SSE2)", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2323, + "column": 1, + "source_line": "#elif defined(STBIR_SSE2)" + } + }, + { + "directive": "elif", + "argument": "defined(STBIR_NEON) && defined(_MSC_VER) && defined(_M_ARM64) && !defined(__clang__)", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2460, + "column": 1, + "source_line": "#elif defined(STBIR_NEON) && defined(_MSC_VER) && defined(_M_ARM64) && !defined(__clang__) // 64-bit ARM on MSVC (not clang)" + } + }, + { + "directive": "elif", + "argument": "defined(STBIR_NEON) && ( defined( _M_ARM64 ) || defined( __aarch64__ ) || defined( __arm64__ ) )", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2488, + "column": 1, + "source_line": "#elif defined(STBIR_NEON) && ( defined( _M_ARM64 ) || defined( __aarch64__ ) || defined( __arm64__ ) ) // 64-bit ARM" + } + }, + { + "directive": "elif", + "argument": "defined(STBIR_WASM) || (defined(STBIR_NEON) && (defined(_MSC_VER) || defined(_M_ARM) || defined(__arm__)))", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2514, + "column": 1, + "source_line": "#elif defined(STBIR_WASM) || (defined(STBIR_NEON) && (defined(_MSC_VER) || defined(_M_ARM) || defined(__arm__))) // WASM or 32-bit ARM on MSVC/clang" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2531, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_SIMD", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2534, + "column": 1, + "source_line": "#ifdef STBIR_SIMD" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_MEMCPY", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2586, + "column": 1, + "source_line": "#ifdef STBIR_MEMCPY" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2588, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2716, + "column": 1, + "source_line": "#else // no SSE2" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2724, + "column": 1, + "source_line": "#endif // SSE2" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_PROFILE", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2727, + "column": 1, + "source_line": "#ifdef STBIR_PROFILE" + } + }, + { + "directive": "ifndef", + "argument": "STBIR_PROFILE_FUNC", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2729, + "column": 1, + "source_line": "#ifndef STBIR_PROFILE_FUNC" + } + }, + { + "directive": "if", + "argument": "defined(_x86_64) || defined( __x86_64__ ) || defined( _M_X64 ) || defined(__x86_64) || defined(__SSE2__) || defined(STBIR_SSE) || defined( _M_IX86_FP ) || defined(__i386) || defined( __i386__ ) || defined( _M_IX86 ) || defined( _X86_ )", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2731, + "column": 1, + "source_line": "#if defined(_x86_64) || defined( __x86_64__ ) || defined( _M_X64 ) || defined(__x86_64) || defined(__SSE2__) || defined(STBIR_SSE) || defined( _M_IX86_FP ) || defined(__i386) || defined( __i386__ ) || defined( _M_IX86 ) || defined( _X86_ )" + } + }, + { + "directive": "ifdef", + "argument": "_MSC_VER", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2733, + "column": 1, + "source_line": "#ifdef _MSC_VER" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2738, + "column": 1, + "source_line": "#else // non msvc" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2747, + "column": 1, + "source_line": "#endif // msvc" + } + }, + { + "directive": "elif", + "argument": "defined( _M_ARM64 ) || defined( __aarch64__ ) || defined( __arm64__ ) || defined(__ARM_NEON__)", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2749, + "column": 1, + "source_line": "#elif defined( _M_ARM64 ) || defined( __aarch64__ ) || defined( __arm64__ ) || defined(__ARM_NEON__)" + } + }, + { + "directive": "if", + "argument": "defined( _MSC_VER ) && !defined(__clang__)", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2751, + "column": 1, + "source_line": "#if defined( _MSC_VER ) && !defined(__clang__)" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2755, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2764, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2766, + "column": 1, + "source_line": "#else // x64, arm" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2770, + "column": 1, + "source_line": "#endif // x64, arm" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2772, + "column": 1, + "source_line": "#endif // STBIR_PROFILE_FUNC" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2798, + "column": 1, + "source_line": "#else // no profile" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2816, + "column": 1, + "source_line": "#endif // stbir_profile" + } + }, + { + "directive": "ifndef", + "argument": "STBIR_CEILF", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2818, + "column": 1, + "source_line": "#ifndef STBIR_CEILF" + } + }, + { + "directive": "if", + "argument": "_MSC_VER <= 1200", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2820, + "column": 1, + "source_line": "#if _MSC_VER <= 1200 // support VC6 for Sean" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2823, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2826, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2827, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBIR_MEMCPY", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2829, + "column": 1, + "source_line": "#ifndef STBIR_MEMCPY" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2833, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBIR_SIMD", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2835, + "column": 1, + "source_line": "#ifndef STBIR_SIMD" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2888, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_RENORMALIZE_IN_FLOAT", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 3517, + "column": 1, + "source_line": "#ifdef STBIR_RENORMALIZE_IN_FLOAT" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 3519, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 3521, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_SIMD", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 3700, + "column": 3, + "source_line": " #ifdef STBIR_SIMD" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 3702, + "column": 3, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 3704, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_SIMD", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4146, + "column": 3, + "source_line": " #ifdef STBIR_SIMD" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_SIMD8", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4148, + "column": 3, + "source_line": " #ifdef STBIR_SIMD8" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4173, + "column": 3, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4194, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_SIMD8", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4197, + "column": 3, + "source_line": " #ifdef STBIR_SIMD8" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4200, + "column": 3, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4202, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4215, + "column": 3, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4231, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_SIMD", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4242, + "column": 3, + "source_line": " #ifdef STBIR_SIMD" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_SIMD8", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4249, + "column": 7, + "source_line": " #ifdef STBIR_SIMD8" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4264, + "column": 7, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4283, + "column": 7, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4289, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_SIMD", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4315, + "column": 1, + "source_line": "#ifdef STBIR_SIMD" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4331, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4346, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_SIMD", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4377, + "column": 3, + "source_line": " #ifdef STBIR_SIMD" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_SIMD8", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4398, + "column": 5, + "source_line": " #ifdef STBIR_SIMD8" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4401, + "column": 5, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4403, + "column": 5, + "source_line": " #endif" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4414, + "column": 3, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4425, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_SIMD", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4433, + "column": 3, + "source_line": " #ifdef STBIR_SIMD" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4451, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_SIMD", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4472, + "column": 1, + "source_line": "#ifdef STBIR_SIMD" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4483, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4491, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_SIMD", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4516, + "column": 1, + "source_line": "#ifdef STBIR_SIMD" + } + }, + { + "directive": "ifdef", + "argument": "stbir__simdf_swiz2", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4517, + "column": 5, + "source_line": " #ifdef stbir__simdf_swiz2 // do we have two argument swizzles?" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4540, + "column": 5, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4580, + "column": 5, + "source_line": " #endif" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4581, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4595, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_SIMD", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4708, + "column": 1, + "source_line": "#ifdef STBIR_SIMD" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4783, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4837, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_SIMD", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4847, + "column": 1, + "source_line": "#ifdef STBIR_SIMD" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_SIMD8", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4882, + "column": 1, + "source_line": "#ifdef STBIR_SIMD8" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4929, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4978, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4980, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5077, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_SIMD", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5087, + "column": 1, + "source_line": "#ifdef STBIR_SIMD" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_SIMD8", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5130, + "column": 1, + "source_line": "#ifdef STBIR_SIMD8" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5187, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5258, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5260, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5378, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_SIMD", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5387, + "column": 1, + "source_line": "#ifdef STBIR_SIMD" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_SIMD8", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5422, + "column": 1, + "source_line": "#ifdef STBIR_SIMD8" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5467, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5525, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5527, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5675, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_SIMD", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5686, + "column": 1, + "source_line": "#ifdef STBIR_SIMD" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_SIMD8", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5728, + "column": 1, + "source_line": "#ifdef STBIR_SIMD8" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5791, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5865, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 5867, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6078, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBIR__SEPARATE_ALLOCATIONS", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6222, + "column": 3, + "source_line": " #ifdef STBIR__SEPARATE_ALLOCATIONS" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6224, + "column": 3, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6226, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STBIR__SEPARATE_ALLOCATIONS", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6823, + "column": 3, + "source_line": " #ifndef STBIR__SEPARATE_ALLOCATIONS" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6825, + "column": 3, + "source_line": " #else" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_SIMD8", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6837, + "column": 9, + "source_line": " #ifdef STBIR_SIMD8" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6840, + "column": 9, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_SIMD8", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6844, + "column": 7, + "source_line": " #ifdef STBIR_SIMD8" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6847, + "column": 7, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6862, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "STBIR__V_FIRST_INFO_BUFFER", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6956, + "column": 1, + "source_line": "#ifdef STBIR__V_FIRST_INFO_BUFFER" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6959, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6961, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "defined( STBIR__SEPARATE_ALLOCATIONS ) && defined(STBIR_SIMD8)", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 7106, + "column": 1, + "source_line": "#if defined( STBIR__SEPARATE_ALLOCATIONS ) && defined(STBIR_SIMD8)" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 7109, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBIR__SEPARATE_ALLOCATIONS", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 7142, + "column": 1, + "source_line": "#ifdef STBIR__SEPARATE_ALLOCATIONS" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 7144, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 7146, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBIR__SEPARATE_ALLOCATIONS", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 7223, + "column": 1, + "source_line": "#ifdef STBIR__SEPARATE_ALLOCATIONS" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_SIMD8", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 7225, + "column": 7, + "source_line": " #ifdef STBIR_SIMD8" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 7228, + "column": 7, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_SIMD8", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 7236, + "column": 11, + "source_line": " #ifdef STBIR_SIMD8" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 7239, + "column": 11, + "source_line": " #endif" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 7242, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 7244, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBIR__SEPARATE_ALLOCATIONS", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 7260, + "column": 1, + "source_line": "#ifdef STBIR__SEPARATE_ALLOCATIONS" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_SIMD8", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 7263, + "column": 7, + "source_line": " #ifdef STBIR_SIMD8" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 7266, + "column": 7, + "source_line": " #endif" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 7267, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 7269, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_PROFILE", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 7882, + "column": 3, + "source_line": " #ifdef STBIR_PROFILE" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 7885, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_PROFILE", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 7936, + "column": 5, + "source_line": " #ifdef STBIR_PROFILE" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 7938, + "column": 5, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_PROFILE", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8159, + "column": 1, + "source_line": "#ifdef STBIR_PROFILE" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8224, + "column": 1, + "source_line": "#endif // STBIR_PROFILE" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8244, + "column": 1, + "source_line": "#endif // STB_IMAGE_RESIZE_IMPLEMENTATION" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8246, + "column": 1, + "source_line": "#else // STB_IMAGE_RESIZE_HORIZONTALS&STB_IMAGE_RESIZE_DO_VERTICALS" + } + }, + { + "directive": "ifdef", + "argument": "STB_IMAGE_RESIZE_DO_CODERS", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8259, + "column": 1, + "source_line": "#ifdef STB_IMAGE_RESIZE_DO_CODERS" + } + }, + { + "directive": "ifdef", + "argument": "stbir__decode_suffix", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8261, + "column": 1, + "source_line": "#ifdef stbir__decode_suffix" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8263, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8265, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "stbir__decode_swizzle", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8267, + "column": 1, + "source_line": "#ifdef stbir__decode_swizzle" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8272, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8285, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_SIMD8", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8287, + "column": 1, + "source_line": "#ifdef STBIR_SIMD8" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8289, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8291, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_SIMD", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8299, + "column": 3, + "source_line": " #ifdef STBIR_SIMD" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_SIMD8", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8307, + "column": 7, + "source_line": " #ifdef STBIR_SIMD8" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8321, + "column": 7, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8343, + "column": 7, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8355, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "stbir__coder_min_num != 3", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8358, + "column": 3, + "source_line": " #if stbir__coder_min_num != 3 // doesn't divide cleanly by four" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8372, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "stbir__coder_min_num < 4", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8375, + "column": 3, + "source_line": " #if stbir__coder_min_num < 4" + } + }, + { + "directive": "if", + "argument": "stbir__coder_min_num >= 2", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8381, + "column": 5, + "source_line": " #if stbir__coder_min_num >= 2" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8383, + "column": 5, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "stbir__coder_min_num >= 3", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8384, + "column": 5, + "source_line": " #if stbir__coder_min_num >= 3" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8386, + "column": 5, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8390, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_SIMD", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8400, + "column": 3, + "source_line": " #ifdef STBIR_SIMD" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_SIMD8", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8415, + "column": 7, + "source_line": " #ifdef STBIR_SIMD8" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8418, + "column": 7, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8421, + "column": 7, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "stbir__coder_min_num != 3", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8435, + "column": 3, + "source_line": " #if stbir__coder_min_num != 3 // doesn't divide cleanly by four" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8452, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "stbir__coder_min_num < 4", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8455, + "column": 3, + "source_line": " #if stbir__coder_min_num < 4" + } + }, + { + "directive": "if", + "argument": "stbir__coder_min_num >= 2", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8462, + "column": 5, + "source_line": " #if stbir__coder_min_num >= 2" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8464, + "column": 5, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "stbir__coder_min_num >= 3", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8465, + "column": 5, + "source_line": " #if stbir__coder_min_num >= 3" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8467, + "column": 5, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8471, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8473, + "column": 3, + "source_line": " #else" + } + }, + { + "directive": "if", + "argument": "stbir__coder_min_num != 3", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8476, + "column": 3, + "source_line": " #if stbir__coder_min_num != 3 // doesn't divide cleanly by four" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8489, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "stbir__coder_min_num < 4", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8492, + "column": 3, + "source_line": " #if stbir__coder_min_num < 4" + } + }, + { + "directive": "if", + "argument": "stbir__coder_min_num >= 2", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8499, + "column": 5, + "source_line": " #if stbir__coder_min_num >= 2" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8501, + "column": 5, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "stbir__coder_min_num >= 3", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8502, + "column": 5, + "source_line": " #if stbir__coder_min_num >= 3" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8504, + "column": 5, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8508, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8509, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_SIMD", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8518, + "column": 3, + "source_line": " #ifdef STBIR_SIMD" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_SIMD8", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8526, + "column": 7, + "source_line": " #ifdef STBIR_SIMD8" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8538, + "column": 7, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8556, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8568, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "stbir__coder_min_num != 3", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8571, + "column": 3, + "source_line": " #if stbir__coder_min_num != 3 // doesn't divide cleanly by four" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8585, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "stbir__coder_min_num < 4", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8588, + "column": 3, + "source_line": " #if stbir__coder_min_num < 4" + } + }, + { + "directive": "if", + "argument": "stbir__coder_min_num >= 2", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8594, + "column": 5, + "source_line": " #if stbir__coder_min_num >= 2" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8596, + "column": 5, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "stbir__coder_min_num >= 3", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8597, + "column": 5, + "source_line": " #if stbir__coder_min_num >= 3" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8599, + "column": 5, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8603, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_SIMD", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8612, + "column": 3, + "source_line": " #ifdef STBIR_SIMD" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_SIMD8", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8627, + "column": 7, + "source_line": " #ifdef STBIR_SIMD8" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8630, + "column": 7, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8633, + "column": 7, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "stbir__coder_min_num != 3", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8647, + "column": 3, + "source_line": " #if stbir__coder_min_num != 3 // doesn't divide cleanly by four" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8664, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8666, + "column": 3, + "source_line": " #else" + } + }, + { + "directive": "if", + "argument": "stbir__coder_min_num != 3", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8669, + "column": 3, + "source_line": " #if stbir__coder_min_num != 3 // doesn't divide cleanly by four" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8682, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8684, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "stbir__coder_min_num < 4", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8687, + "column": 3, + "source_line": " #if stbir__coder_min_num < 4" + } + }, + { + "directive": "if", + "argument": "stbir__coder_min_num >= 2", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8694, + "column": 5, + "source_line": " #if stbir__coder_min_num >= 2" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8696, + "column": 5, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "stbir__coder_min_num >= 3", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8697, + "column": 5, + "source_line": " #if stbir__coder_min_num >= 3" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8699, + "column": 5, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8703, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "stbir__coder_min_num != 3", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8713, + "column": 3, + "source_line": " #if stbir__coder_min_num != 3 // doesn't divide cleanly by four" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8725, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "stbir__coder_min_num < 4", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8728, + "column": 3, + "source_line": " #if stbir__coder_min_num < 4" + } + }, + { + "directive": "if", + "argument": "stbir__coder_min_num >= 2", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8734, + "column": 5, + "source_line": " #if stbir__coder_min_num >= 2" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8736, + "column": 5, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "stbir__coder_min_num >= 3", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8737, + "column": 5, + "source_line": " #if stbir__coder_min_num >= 3" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8739, + "column": 5, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8743, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_SIMD", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8815, + "column": 3, + "source_line": " #ifdef STBIR_SIMD" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8855, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "stbir__coder_min_num != 3", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8858, + "column": 3, + "source_line": " #if stbir__coder_min_num != 3 // doesn't divide cleanly by four" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8874, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "stbir__coder_min_num < 4", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8877, + "column": 3, + "source_line": " #if stbir__coder_min_num < 4" + } + }, + { + "directive": "if", + "argument": "stbir__coder_min_num >= 2", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8883, + "column": 5, + "source_line": " #if stbir__coder_min_num >= 2" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8885, + "column": 5, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "stbir__coder_min_num >= 3", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8886, + "column": 5, + "source_line": " #if stbir__coder_min_num >= 3" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8888, + "column": 5, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8892, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "( stbir__coder_min_num == 4 ) || ( ( stbir__coder_min_num == 1 ) && ( !defined(stbir__decode_swizzle) ) )", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8895, + "column": 1, + "source_line": "#if ( stbir__coder_min_num == 4 ) || ( ( stbir__coder_min_num == 1 ) && ( !defined(stbir__decode_swizzle) ) )" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_SIMD", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8920, + "column": 3, + "source_line": " #ifdef STBIR_SIMD" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8960, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8980, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "( stbir__coder_min_num == 2 ) || ( ( stbir__coder_min_num == 1 ) && ( !defined(stbir__decode_swizzle) ) )", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8982, + "column": 1, + "source_line": "#if ( stbir__coder_min_num == 2 ) || ( ( stbir__coder_min_num == 1 ) && ( !defined(stbir__decode_swizzle) ) )" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_SIMD", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9014, + "column": 3, + "source_line": " #ifdef STBIR_SIMD" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9052, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9070, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_SIMD", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9078, + "column": 3, + "source_line": " #ifdef STBIR_SIMD" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_SIMD8", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9086, + "column": 7, + "source_line": " #ifdef STBIR_SIMD8" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9096, + "column": 7, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9110, + "column": 7, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9122, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "stbir__coder_min_num != 3", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9125, + "column": 3, + "source_line": " #if stbir__coder_min_num != 3 // doesn't divide cleanly by four" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9139, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "stbir__coder_min_num < 4", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9142, + "column": 3, + "source_line": " #if stbir__coder_min_num < 4" + } + }, + { + "directive": "if", + "argument": "stbir__coder_min_num >= 2", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9148, + "column": 5, + "source_line": " #if stbir__coder_min_num >= 2" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9150, + "column": 5, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "stbir__coder_min_num >= 3", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9151, + "column": 5, + "source_line": " #if stbir__coder_min_num >= 3" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9153, + "column": 5, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9157, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_SIMD", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9167, + "column": 3, + "source_line": " #ifdef STBIR_SIMD" + } + }, + { + "directive": "if", + "argument": "stbir__coder_min_num != 3", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9199, + "column": 3, + "source_line": " #if stbir__coder_min_num != 3 // doesn't divide cleanly by four" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9216, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "stbir__coder_min_num < 4", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9219, + "column": 3, + "source_line": " #if stbir__coder_min_num < 4" + } + }, + { + "directive": "if", + "argument": "stbir__coder_min_num >= 2", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9226, + "column": 5, + "source_line": " #if stbir__coder_min_num >= 2" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9228, + "column": 5, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "stbir__coder_min_num >= 3", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9229, + "column": 5, + "source_line": " #if stbir__coder_min_num >= 3" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9231, + "column": 5, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9235, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9237, + "column": 3, + "source_line": " #else" + } + }, + { + "directive": "if", + "argument": "stbir__coder_min_num != 3", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9240, + "column": 3, + "source_line": " #if stbir__coder_min_num != 3 // doesn't divide cleanly by four" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9255, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "stbir__coder_min_num < 4", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9258, + "column": 3, + "source_line": " #if stbir__coder_min_num < 4" + } + }, + { + "directive": "if", + "argument": "stbir__coder_min_num >= 2", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9265, + "column": 5, + "source_line": " #if stbir__coder_min_num >= 2" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9267, + "column": 5, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "stbir__coder_min_num >= 3", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9268, + "column": 5, + "source_line": " #if stbir__coder_min_num >= 3" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9270, + "column": 5, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9274, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9275, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_SIMD", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9284, + "column": 3, + "source_line": " #ifdef STBIR_SIMD" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_SIMD8", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9292, + "column": 7, + "source_line": " #ifdef STBIR_SIMD8" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9301, + "column": 7, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9313, + "column": 7, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9325, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "stbir__coder_min_num != 3", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9328, + "column": 3, + "source_line": " #if stbir__coder_min_num != 3 // doesn't divide cleanly by four" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9342, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "stbir__coder_min_num < 4", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9345, + "column": 3, + "source_line": " #if stbir__coder_min_num < 4" + } + }, + { + "directive": "if", + "argument": "stbir__coder_min_num >= 2", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9351, + "column": 5, + "source_line": " #if stbir__coder_min_num >= 2" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9353, + "column": 5, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "stbir__coder_min_num >= 3", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9354, + "column": 5, + "source_line": " #if stbir__coder_min_num >= 3" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9356, + "column": 5, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9360, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_SIMD", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9369, + "column": 3, + "source_line": " #ifdef STBIR_SIMD" + } + }, + { + "directive": "if", + "argument": "stbir__coder_min_num != 3", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9401, + "column": 3, + "source_line": " #if stbir__coder_min_num != 3 // doesn't divide cleanly by four" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9418, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9420, + "column": 3, + "source_line": " #else" + } + }, + { + "directive": "if", + "argument": "stbir__coder_min_num != 3", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9423, + "column": 3, + "source_line": " #if stbir__coder_min_num != 3 // doesn't divide cleanly by four" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9438, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9440, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "stbir__coder_min_num < 4", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9443, + "column": 3, + "source_line": " #if stbir__coder_min_num < 4" + } + }, + { + "directive": "if", + "argument": "stbir__coder_min_num >= 2", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9450, + "column": 5, + "source_line": " #if stbir__coder_min_num >= 2" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9452, + "column": 5, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "stbir__coder_min_num >= 3", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9453, + "column": 5, + "source_line": " #if stbir__coder_min_num >= 3" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9455, + "column": 5, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9459, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_SIMD", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9468, + "column": 3, + "source_line": " #ifdef STBIR_SIMD" + } + }, + { + "directive": "ifdef", + "argument": "stbir__decode_swizzle", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9479, + "column": 7, + "source_line": " #ifdef stbir__decode_swizzle" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_SIMD8", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9480, + "column": 7, + "source_line": " #ifdef STBIR_SIMD8" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9487, + "column": 7, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9497, + "column": 7, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9498, + "column": 7, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9510, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "stbir__coder_min_num != 3", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9513, + "column": 3, + "source_line": " #if stbir__coder_min_num != 3 // doesn't divide cleanly by four" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9527, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "stbir__coder_min_num < 4", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9530, + "column": 3, + "source_line": " #if stbir__coder_min_num < 4" + } + }, + { + "directive": "if", + "argument": "stbir__coder_min_num >= 2", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9536, + "column": 5, + "source_line": " #if stbir__coder_min_num >= 2" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9538, + "column": 5, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "stbir__coder_min_num >= 3", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9539, + "column": 5, + "source_line": " #if stbir__coder_min_num >= 3" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9541, + "column": 5, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9545, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_SIMD", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9554, + "column": 3, + "source_line": " #ifdef STBIR_SIMD" + } + }, + { + "directive": "ifdef", + "argument": "stbir__decode_swizzle", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9563, + "column": 7, + "source_line": " #ifdef stbir__decode_swizzle" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_SIMD8", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9564, + "column": 7, + "source_line": " #ifdef STBIR_SIMD8" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9571, + "column": 7, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9580, + "column": 7, + "source_line": " #endif" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9581, + "column": 7, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9583, + "column": 7, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9595, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "stbir__coder_min_num != 3", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9598, + "column": 3, + "source_line": " #if stbir__coder_min_num != 3 // doesn't divide cleanly by four" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9612, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "stbir__coder_min_num < 4", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9615, + "column": 3, + "source_line": " #if stbir__coder_min_num < 4" + } + }, + { + "directive": "if", + "argument": "stbir__coder_min_num >= 2", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9621, + "column": 5, + "source_line": " #if stbir__coder_min_num >= 2" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9623, + "column": 5, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "stbir__coder_min_num >= 3", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9624, + "column": 5, + "source_line": " #if stbir__coder_min_num >= 3" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9626, + "column": 5, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9630, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "stbir__decode_swizzle", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9635, + "column": 3, + "source_line": " #ifdef stbir__decode_swizzle" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_SIMD", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9640, + "column": 3, + "source_line": " #ifdef STBIR_SIMD" + } + }, + { + "directive": "ifdef", + "argument": "stbir__decode_swizzle", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9649, + "column": 7, + "source_line": " #ifdef stbir__decode_swizzle" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_SIMD8", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9650, + "column": 7, + "source_line": " #ifdef STBIR_SIMD8" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9660, + "column": 7, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9676, + "column": 7, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9677, + "column": 7, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9689, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "stbir__coder_min_num != 3", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9692, + "column": 3, + "source_line": " #if stbir__coder_min_num != 3 // doesn't divide cleanly by four" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9706, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "stbir__coder_min_num < 4", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9709, + "column": 3, + "source_line": " #if stbir__coder_min_num < 4" + } + }, + { + "directive": "if", + "argument": "stbir__coder_min_num >= 2", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9715, + "column": 5, + "source_line": " #if stbir__coder_min_num >= 2" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9717, + "column": 5, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "stbir__coder_min_num >= 3", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9718, + "column": 5, + "source_line": " #if stbir__coder_min_num >= 3" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9720, + "column": 5, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9724, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9727, + "column": 3, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9734, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "!defined( STBIR_FLOAT_HIGH_CLAMP ) && !defined(STBIR_FLOAT_LOW_CLAMP) && !defined(stbir__decode_swizzle)", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9739, + "column": 3, + "source_line": " #if !defined( STBIR_FLOAT_HIGH_CLAMP ) && !defined(STBIR_FLOAT_LOW_CLAMP) && !defined(stbir__decode_swizzle)" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9744, + "column": 3, + "source_line": " #else" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_FLOAT_HIGH_CLAMP", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9749, + "column": 3, + "source_line": " #ifdef STBIR_FLOAT_HIGH_CLAMP" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9751, + "column": 3, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9753, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_FLOAT_LOW_CLAMP", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9754, + "column": 3, + "source_line": " #ifdef STBIR_FLOAT_LOW_CLAMP" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9756, + "column": 3, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9758, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_SIMD", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9760, + "column": 3, + "source_line": " #ifdef STBIR_SIMD" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_FLOAT_HIGH_CLAMP", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9762, + "column": 3, + "source_line": " #ifdef STBIR_FLOAT_HIGH_CLAMP" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9764, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_FLOAT_LOW_CLAMP", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9765, + "column": 3, + "source_line": " #ifdef STBIR_FLOAT_LOW_CLAMP" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9767, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_FLOAT_HIGH_CLAMP", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9780, + "column": 1, + "source_line": "#ifdef STBIR_FLOAT_HIGH_CLAMP" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9783, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_FLOAT_LOW_CLAMP", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9784, + "column": 1, + "source_line": "#ifdef STBIR_FLOAT_LOW_CLAMP" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9787, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "stbir__coder_min_num != 3", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9805, + "column": 3, + "source_line": " #if stbir__coder_min_num != 3 // doesn't divide cleanly by four" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_FLOAT_HIGH_CLAMP", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9813, + "column": 1, + "source_line": "#ifdef STBIR_FLOAT_HIGH_CLAMP" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9815, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_FLOAT_LOW_CLAMP", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9816, + "column": 1, + "source_line": "#ifdef STBIR_FLOAT_LOW_CLAMP" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9818, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9825, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9827, + "column": 3, + "source_line": " #else" + } + }, + { + "directive": "if", + "argument": "stbir__coder_min_num != 3", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9830, + "column": 3, + "source_line": " #if stbir__coder_min_num != 3 // doesn't divide cleanly by four" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9846, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9848, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "stbir__coder_min_num < 4", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9851, + "column": 3, + "source_line": " #if stbir__coder_min_num < 4" + } + }, + { + "directive": "if", + "argument": "stbir__coder_min_num >= 2", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9858, + "column": 5, + "source_line": " #if stbir__coder_min_num >= 2" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9860, + "column": 5, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "stbir__coder_min_num >= 3", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9861, + "column": 5, + "source_line": " #if stbir__coder_min_num >= 3" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9863, + "column": 5, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9867, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9869, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "elif", + "argument": "defined( STB_IMAGE_RESIZE_DO_VERTICALS)", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9893, + "column": 1, + "source_line": "#elif defined( STB_IMAGE_RESIZE_DO_VERTICALS)" + } + }, + { + "directive": "ifdef", + "argument": "STB_IMAGE_RESIZE_VERTICAL_CONTINUE", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9895, + "column": 1, + "source_line": "#ifdef STB_IMAGE_RESIZE_VERTICAL_CONTINUE" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9897, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9899, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "STBIR__vertical_channels >= 1", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9901, + "column": 1, + "source_line": "#if STBIR__vertical_channels >= 1" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9903, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9905, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "STBIR__vertical_channels >= 2", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9906, + "column": 1, + "source_line": "#if STBIR__vertical_channels >= 2" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9908, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9910, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "STBIR__vertical_channels >= 3", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9911, + "column": 1, + "source_line": "#if STBIR__vertical_channels >= 3" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9913, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9915, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "STBIR__vertical_channels >= 4", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9916, + "column": 1, + "source_line": "#if STBIR__vertical_channels >= 4" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9918, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9920, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "STBIR__vertical_channels >= 5", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9921, + "column": 1, + "source_line": "#if STBIR__vertical_channels >= 5" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9923, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9925, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "STBIR__vertical_channels >= 6", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9926, + "column": 1, + "source_line": "#if STBIR__vertical_channels >= 6" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9928, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9930, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "STBIR__vertical_channels >= 7", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9931, + "column": 1, + "source_line": "#if STBIR__vertical_channels >= 7" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9933, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9935, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "STBIR__vertical_channels >= 8", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9936, + "column": 1, + "source_line": "#if STBIR__vertical_channels >= 8" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9938, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9940, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_SIMD", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9953, + "column": 3, + "source_line": " #ifdef STBIR_SIMD" + } + }, + { + "directive": "ifdef", + "argument": "STB_IMAGE_RESIZE_VERTICAL_CONTINUE", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9971, + "column": 7, + "source_line": " #ifdef STB_IMAGE_RESIZE_VERTICAL_CONTINUE" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9996, + "column": 7, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10013, + "column": 7, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "STB_IMAGE_RESIZE_VERTICAL_CONTINUE", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10026, + "column": 7, + "source_line": " #ifdef STB_IMAGE_RESIZE_VERTICAL_CONTINUE" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10035, + "column": 7, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10044, + "column": 7, + "source_line": " #endif" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10050, + "column": 3, + "source_line": " #else" + } + }, + { + "directive": "ifdef", + "argument": "STB_IMAGE_RESIZE_VERTICAL_CONTINUE", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10059, + "column": 5, + "source_line": " #ifdef STB_IMAGE_RESIZE_VERTICAL_CONTINUE" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10068, + "column": 5, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10077, + "column": 5, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10082, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "STB_IMAGE_RESIZE_VERTICAL_CONTINUE", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10089, + "column": 5, + "source_line": " #ifdef STB_IMAGE_RESIZE_VERTICAL_CONTINUE" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10098, + "column": 5, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10107, + "column": 5, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "( STBIR__vertical_channels == 1 ) && !defined(STB_IMAGE_RESIZE_VERTICAL_CONTINUE)", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10127, + "column": 1, + "source_line": "#if ( STBIR__vertical_channels == 1 ) && !defined(STB_IMAGE_RESIZE_VERTICAL_CONTINUE)" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10134, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBIR_SIMD", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10136, + "column": 3, + "source_line": " #ifdef STBIR_SIMD" + } + }, + { + "directive": "ifdef", + "argument": "STB_IMAGE_RESIZE_VERTICAL_CONTINUE", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10163, + "column": 7, + "source_line": " #ifdef STB_IMAGE_RESIZE_VERTICAL_CONTINUE" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10167, + "column": 7, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10170, + "column": 7, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "STB_IMAGE_RESIZE_VERTICAL_CONTINUE", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10198, + "column": 7, + "source_line": " #ifdef STB_IMAGE_RESIZE_VERTICAL_CONTINUE" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10200, + "column": 7, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10202, + "column": 7, + "source_line": " #endif" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10216, + "column": 3, + "source_line": " #else" + } + }, + { + "directive": "ifdef", + "argument": "STB_IMAGE_RESIZE_VERTICAL_CONTINUE", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10222, + "column": 5, + "source_line": " #ifdef STB_IMAGE_RESIZE_VERTICAL_CONTINUE" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10224, + "column": 5, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10226, + "column": 5, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10238, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "STB_IMAGE_RESIZE_VERTICAL_CONTINUE", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10244, + "column": 5, + "source_line": " #ifdef STB_IMAGE_RESIZE_VERTICAL_CONTINUE" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10246, + "column": 5, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10248, + "column": 5, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "STB_IMAGE_RESIZE_VERTICAL_CONTINUE", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10276, + "column": 1, + "source_line": "#ifdef STB_IMAGE_RESIZE_VERTICAL_CONTINUE" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10278, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10280, + "column": 1, + "source_line": "#else // !STB_IMAGE_RESIZE_DO_VERTICALS" + } + }, + { + "directive": "ifndef", + "argument": "stbir__2_coeff_only", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10284, + "column": 1, + "source_line": "#ifndef stbir__2_coeff_only" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10288, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "stbir__2_coeff_remnant", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10290, + "column": 1, + "source_line": "#ifndef stbir__2_coeff_remnant" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10294, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "stbir__3_coeff_only", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10296, + "column": 1, + "source_line": "#ifndef stbir__3_coeff_only" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10300, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "stbir__3_coeff_remnant", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10302, + "column": 1, + "source_line": "#ifndef stbir__3_coeff_remnant" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10306, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "stbir__3_coeff_setup", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10308, + "column": 1, + "source_line": "#ifndef stbir__3_coeff_setup" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10310, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "stbir__4_coeff_start", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10312, + "column": 1, + "source_line": "#ifndef stbir__4_coeff_start" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10316, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "stbir__4_coeff_continue_from_4", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10318, + "column": 1, + "source_line": "#ifndef stbir__4_coeff_continue_from_4" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10322, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "stbir__store_output_tiny", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10324, + "column": 1, + "source_line": "#ifndef stbir__store_output_tiny" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10326, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10632, + "column": 1, + "source_line": "#endif // HORIZONALS" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10637, + "column": 1, + "source_line": "#endif // STB_IMAGE_RESIZE_DO_HORIZONTALS/VERTICALS/CODERS" + } + } + ], + "macro_dependencies": [ + { + "name": "STBIRDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 472, + "column": 1, + "source_line": "STBIRDEF unsigned char * stbir_resize_uint8_srgb( const unsigned char *input_pixels , int input_w , int input_h, int input_stride_in_bytes," + }, + "source_text": "STBIRDEF unsigned char * stbir_resize_uint8_srgb( const unsigned char *input_pixels , int input_w , int input_h, int input_stride_in_bytes,\n unsigned char *output_pixels, int output_w, int output_h, int output_stride_in_bytes,\n stbir_pixel_layout pixel_type )" + }, + { + "name": "STBIRDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 476, + "column": 1, + "source_line": "STBIRDEF unsigned char * stbir_resize_uint8_linear( const unsigned char *input_pixels , int input_w , int input_h, int input_stride_in_bytes," + }, + "source_text": "STBIRDEF unsigned char * stbir_resize_uint8_linear( const unsigned char *input_pixels , int input_w , int input_h, int input_stride_in_bytes,\n unsigned char *output_pixels, int output_w, int output_h, int output_stride_in_bytes,\n stbir_pixel_layout pixel_type )" + }, + { + "name": "STBIRDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 480, + "column": 1, + "source_line": "STBIRDEF float * stbir_resize_float_linear( const float *input_pixels , int input_w , int input_h, int input_stride_in_bytes," + }, + "source_text": "STBIRDEF float * stbir_resize_float_linear( const float *input_pixels , int input_w , int input_h, int input_stride_in_bytes,\n float *output_pixels, int output_w, int output_h, int output_stride_in_bytes,\n stbir_pixel_layout pixel_type )" + }, + { + "name": "STBIRDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 526, + "column": 1, + "source_line": "STBIRDEF void * stbir_resize( const void *input_pixels , int input_w , int input_h, int input_stride_in_bytes," + }, + "source_text": "STBIRDEF void * stbir_resize( const void *input_pixels , int input_w , int input_h, int input_stride_in_bytes,\n void *output_pixels, int output_w, int output_h, int output_stride_in_bytes,\n stbir_pixel_layout pixel_layout, stbir_datatype data_type,\n stbir_edge edge, stbir_filter filter )" + }, + { + "name": "STBIRDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 606, + "column": 1, + "source_line": "STBIRDEF void stbir_resize_init( STBIR_RESIZE * resize," + }, + "source_text": "STBIRDEF void stbir_resize_init( STBIR_RESIZE * resize,\n const void *input_pixels, int input_w, int input_h, int input_stride_in_bytes, \n void *output_pixels, int output_w, int output_h, int output_stride_in_bytes, \n stbir_pixel_layout pixel_layout, stbir_datatype data_type )" + }, + { + "name": "STBIRDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 615, + "column": 1, + "source_line": "STBIRDEF void stbir_set_datatypes( STBIR_RESIZE * resize, stbir_datatype input_type, stbir_datatype output_type );" + }, + "source_text": "STBIRDEF void stbir_set_datatypes( STBIR_RESIZE * resize, stbir_datatype input_type, stbir_datatype output_type )" + }, + { + "name": "STBIRDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 616, + "column": 1, + "source_line": "STBIRDEF void stbir_set_pixel_callbacks( STBIR_RESIZE * resize, stbir_input_callback * input_cb, stbir_output_callback * output_cb ); // no callbacks by default" + }, + "source_text": "STBIRDEF void stbir_set_pixel_callbacks( STBIR_RESIZE * resize, stbir_input_callback * input_cb, stbir_output_callback * output_cb )" + }, + { + "name": "STBIRDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 617, + "column": 1, + "source_line": "STBIRDEF void stbir_set_user_data( STBIR_RESIZE * resize, void * user_data ); // pass back STBIR_RESIZE* by default" + }, + "source_text": "STBIRDEF void stbir_set_user_data( STBIR_RESIZE * resize, void * user_data )" + }, + { + "name": "STBIRDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 618, + "column": 1, + "source_line": "STBIRDEF void stbir_set_buffer_ptrs( STBIR_RESIZE * resize, const void * input_pixels, int input_stride_in_bytes, void * output_pixels, int output_stride_in_bytes );" + }, + "source_text": "STBIRDEF void stbir_set_buffer_ptrs( STBIR_RESIZE * resize, const void * input_pixels, int input_stride_in_bytes, void * output_pixels, int output_stride_in_bytes )" + }, + { + "name": "STBIRDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 627, + "column": 1, + "source_line": "STBIRDEF int stbir_set_pixel_layouts( STBIR_RESIZE * resize, stbir_pixel_layout input_pixel_layout, stbir_pixel_layout output_pixel_layout ); // sets new buffer layouts" + }, + "source_text": "STBIRDEF int stbir_set_pixel_layouts( STBIR_RESIZE * resize, stbir_pixel_layout input_pixel_layout, stbir_pixel_layout output_pixel_layout )" + }, + { + "name": "STBIRDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 628, + "column": 1, + "source_line": "STBIRDEF int stbir_set_edgemodes( STBIR_RESIZE * resize, stbir_edge horizontal_edge, stbir_edge vertical_edge ); // CLAMP by default" + }, + "source_text": "STBIRDEF int stbir_set_edgemodes( STBIR_RESIZE * resize, stbir_edge horizontal_edge, stbir_edge vertical_edge )" + }, + { + "name": "STBIRDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 630, + "column": 1, + "source_line": "STBIRDEF int stbir_set_filters( STBIR_RESIZE * resize, stbir_filter horizontal_filter, stbir_filter vertical_filter ); // STBIR_DEFAULT_FILTER_UPSAMPLE/DOWNSAMPLE by default" + }, + "source_text": "STBIRDEF int stbir_set_filters( STBIR_RESIZE * resize, stbir_filter horizontal_filter, stbir_filter vertical_filter )" + }, + { + "name": "STBIRDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 631, + "column": 1, + "source_line": "STBIRDEF int stbir_set_filter_callbacks( STBIR_RESIZE * resize, stbir__kernel_callback * horizontal_filter, stbir__support_callback * horizontal_support, stbir__kernel_callback * vertical_filter, stbir__support_callback * vertical_support );" + }, + "source_text": "STBIRDEF int stbir_set_filter_callbacks( STBIR_RESIZE * resize, stbir__kernel_callback * horizontal_filter, stbir__support_callback * horizontal_support, stbir__kernel_callback * vertical_filter, stbir__support_callback * vertical_support )" + }, + { + "name": "STBIRDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 633, + "column": 1, + "source_line": "STBIRDEF int stbir_set_pixel_subrect( STBIR_RESIZE * resize, int subx, int suby, int subw, int subh ); // sets both sub-regions (full regions by default)" + }, + "source_text": "STBIRDEF int stbir_set_pixel_subrect( STBIR_RESIZE * resize, int subx, int suby, int subw, int subh )" + }, + { + "name": "STBIRDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 634, + "column": 1, + "source_line": "STBIRDEF int stbir_set_input_subrect( STBIR_RESIZE * resize, double s0, double t0, double s1, double t1 ); // sets input sub-region (full region by default)" + }, + "source_text": "STBIRDEF int stbir_set_input_subrect( STBIR_RESIZE * resize, double s0, double t0, double s1, double t1 )" + }, + { + "name": "STBIRDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 635, + "column": 1, + "source_line": "STBIRDEF int stbir_set_output_pixel_subrect( STBIR_RESIZE * resize, int subx, int suby, int subw, int subh ); // sets output sub-region (full region by default)" + }, + "source_text": "STBIRDEF int stbir_set_output_pixel_subrect( STBIR_RESIZE * resize, int subx, int suby, int subw, int subh )" + }, + { + "name": "STBIRDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 641, + "column": 1, + "source_line": "STBIRDEF int stbir_set_non_pm_alpha_speed_over_quality( STBIR_RESIZE * resize, int non_pma_alpha_speed_over_quality );" + }, + "source_text": "STBIRDEF int stbir_set_non_pm_alpha_speed_over_quality( STBIR_RESIZE * resize, int non_pma_alpha_speed_over_quality )" + }, + { + "name": "STBIRDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 653, + "column": 1, + "source_line": "STBIRDEF int stbir_build_samplers( STBIR_RESIZE * resize );" + }, + "source_text": "STBIRDEF int stbir_build_samplers( STBIR_RESIZE * resize )" + }, + { + "name": "STBIRDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 656, + "column": 1, + "source_line": "STBIRDEF void stbir_free_samplers( STBIR_RESIZE * resize );" + }, + "source_text": "STBIRDEF void stbir_free_samplers( STBIR_RESIZE * resize )" + }, + { + "name": "STBIRDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 661, + "column": 1, + "source_line": "STBIRDEF int stbir_resize_extended( STBIR_RESIZE * resize );" + }, + "source_text": "STBIRDEF int stbir_resize_extended( STBIR_RESIZE * resize )" + }, + { + "name": "STBIRDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 676, + "column": 1, + "source_line": "STBIRDEF int stbir_build_samplers_with_splits( STBIR_RESIZE * resize, int try_splits );" + }, + "source_text": "STBIRDEF int stbir_build_samplers_with_splits( STBIR_RESIZE * resize, int try_splits )" + }, + { + "name": "STBIRDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 689, + "column": 1, + "source_line": "STBIRDEF int stbir_resize_extended_split( STBIR_RESIZE * resize, int split_start, int split_count );" + }, + "source_text": "STBIRDEF int stbir_resize_extended_split( STBIR_RESIZE * resize, int split_start, int split_count )" + }, + { + "name": "STBIRDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 767, + "column": 1, + "source_line": "STBIRDEF void stbir_resize_build_profile_info( STBIR_PROFILE_INFO * out_info, STBIR_RESIZE const * resize );" + }, + "source_text": "STBIRDEF void stbir_resize_build_profile_info( STBIR_PROFILE_INFO * out_info, STBIR_RESIZE const * resize )" + }, + { + "name": "STBIRDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 770, + "column": 1, + "source_line": "STBIRDEF void stbir_resize_extended_profile_info( STBIR_PROFILE_INFO * out_info, STBIR_RESIZE const * resize );" + }, + "source_text": "STBIRDEF void stbir_resize_extended_profile_info( STBIR_PROFILE_INFO * out_info, STBIR_RESIZE const * resize )" + }, + { + "name": "STBIRDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 773, + "column": 1, + "source_line": "STBIRDEF void stbir_resize_split_profile_info( STBIR_PROFILE_INFO * out_info, STBIR_RESIZE const * resize, int split_start, int split_num );" + }, + "source_text": "STBIRDEF void stbir_resize_split_profile_info( STBIR_PROFILE_INFO * out_info, STBIR_RESIZE const * resize, int split_start, int split_num )" + }, + { + "name": "stbir__inline", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1077, + "column": 1, + "source_line": "static stbir__inline int stbir__min(int a, int b)" + }, + "source_text": "static stbir__inline int stbir__min(int a, int b)" + }, + { + "name": "stbir__inline", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1082, + "column": 1, + "source_line": "static stbir__inline int stbir__max(int a, int b)" + }, + "source_text": "static stbir__inline int stbir__max(int a, int b)" + }, + { + "name": "stbir__inline", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1138, + "column": 1, + "source_line": "static stbir__inline stbir_uint8 stbir__linear_to_srgb_uchar(float in)" + }, + "source_text": "static stbir__inline stbir_uint8 stbir__linear_to_srgb_uchar(float in)" + }, + { + "name": "stbir__simdf", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1405, + "column": 3, + "source_line": " static const stbir__simdf STBIR_zeroones = { 0.0f,1.0f,0.0f,1.0f };" + }, + "source_text": "static const stbir__simdf STBIR_zeroones =" + }, + { + "name": "stbir__simdf", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1406, + "column": 3, + "source_line": " static const stbir__simdf STBIR_onezeros = { 1.0f,0.0f,1.0f,0.0f };" + }, + "source_text": "static const stbir__simdf STBIR_onezeros =" + }, + { + "name": "STBIR__SIMDI_CONST", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1481, + "column": 5, + "source_line": " static STBIR__SIMDI_CONST(stbir__s32_32768, 32768);" + }, + "source_text": "static STBIR__SIMDI_CONST(stbir__s32_32768, 32768)" + }, + { + "name": "STBIR__SIMDI_CONST", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1482, + "column": 5, + "source_line": " static STBIR__SIMDI_CONST(stbir__s16_32768, ((32768<<16)|32768));" + }, + "source_text": "static STBIR__SIMDI_CONST(stbir__s16_32768, ((32768<<16)|32768))" + }, + { + "name": "stbir__inline", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1679, + "column": 3, + "source_line": " static stbir__inline float stbir_simd_floorf(float x) // martins floorf" + }, + "source_text": "static stbir__inline float stbir_simd_floorf(float x)" + }, + { + "name": "stbir__inline", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1696, + "column": 3, + "source_line": " static stbir__inline float stbir_simd_ceilf(float x) // martins ceilf" + }, + "source_text": "static stbir__inline float stbir_simd_ceilf(float x)" + }, + { + "name": "stbir_make16x2", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1821, + "column": 7, + "source_line": " static stbir__inline uint8x16x2_t stbir_make16x2(float32x4_t rega,float32x4_t regb)" + }, + "source_text": "static stbir__inline uint8x16x2_t stbir_make16x2(float32x4_t rega,float32x4_t regb)" + }, + { + "name": "stbir_make8x2", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1849, + "column": 7, + "source_line": " static stbir__inline uint8x8x2_t stbir_make8x2(float32x4_t reg)" + }, + "source_text": "static stbir__inline uint8x8x2_t stbir_make8x2(float32x4_t reg)" + }, + { + "name": "stbir__inline", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1940, + "column": 3, + "source_line": " static stbir__inline float stbir_simd_floorf(float x)" + }, + "source_text": "static stbir__inline float stbir_simd_floorf(float x)" + }, + { + "name": "stbir__inline", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1958, + "column": 3, + "source_line": " static stbir__inline float stbir_simd_ceilf(float x)" + }, + "source_text": "static stbir__inline float stbir_simd_ceilf(float x)" + }, + { + "name": "stbir__inline", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2130, + "column": 3, + "source_line": " static stbir__inline float stbir_simd_floorf(float x)" + }, + "source_text": "static stbir__inline float stbir_simd_floorf(float x)" + }, + { + "name": "stbir__inline", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2139, + "column": 3, + "source_line": " static stbir__inline float stbir_simd_ceilf(float x)" + }, + "source_text": "static stbir__inline float stbir_simd_ceilf(float x)" + }, + { + "name": "stbir__simdf8", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2178, + "column": 3, + "source_line": " static const stbir__simdf8 STBIR_max_uint16_as_float_inverted8 = { stbir__max_uint16_as_float_inverted,stbir__max_uint16_as_float_inverted,stbir__max_uint16_as_float_inverted,stbir__max_uint16_as_float_inverted,stbir__max_uint16_as_float_inverted,stbir__max_uint16_as_float_inverted,stbir__max_uint16_as_float_inverted,stbir__max_uint16_as_float_inverted };" + }, + "source_text": "static const stbir__simdf8 STBIR_max_uint16_as_float_inverted8 =" + }, + { + "name": "stbir__simdf8", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2179, + "column": 3, + "source_line": " static const stbir__simdf8 STBIR_max_uint8_as_float_inverted8 = { stbir__max_uint8_as_float_inverted,stbir__max_uint8_as_float_inverted,stbir__max_uint8_as_float_inverted,stbir__max_uint8_as_float_inverted,stbir__max_uint8_as_float_inverted,stbir__max_uint8_as_float_inverted,stbir__max_uint8_as_float_inverted,stbir__max_uint8_as_float_inverted };" + }, + "source_text": "static const stbir__simdf8 STBIR_max_uint8_as_float_inverted8 =" + }, + { + "name": "stbir__simdf8", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2180, + "column": 3, + "source_line": " static const stbir__simdf8 STBIR_ones8 = { 1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0 };" + }, + "source_text": "static const stbir__simdf8 STBIR_ones8 =" + }, + { + "name": "stbir__simdf8", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2181, + "column": 3, + "source_line": " static const stbir__simdf8 STBIR_simd_point58 = { 0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5 };" + }, + "source_text": "static const stbir__simdf8 STBIR_simd_point58 =" + }, + { + "name": "stbir__simdf8", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2182, + "column": 3, + "source_line": " static const stbir__simdf8 STBIR_max_uint8_as_float8 = { stbir__max_uint8_as_float,stbir__max_uint8_as_float,stbir__max_uint8_as_float,stbir__max_uint8_as_float, stbir__max_uint8_as_float,stbir__max_uint8_as_float,stbir__max_uint8_as_float,stbir__max_uint8_as_float };" + }, + "source_text": "static const stbir__simdf8 STBIR_max_uint8_as_float8 =" + }, + { + "name": "stbir__simdf8", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2183, + "column": 3, + "source_line": " static const stbir__simdf8 STBIR_max_uint16_as_float8 = { stbir__max_uint16_as_float,stbir__max_uint16_as_float,stbir__max_uint16_as_float,stbir__max_uint16_as_float, stbir__max_uint16_as_float,stbir__max_uint16_as_float,stbir__max_uint16_as_float,stbir__max_uint16_as_float };" + }, + "source_text": "static const stbir__simdf8 STBIR_max_uint16_as_float8 =" + }, + { + "name": "stbir__inline", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2237, + "column": 3, + "source_line": " static stbir__inline float stbir__half_to_float( stbir__FP16 h )" + }, + "source_text": "static stbir__inline float stbir__half_to_float( stbir__FP16 h )" + }, + { + "name": "stbir__inline", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2251, + "column": 3, + "source_line": " static stbir__inline stbir__FP16 stbir__float_to_half(float val)" + }, + "source_text": "static stbir__inline stbir__FP16 stbir__float_to_half(float val)" + }, + { + "name": "stbir__inline", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2301, + "column": 3, + "source_line": " static stbir__inline void stbir__half_to_float_SIMD(float * output, stbir__FP16 const * input)" + }, + "source_text": "static stbir__inline void stbir__half_to_float_SIMD(float * output, stbir__FP16 const * input)" + }, + { + "name": "stbir__inline", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2306, + "column": 3, + "source_line": " static stbir__inline void stbir__float_to_half_SIMD(stbir__FP16 * output, float const * input)" + }, + "source_text": "static stbir__inline void stbir__float_to_half_SIMD(stbir__FP16 * output, float const * input)" + }, + { + "name": "stbir__inline", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2311, + "column": 3, + "source_line": " static stbir__inline float stbir__half_to_float( stbir__FP16 h )" + }, + "source_text": "static stbir__inline float stbir__half_to_float( stbir__FP16 h )" + }, + { + "name": "stbir__inline", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2316, + "column": 3, + "source_line": " static stbir__inline stbir__FP16 stbir__float_to_half( float f )" + }, + "source_text": "static stbir__inline stbir__FP16 stbir__float_to_half( float f )" + }, + { + "name": "stbir__inline", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2326, + "column": 3, + "source_line": " stbir__inline static void stbir__half_to_float_SIMD(float * output, void const * input)" + }, + "source_text": "stbir__inline static void stbir__half_to_float_SIMD(float * output, void const * input)" + }, + { + "name": "stbir__inline", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2380, + "column": 3, + "source_line": " stbir__inline static void stbir__float_to_half_SIMD(void * output, float const * input)" + }, + "source_text": "stbir__inline static void stbir__float_to_half_SIMD(void * output, float const * input)" + }, + { + "name": "stbir__inline", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2462, + "column": 3, + "source_line": " static stbir__inline void stbir__half_to_float_SIMD(float * output, stbir__FP16 const * input)" + }, + "source_text": "static stbir__inline void stbir__half_to_float_SIMD(float * output, stbir__FP16 const * input)" + }, + { + "name": "stbir__inline", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2470, + "column": 3, + "source_line": " static stbir__inline void stbir__float_to_half_SIMD(stbir__FP16 * output, float const * input)" + }, + "source_text": "static stbir__inline void stbir__float_to_half_SIMD(stbir__FP16 * output, float const * input)" + }, + { + "name": "stbir__inline", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2478, + "column": 3, + "source_line": " static stbir__inline float stbir__half_to_float( stbir__FP16 h )" + }, + "source_text": "static stbir__inline float stbir__half_to_float( stbir__FP16 h )" + }, + { + "name": "stbir__inline", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2483, + "column": 3, + "source_line": " static stbir__inline stbir__FP16 stbir__float_to_half( float f )" + }, + "source_text": "static stbir__inline stbir__FP16 stbir__float_to_half( float f )" + }, + { + "name": "stbir__inline", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2490, + "column": 3, + "source_line": " static stbir__inline void stbir__half_to_float_SIMD(float * output, stbir__FP16 const * input)" + }, + "source_text": "static stbir__inline void stbir__half_to_float_SIMD(float * output, stbir__FP16 const * input)" + }, + { + "name": "stbir__inline", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2497, + "column": 3, + "source_line": " static stbir__inline void stbir__float_to_half_SIMD(stbir__FP16 * output, float const * input)" + }, + "source_text": "static stbir__inline void stbir__float_to_half_SIMD(stbir__FP16 * output, float const * input)" + }, + { + "name": "stbir__inline", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2504, + "column": 3, + "source_line": " static stbir__inline float stbir__half_to_float( stbir__FP16 h )" + }, + "source_text": "static stbir__inline float stbir__half_to_float( stbir__FP16 h )" + }, + { + "name": "stbir__inline", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2509, + "column": 3, + "source_line": " static stbir__inline stbir__FP16 stbir__float_to_half( float f )" + }, + "source_text": "static stbir__inline stbir__FP16 stbir__float_to_half( float f )" + }, + { + "name": "stbir__inline", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2516, + "column": 3, + "source_line": " static stbir__inline void stbir__half_to_float_SIMD(float * output, stbir__FP16 const * input)" + }, + "source_text": "static stbir__inline void stbir__half_to_float_SIMD(float * output, stbir__FP16 const * input)" + }, + { + "name": "stbir__inline", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2523, + "column": 3, + "source_line": " static stbir__inline void stbir__float_to_half_SIMD(stbir__FP16 * output, float const * input)" + }, + "source_text": "static stbir__inline void stbir__float_to_half_SIMD(stbir__FP16 * output, float const * input)" + }, + { + "name": "STBIR__SIMDF_CONST", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2566, + "column": 1, + "source_line": "static const STBIR__SIMDF_CONST(STBIR_max_uint8_as_float, stbir__max_uint8_as_float);" + }, + "source_text": "static const STBIR__SIMDF_CONST(STBIR_max_uint8_as_float, stbir__max_uint8_as_float)" + }, + { + "name": "STBIR__SIMDF_CONST", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2567, + "column": 1, + "source_line": "static const STBIR__SIMDF_CONST(STBIR_max_uint16_as_float, stbir__max_uint16_as_float);" + }, + "source_text": "static const STBIR__SIMDF_CONST(STBIR_max_uint16_as_float, stbir__max_uint16_as_float)" + }, + { + "name": "STBIR__SIMDF_CONST", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2568, + "column": 1, + "source_line": "static const STBIR__SIMDF_CONST(STBIR_max_uint8_as_float_inverted, stbir__max_uint8_as_float_inverted);" + }, + "source_text": "static const STBIR__SIMDF_CONST(STBIR_max_uint8_as_float_inverted, stbir__max_uint8_as_float_inverted)" + }, + { + "name": "STBIR__SIMDF_CONST", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2569, + "column": 1, + "source_line": "static const STBIR__SIMDF_CONST(STBIR_max_uint16_as_float_inverted, stbir__max_uint16_as_float_inverted);" + }, + "source_text": "static const STBIR__SIMDF_CONST(STBIR_max_uint16_as_float_inverted, stbir__max_uint16_as_float_inverted)" + }, + { + "name": "STBIR__SIMDF_CONST", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2571, + "column": 1, + "source_line": "static const STBIR__SIMDF_CONST(STBIR_simd_point5, 0.5f);" + }, + "source_text": "static const STBIR__SIMDF_CONST(STBIR_simd_point5, 0.5f)" + }, + { + "name": "STBIR__SIMDF_CONST", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2572, + "column": 1, + "source_line": "static const STBIR__SIMDF_CONST(STBIR_ones, 1.0f);" + }, + "source_text": "static const STBIR__SIMDF_CONST(STBIR_ones, 1.0f)" + }, + { + "name": "STBIR__SIMDI_CONST", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2573, + "column": 1, + "source_line": "static const STBIR__SIMDI_CONST(STBIR_almost_zero, (127 - 13) << 23);" + }, + "source_text": "static const STBIR__SIMDI_CONST(STBIR_almost_zero, (127 - 13) << 23)" + }, + { + "name": "STBIR__SIMDI_CONST", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2574, + "column": 1, + "source_line": "static const STBIR__SIMDI_CONST(STBIR_almost_one, 0x3f7fffff);" + }, + "source_text": "static const STBIR__SIMDI_CONST(STBIR_almost_one, 0x3f7fffff)" + }, + { + "name": "STBIR__SIMDI_CONST", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2575, + "column": 1, + "source_line": "static const STBIR__SIMDI_CONST(STBIR_mantissa_mask, 0xff);" + }, + "source_text": "static const STBIR__SIMDI_CONST(STBIR_mantissa_mask, 0xff)" + }, + { + "name": "STBIR__SIMDI_CONST", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2576, + "column": 1, + "source_line": "static const STBIR__SIMDI_CONST(STBIR_topscale, 0x02000000);" + }, + "source_text": "static const STBIR__SIMDI_CONST(STBIR_topscale, 0x02000000)" + }, + { + "name": "STBIRDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2735, + "column": 3, + "source_line": " STBIRDEF stbir_uint64 __rdtsc();" + }, + "source_text": "STBIRDEF stbir_uint64 __rdtsc()" + }, + { + "name": "STBIR_PROFILE_FUNC", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2740, + "column": 3, + "source_line": " static stbir__inline stbir_uint64 STBIR_PROFILE_FUNC()" + }, + "source_text": "static stbir__inline stbir_uint64 STBIR_PROFILE_FUNC()" + }, + { + "name": "STBIR_PROFILE_FUNC", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2757, + "column": 3, + "source_line": " static stbir__inline stbir_uint64 STBIR_PROFILE_FUNC()" + }, + "source_text": "static stbir__inline stbir_uint64 STBIR_PROFILE_FUNC()" + }, + { + "name": "stbir__inline", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 3110, + "column": 1, + "source_line": "stbir__inline static int stbir__edge_wrap(stbir_edge edge, int n, int max)" + }, + "source_text": "stbir__inline static int stbir__edge_wrap(stbir_edge edge, int n, int max)" + }, + { + "name": "STBIRDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 7720, + "column": 1, + "source_line": "STBIRDEF void stbir_resize_init( STBIR_RESIZE * resize," + }, + "source_text": "STBIRDEF void stbir_resize_init( STBIR_RESIZE * resize,\n const void *input_pixels, int input_w, int input_h, int input_stride_in_bytes, \n void *output_pixels, int output_w, int output_h, int output_stride_in_bytes, \n stbir_pixel_layout pixel_layout, stbir_datatype data_type )" + }, + { + "name": "STBIRDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 7739, + "column": 1, + "source_line": "STBIRDEF void stbir_set_datatypes( STBIR_RESIZE * resize, stbir_datatype input_type, stbir_datatype output_type ) // by default, datatype from resize_init" + }, + "source_text": "STBIRDEF void stbir_set_datatypes( STBIR_RESIZE * resize, stbir_datatype input_type, stbir_datatype output_type )" + }, + { + "name": "STBIRDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 7747, + "column": 1, + "source_line": "STBIRDEF void stbir_set_pixel_callbacks( STBIR_RESIZE * resize, stbir_input_callback * input_cb, stbir_output_callback * output_cb ) // no callbacks by default" + }, + "source_text": "STBIRDEF void stbir_set_pixel_callbacks( STBIR_RESIZE * resize, stbir_input_callback * input_cb, stbir_output_callback * output_cb )" + }, + { + "name": "STBIRDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 7759, + "column": 1, + "source_line": "STBIRDEF void stbir_set_user_data( STBIR_RESIZE * resize, void * user_data ) // pass back STBIR_RESIZE* by default" + }, + "source_text": "STBIRDEF void stbir_set_user_data( STBIR_RESIZE * resize, void * user_data )" + }, + { + "name": "STBIRDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 7766, + "column": 1, + "source_line": "STBIRDEF void stbir_set_buffer_ptrs( STBIR_RESIZE * resize, const void * input_pixels, int input_stride_in_bytes, void * output_pixels, int output_stride_in_bytes )" + }, + "source_text": "STBIRDEF void stbir_set_buffer_ptrs( STBIR_RESIZE * resize, const void * input_pixels, int input_stride_in_bytes, void * output_pixels, int output_stride_in_bytes )" + }, + { + "name": "STBIRDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 7777, + "column": 1, + "source_line": "STBIRDEF int stbir_set_edgemodes( STBIR_RESIZE * resize, stbir_edge horizontal_edge, stbir_edge vertical_edge ) // CLAMP by default" + }, + "source_text": "STBIRDEF int stbir_set_edgemodes( STBIR_RESIZE * resize, stbir_edge horizontal_edge, stbir_edge vertical_edge )" + }, + { + "name": "STBIRDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 7785, + "column": 1, + "source_line": "STBIRDEF int stbir_set_filters( STBIR_RESIZE * resize, stbir_filter horizontal_filter, stbir_filter vertical_filter ) // STBIR_DEFAULT_FILTER_UPSAMPLE/DOWNSAMPLE by default" + }, + "source_text": "STBIRDEF int stbir_set_filters( STBIR_RESIZE * resize, stbir_filter horizontal_filter, stbir_filter vertical_filter )" + }, + { + "name": "STBIRDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 7793, + "column": 1, + "source_line": "STBIRDEF int stbir_set_filter_callbacks( STBIR_RESIZE * resize, stbir__kernel_callback * horizontal_filter, stbir__support_callback * horizontal_support, stbir__kernel_callback * vertical_filter, stbir__support_callback * vertical_support )" + }, + "source_text": "STBIRDEF int stbir_set_filter_callbacks( STBIR_RESIZE * resize, stbir__kernel_callback * horizontal_filter, stbir__support_callback * horizontal_support, stbir__kernel_callback * vertical_filter, stbir__support_callback * vertical_support )" + }, + { + "name": "STBIRDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 7801, + "column": 1, + "source_line": "STBIRDEF int stbir_set_pixel_layouts( STBIR_RESIZE * resize, stbir_pixel_layout input_pixel_layout, stbir_pixel_layout output_pixel_layout ) // sets new pixel layouts" + }, + "source_text": "STBIRDEF int stbir_set_pixel_layouts( STBIR_RESIZE * resize, stbir_pixel_layout input_pixel_layout, stbir_pixel_layout output_pixel_layout )" + }, + { + "name": "STBIRDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 7810, + "column": 1, + "source_line": "STBIRDEF int stbir_set_non_pm_alpha_speed_over_quality( STBIR_RESIZE * resize, int non_pma_alpha_speed_over_quality ) // sets alpha speed" + }, + "source_text": "STBIRDEF int stbir_set_non_pm_alpha_speed_over_quality( STBIR_RESIZE * resize, int non_pma_alpha_speed_over_quality )" + }, + { + "name": "STBIRDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 7817, + "column": 1, + "source_line": "STBIRDEF int stbir_set_input_subrect( STBIR_RESIZE * resize, double s0, double t0, double s1, double t1 ) // sets input region (full region by default)" + }, + "source_text": "STBIRDEF int stbir_set_input_subrect( STBIR_RESIZE * resize, double s0, double t0, double s1, double t1 )" + }, + { + "name": "STBIRDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 7835, + "column": 1, + "source_line": "STBIRDEF int stbir_set_output_pixel_subrect( STBIR_RESIZE * resize, int subx, int suby, int subw, int subh ) // sets input region (full region by default)" + }, + "source_text": "STBIRDEF int stbir_set_output_pixel_subrect( STBIR_RESIZE * resize, int subx, int suby, int subw, int subh )" + }, + { + "name": "STBIRDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 7850, + "column": 1, + "source_line": "STBIRDEF int stbir_set_pixel_subrect( STBIR_RESIZE * resize, int subx, int suby, int subw, int subh ) // sets both regions (full regions by default)" + }, + "source_text": "STBIRDEF int stbir_set_pixel_subrect( STBIR_RESIZE * resize, int subx, int suby, int subw, int subh )" + }, + { + "name": "STBIRDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 7949, + "column": 1, + "source_line": "STBIRDEF void stbir_free_samplers( STBIR_RESIZE * resize )" + }, + "source_text": "STBIRDEF void stbir_free_samplers( STBIR_RESIZE * resize )" + }, + { + "name": "STBIRDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 7959, + "column": 1, + "source_line": "STBIRDEF int stbir_build_samplers_with_splits( STBIR_RESIZE * resize, int splits )" + }, + "source_text": "STBIRDEF int stbir_build_samplers_with_splits( STBIR_RESIZE * resize, int splits )" + }, + { + "name": "STBIRDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 7975, + "column": 1, + "source_line": "STBIRDEF int stbir_build_samplers( STBIR_RESIZE * resize )" + }, + "source_text": "STBIRDEF int stbir_build_samplers( STBIR_RESIZE * resize )" + }, + { + "name": "STBIRDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 7980, + "column": 1, + "source_line": "STBIRDEF int stbir_resize_extended( STBIR_RESIZE * resize )" + }, + "source_text": "STBIRDEF int stbir_resize_extended( STBIR_RESIZE * resize )" + }, + { + "name": "STBIRDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8024, + "column": 1, + "source_line": "STBIRDEF int stbir_resize_extended_split( STBIR_RESIZE * resize, int split_start, int split_count )" + }, + "source_text": "STBIRDEF int stbir_resize_extended_split( STBIR_RESIZE * resize, int split_start, int split_count )" + }, + { + "name": "STBIRDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8120, + "column": 1, + "source_line": "STBIRDEF unsigned char * stbir_resize_uint8_linear( const unsigned char *input_pixels , int input_w , int input_h, int input_stride_in_bytes," + }, + "source_text": "STBIRDEF unsigned char * stbir_resize_uint8_linear( const unsigned char *input_pixels , int input_w , int input_h, int input_stride_in_bytes,\n unsigned char *output_pixels, int output_w, int output_h, int output_stride_in_bytes,\n stbir_pixel_layout pixel_layout )" + }, + { + "name": "STBIRDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8129, + "column": 1, + "source_line": "STBIRDEF unsigned char * stbir_resize_uint8_srgb( const unsigned char *input_pixels , int input_w , int input_h, int input_stride_in_bytes," + }, + "source_text": "STBIRDEF unsigned char * stbir_resize_uint8_srgb( const unsigned char *input_pixels , int input_w , int input_h, int input_stride_in_bytes,\n unsigned char *output_pixels, int output_w, int output_h, int output_stride_in_bytes,\n stbir_pixel_layout pixel_layout )" + }, + { + "name": "STBIRDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8139, + "column": 1, + "source_line": "STBIRDEF float * stbir_resize_float_linear( const float *input_pixels , int input_w , int input_h, int input_stride_in_bytes," + }, + "source_text": "STBIRDEF float * stbir_resize_float_linear( const float *input_pixels , int input_w , int input_h, int input_stride_in_bytes,\n float *output_pixels, int output_w, int output_h, int output_stride_in_bytes,\n stbir_pixel_layout pixel_layout )" + }, + { + "name": "STBIRDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8149, + "column": 1, + "source_line": "STBIRDEF void * stbir_resize( const void *input_pixels , int input_w , int input_h, int input_stride_in_bytes," + }, + "source_text": "STBIRDEF void * stbir_resize( const void *input_pixels , int input_w , int input_h, int input_stride_in_bytes,\n void *output_pixels, int output_w, int output_h, int output_stride_in_bytes,\n stbir_pixel_layout pixel_layout, stbir_datatype data_type,\n stbir_edge edge, stbir_filter filter )" + }, + { + "name": "STBIRDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8161, + "column": 1, + "source_line": "STBIRDEF void stbir_resize_build_profile_info( STBIR_PROFILE_INFO * info, STBIR_RESIZE const * resize )" + }, + "source_text": "STBIRDEF void stbir_resize_build_profile_info( STBIR_PROFILE_INFO * info, STBIR_RESIZE const * resize )" + }, + { + "name": "STBIRDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8179, + "column": 1, + "source_line": "STBIRDEF void stbir_resize_split_profile_info( STBIR_PROFILE_INFO * info, STBIR_RESIZE const * resize, int split_start, int split_count )" + }, + "source_text": "STBIRDEF void stbir_resize_split_profile_info( STBIR_PROFILE_INFO * info, STBIR_RESIZE const * resize, int split_start, int split_count )" + }, + { + "name": "STBIRDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8219, + "column": 1, + "source_line": "STBIRDEF void stbir_resize_extended_profile_info( STBIR_PROFILE_INFO * info, STBIR_RESIZE const * resize )" + }, + "source_text": "STBIRDEF void stbir_resize_extended_profile_info( STBIR_PROFILE_INFO * info, STBIR_RESIZE const * resize )" + }, + { + "name": "STBIR__CODER_NAME", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8293, + "column": 1, + "source_line": "static float * STBIR__CODER_NAME( stbir__decode_uint8_linear_scaled )( float * decodep, int width_times_channels, void const * inputp )" + }, + "source_text": "static float * STBIR__CODER_NAME( stbir__decode_uint8_linear_scaled )( float * decodep, int width_times_channels, void const * inputp )" + }, + { + "name": "STBIR__CODER_NAME", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8395, + "column": 1, + "source_line": "static void STBIR__CODER_NAME( stbir__encode_uint8_linear_scaled )( void * outputp, int width_times_channels, float const * encode )" + }, + "source_text": "static void STBIR__CODER_NAME( stbir__encode_uint8_linear_scaled )( void * outputp, int width_times_channels, float const * encode )" + }, + { + "name": "STBIR__CODER_NAME", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8512, + "column": 1, + "source_line": "static float * STBIR__CODER_NAME(stbir__decode_uint8_linear)( float * decodep, int width_times_channels, void const * inputp )" + }, + "source_text": "static float * STBIR__CODER_NAME(stbir__decode_uint8_linear)( float * decodep, int width_times_channels, void const * inputp )" + }, + { + "name": "STBIR__CODER_NAME", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8607, + "column": 1, + "source_line": "static void STBIR__CODER_NAME( stbir__encode_uint8_linear )( void * outputp, int width_times_channels, float const * encode )" + }, + "source_text": "static void STBIR__CODER_NAME( stbir__encode_uint8_linear )( void * outputp, int width_times_channels, float const * encode )" + }, + { + "name": "STBIR__CODER_NAME", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8706, + "column": 1, + "source_line": "static float * STBIR__CODER_NAME(stbir__decode_uint8_srgb)( float * decodep, int width_times_channels, void const * inputp )" + }, + "source_text": "static float * STBIR__CODER_NAME(stbir__decode_uint8_srgb)( float * decodep, int width_times_channels, void const * inputp )" + }, + { + "name": "STBIR__CODER_NAME", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8810, + "column": 1, + "source_line": "static void STBIR__CODER_NAME( stbir__encode_uint8_srgb )( void * outputp, int width_times_channels, float const * encode )" + }, + "source_text": "static void STBIR__CODER_NAME( stbir__encode_uint8_srgb )( void * outputp, int width_times_channels, float const * encode )" + }, + { + "name": "STBIR__CODER_NAME", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8897, + "column": 1, + "source_line": "static float * STBIR__CODER_NAME(stbir__decode_uint8_srgb4_linearalpha)( float * decodep, int width_times_channels, void const * inputp )" + }, + "source_text": "static float * STBIR__CODER_NAME(stbir__decode_uint8_srgb4_linearalpha)( float * decodep, int width_times_channels, void const * inputp )" + }, + { + "name": "STBIR__CODER_NAME", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8915, + "column": 1, + "source_line": "static void STBIR__CODER_NAME( stbir__encode_uint8_srgb4_linearalpha )( void * outputp, int width_times_channels, float const * encode )" + }, + "source_text": "static void STBIR__CODER_NAME( stbir__encode_uint8_srgb4_linearalpha )( void * outputp, int width_times_channels, float const * encode )" + }, + { + "name": "STBIR__CODER_NAME", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8984, + "column": 1, + "source_line": "static float * STBIR__CODER_NAME(stbir__decode_uint8_srgb2_linearalpha)( float * decodep, int width_times_channels, void const * inputp )" + }, + "source_text": "static float * STBIR__CODER_NAME(stbir__decode_uint8_srgb2_linearalpha)( float * decodep, int width_times_channels, void const * inputp )" + }, + { + "name": "STBIR__CODER_NAME", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9009, + "column": 1, + "source_line": "static void STBIR__CODER_NAME( stbir__encode_uint8_srgb2_linearalpha )( void * outputp, int width_times_channels, float const * encode )" + }, + "source_text": "static void STBIR__CODER_NAME( stbir__encode_uint8_srgb2_linearalpha )( void * outputp, int width_times_channels, float const * encode )" + }, + { + "name": "STBIR__CODER_NAME", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9072, + "column": 1, + "source_line": "static float * STBIR__CODER_NAME(stbir__decode_uint16_linear_scaled)( float * decodep, int width_times_channels, void const * inputp )" + }, + "source_text": "static float * STBIR__CODER_NAME(stbir__decode_uint16_linear_scaled)( float * decodep, int width_times_channels, void const * inputp )" + }, + { + "name": "STBIR__CODER_NAME", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9162, + "column": 1, + "source_line": "static void STBIR__CODER_NAME(stbir__encode_uint16_linear_scaled)( void * outputp, int width_times_channels, float const * encode )" + }, + "source_text": "static void STBIR__CODER_NAME(stbir__encode_uint16_linear_scaled)( void * outputp, int width_times_channels, float const * encode )" + }, + { + "name": "STBIR__CODER_NAME", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9278, + "column": 1, + "source_line": "static float * STBIR__CODER_NAME(stbir__decode_uint16_linear)( float * decodep, int width_times_channels, void const * inputp )" + }, + "source_text": "static float * STBIR__CODER_NAME(stbir__decode_uint16_linear)( float * decodep, int width_times_channels, void const * inputp )" + }, + { + "name": "STBIR__CODER_NAME", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9364, + "column": 1, + "source_line": "static void STBIR__CODER_NAME(stbir__encode_uint16_linear)( void * outputp, int width_times_channels, float const * encode )" + }, + "source_text": "static void STBIR__CODER_NAME(stbir__encode_uint16_linear)( void * outputp, int width_times_channels, float const * encode )" + }, + { + "name": "STBIR__CODER_NAME", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9462, + "column": 1, + "source_line": "static float * STBIR__CODER_NAME(stbir__decode_half_float_linear)( float * decodep, int width_times_channels, void const * inputp )" + }, + "source_text": "static float * STBIR__CODER_NAME(stbir__decode_half_float_linear)( float * decodep, int width_times_channels, void const * inputp )" + }, + { + "name": "STBIR__CODER_NAME", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9549, + "column": 1, + "source_line": "static void STBIR__CODER_NAME( stbir__encode_half_float_linear )( void * outputp, int width_times_channels, float const * encode )" + }, + "source_text": "static void STBIR__CODER_NAME( stbir__encode_half_float_linear )( void * outputp, int width_times_channels, float const * encode )" + }, + { + "name": "STBIR__CODER_NAME", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9633, + "column": 1, + "source_line": "static float * STBIR__CODER_NAME(stbir__decode_float_linear)( float * decodep, int width_times_channels, void const * inputp )" + }, + "source_text": "static float * STBIR__CODER_NAME(stbir__decode_float_linear)( float * decodep, int width_times_channels, void const * inputp )" + }, + { + "name": "STBIR__CODER_NAME", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9737, + "column": 1, + "source_line": "static void STBIR__CODER_NAME( stbir__encode_float_linear )( void * outputp, int width_times_channels, float const * encode )" + }, + "source_text": "static void STBIR__CODER_NAME( stbir__encode_float_linear )( void * outputp, int width_times_channels, float const * encode )" + }, + { + "name": "STBIR_chans", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9942, + "column": 1, + "source_line": "static void STBIR_chans( stbir__vertical_scatter_with_,_coeffs)( float ** outputs, float const * vertical_coefficients, float const * input, float const * input_end )" + }, + "source_text": "static void STBIR_chans( stbir__vertical_scatter_with_,_coeffs)( float ** outputs, float const * vertical_coefficients, float const * input, float const * input_end )" + }, + { + "name": "STBIR_chans", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10114, + "column": 1, + "source_line": "static void STBIR_chans( stbir__vertical_gather_with_,_coeffs)( float * outputp, float const * vertical_coefficients, float const ** inputs, float const * input0_end )" + }, + "source_text": "static void STBIR_chans( stbir__vertical_gather_with_,_coeffs)( float * outputp, float const * vertical_coefficients, float const ** inputs, float const * input0_end )" + }, + { + "name": "STBIR_chans", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10328, + "column": 1, + "source_line": "static void STBIR_chans( stbir__horizontal_gather_,_channels_with_1_coeff)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )" + }, + "source_text": "static void STBIR_chans( stbir__horizontal_gather_,_channels_with_1_coeff)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )" + }, + { + "name": "STBIR_chans", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10341, + "column": 1, + "source_line": "static void STBIR_chans( stbir__horizontal_gather_,_channels_with_2_coeffs)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )" + }, + "source_text": "static void STBIR_chans( stbir__horizontal_gather_,_channels_with_2_coeffs)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )" + }, + { + "name": "STBIR_chans", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10354, + "column": 1, + "source_line": "static void STBIR_chans( stbir__horizontal_gather_,_channels_with_3_coeffs)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )" + }, + "source_text": "static void STBIR_chans( stbir__horizontal_gather_,_channels_with_3_coeffs)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )" + }, + { + "name": "STBIR_chans", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10367, + "column": 1, + "source_line": "static void STBIR_chans( stbir__horizontal_gather_,_channels_with_4_coeffs)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )" + }, + "source_text": "static void STBIR_chans( stbir__horizontal_gather_,_channels_with_4_coeffs)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )" + }, + { + "name": "STBIR_chans", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10380, + "column": 1, + "source_line": "static void STBIR_chans( stbir__horizontal_gather_,_channels_with_5_coeffs)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )" + }, + "source_text": "static void STBIR_chans( stbir__horizontal_gather_,_channels_with_5_coeffs)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )" + }, + { + "name": "STBIR_chans", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10394, + "column": 1, + "source_line": "static void STBIR_chans( stbir__horizontal_gather_,_channels_with_6_coeffs)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )" + }, + "source_text": "static void STBIR_chans( stbir__horizontal_gather_,_channels_with_6_coeffs)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )" + }, + { + "name": "STBIR_chans", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10408, + "column": 1, + "source_line": "static void STBIR_chans( stbir__horizontal_gather_,_channels_with_7_coeffs)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )" + }, + "source_text": "static void STBIR_chans( stbir__horizontal_gather_,_channels_with_7_coeffs)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )" + }, + { + "name": "STBIR_chans", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10424, + "column": 1, + "source_line": "static void STBIR_chans( stbir__horizontal_gather_,_channels_with_8_coeffs)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )" + }, + "source_text": "static void STBIR_chans( stbir__horizontal_gather_,_channels_with_8_coeffs)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )" + }, + { + "name": "STBIR_chans", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10438, + "column": 1, + "source_line": "static void STBIR_chans( stbir__horizontal_gather_,_channels_with_9_coeffs)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )" + }, + "source_text": "static void STBIR_chans( stbir__horizontal_gather_,_channels_with_9_coeffs)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )" + }, + { + "name": "STBIR_chans", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10453, + "column": 1, + "source_line": "static void STBIR_chans( stbir__horizontal_gather_,_channels_with_10_coeffs)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )" + }, + "source_text": "static void STBIR_chans( stbir__horizontal_gather_,_channels_with_10_coeffs)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )" + }, + { + "name": "STBIR_chans", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10468, + "column": 1, + "source_line": "static void STBIR_chans( stbir__horizontal_gather_,_channels_with_11_coeffs)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )" + }, + "source_text": "static void STBIR_chans( stbir__horizontal_gather_,_channels_with_11_coeffs)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )" + }, + { + "name": "STBIR_chans", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10484, + "column": 1, + "source_line": "static void STBIR_chans( stbir__horizontal_gather_,_channels_with_12_coeffs)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )" + }, + "source_text": "static void STBIR_chans( stbir__horizontal_gather_,_channels_with_12_coeffs)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )" + }, + { + "name": "STBIR_chans", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10499, + "column": 1, + "source_line": "static void STBIR_chans( stbir__horizontal_gather_,_channels_with_n_coeffs_mod0 )( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )" + }, + "source_text": "static void STBIR_chans( stbir__horizontal_gather_,_channels_with_n_coeffs_mod0 )( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )" + }, + { + "name": "STBIR_chans", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10521, + "column": 1, + "source_line": "static void STBIR_chans( stbir__horizontal_gather_,_channels_with_n_coeffs_mod1 )( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )" + }, + "source_text": "static void STBIR_chans( stbir__horizontal_gather_,_channels_with_n_coeffs_mod1 )( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )" + }, + { + "name": "STBIR_chans", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10544, + "column": 1, + "source_line": "static void STBIR_chans( stbir__horizontal_gather_,_channels_with_n_coeffs_mod2 )( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )" + }, + "source_text": "static void STBIR_chans( stbir__horizontal_gather_,_channels_with_n_coeffs_mod2 )( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )" + }, + { + "name": "STBIR_chans", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10568, + "column": 1, + "source_line": "static void STBIR_chans( stbir__horizontal_gather_,_channels_with_n_coeffs_mod3 )( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )" + }, + "source_text": "static void STBIR_chans( stbir__horizontal_gather_,_channels_with_n_coeffs_mod3 )( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )" + }, + { + "name": "STBIR_chans", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10593, + "column": 1, + "source_line": "static stbir__horizontal_gather_channels_func * STBIR_chans(stbir__horizontal_gather_,_channels_with_n_coeffs_funcs)[4]=" + }, + "source_text": "static stbir__horizontal_gather_channels_func * STBIR_chans(stbir__horizontal_gather_,_channels_with_n_coeffs_funcs)[4]=" + }, + { + "name": "STBIR_chans", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10601, + "column": 1, + "source_line": "static stbir__horizontal_gather_channels_func * STBIR_chans(stbir__horizontal_gather_,_channels_funcs)[12]=" + }, + "source_text": "static stbir__horizontal_gather_channels_func * STBIR_chans(stbir__horizontal_gather_,_channels_funcs)[12]=" + } + ], + "diagnostics": [ + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_ASSERT' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 787, + "column": 1, + "source_line": "#define STBIR_ASSERT(x) assert(x)" + }, + "unit_kind": "macro", + "unit_name": "STBIR_ASSERT" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_MALLOC' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 792, + "column": 1, + "source_line": "#define STBIR_MALLOC(size,user_data) ((void)(user_data), malloc(size))" + }, + "unit_kind": "macro", + "unit_name": "STBIR_MALLOC" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_FREE' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 793, + "column": 1, + "source_line": "#define STBIR_FREE(ptr,user_data) ((void)(user_data), free(ptr))" + }, + "unit_kind": "macro", + "unit_name": "STBIR_FREE" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR__UNUSED' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 838, + "column": 1, + "source_line": "#define STBIR__UNUSED(v) (void)(v)" + }, + "unit_kind": "macro", + "unit_name": "STBIR__UNUSED" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR__UNUSED' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 840, + "column": 1, + "source_line": "#define STBIR__UNUSED(v) (void)sizeof(v)" + }, + "unit_kind": "macro", + "unit_name": "STBIR__UNUSED" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR__ARRAY_SIZE' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 843, + "column": 1, + "source_line": "#define STBIR__ARRAY_SIZE(a) (sizeof((a))/sizeof((a)[0]))" + }, + "unit_kind": "macro", + "unit_name": "STBIR__ARRAY_SIZE" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_CLAMP' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1071, + "column": 1, + "source_line": "#define STBIR_CLAMP(x, xmin, xmax) for(;;) { \\" + }, + "unit_kind": "macro", + "unit_name": "STBIR_CLAMP" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_STREAMOUT_PTR' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1237, + "column": 3, + "source_line": " #define STBIR_STREAMOUT_PTR( star ) star __restrict" + }, + "unit_kind": "macro", + "unit_name": "STBIR_STREAMOUT_PTR" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_NO_UNROLL' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1238, + "column": 3, + "source_line": " #define STBIR_NO_UNROLL( ptr ) __assume(ptr) // this oddly keeps msvc from unrolling a loop" + }, + "unit_kind": "macro", + "unit_name": "STBIR_NO_UNROLL" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_STREAMOUT_PTR' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1245, + "column": 3, + "source_line": " #define STBIR_STREAMOUT_PTR( star ) star __restrict__" + }, + "unit_kind": "macro", + "unit_name": "STBIR_STREAMOUT_PTR" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_NO_UNROLL' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1246, + "column": 3, + "source_line": " #define STBIR_NO_UNROLL( ptr ) __asm__ (\"\"::\"r\"(ptr)) " + }, + "unit_kind": "macro", + "unit_name": "STBIR_NO_UNROLL" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_STREAMOUT_PTR' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1253, + "column": 3, + "source_line": " #define STBIR_STREAMOUT_PTR( star ) star __restrict__" + }, + "unit_kind": "macro", + "unit_name": "STBIR_STREAMOUT_PTR" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_NO_UNROLL' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1254, + "column": 3, + "source_line": " #define STBIR_NO_UNROLL( ptr ) __asm__ (\"\"::\"r\"(ptr))" + }, + "unit_kind": "macro", + "unit_name": "STBIR_NO_UNROLL" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_STREAMOUT_PTR' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1262, + "column": 3, + "source_line": " #define STBIR_STREAMOUT_PTR( star ) star" + }, + "unit_kind": "macro", + "unit_name": "STBIR_STREAMOUT_PTR" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_NO_UNROLL' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1263, + "column": 3, + "source_line": " #define STBIR_NO_UNROLL( ptr )" + }, + "unit_kind": "macro", + "unit_name": "STBIR_NO_UNROLL" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir_simdi_castf' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1311, + "column": 3, + "source_line": " #define stbir_simdi_castf( reg ) _mm_castps_si128(reg)" + }, + "unit_kind": "macro", + "unit_name": "stbir_simdi_castf" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir_simdf_casti' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1312, + "column": 3, + "source_line": " #define stbir_simdf_casti( reg ) _mm_castsi128_ps(reg)" + }, + "unit_kind": "macro", + "unit_name": "stbir_simdf_casti" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_load' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1314, + "column": 3, + "source_line": " #define stbir__simdf_load( reg, ptr ) (reg) = _mm_loadu_ps( (float const*)(ptr) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_load" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_load' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1315, + "column": 3, + "source_line": " #define stbir__simdi_load( reg, ptr ) (reg) = _mm_loadu_si128 ( (stbir__simdi const*)(ptr) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_load" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_load1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1316, + "column": 3, + "source_line": " #define stbir__simdf_load1( out, ptr ) (out) = _mm_load_ss( (float const*)(ptr) ) // top values can be random (not denormal or nan for perf)" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_load1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_load1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1317, + "column": 3, + "source_line": " #define stbir__simdi_load1( out, ptr ) (out) = _mm_castps_si128( _mm_load_ss( (float const*)(ptr) ))" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_load1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_load1z' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1318, + "column": 3, + "source_line": " #define stbir__simdf_load1z( out, ptr ) (out) = _mm_load_ss( (float const*)(ptr) ) // top values must be zero" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_load1z" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_frep4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1319, + "column": 3, + "source_line": " #define stbir__simdf_frep4( fvar ) _mm_set_ps1( fvar )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_frep4" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_load1frep4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1320, + "column": 3, + "source_line": " #define stbir__simdf_load1frep4( out, fvar ) (out) = _mm_set_ps1( fvar )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_load1frep4" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_load2' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1321, + "column": 3, + "source_line": " #define stbir__simdf_load2( out, ptr ) (out) = _mm_castsi128_ps( _mm_loadl_epi64( (__m128i*)(ptr)) ) // top values can be random (not denormal or nan for perf)" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_load2" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_load2z' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1322, + "column": 3, + "source_line": " #define stbir__simdf_load2z( out, ptr ) (out) = _mm_castsi128_ps( _mm_loadl_epi64( (__m128i*)(ptr)) ) // top values must be zero" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_load2z" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_load2hmerge' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1323, + "column": 3, + "source_line": " #define stbir__simdf_load2hmerge( out, reg, ptr ) (out) = _mm_castpd_ps(_mm_loadh_pd( _mm_castps_pd(reg), (double*)(ptr) ))" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_load2hmerge" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_zeroP' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1325, + "column": 3, + "source_line": " #define stbir__simdf_zeroP() _mm_setzero_ps()" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_zeroP" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_zero' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1326, + "column": 3, + "source_line": " #define stbir__simdf_zero( reg ) (reg) = _mm_setzero_ps()" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_zero" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_store' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1328, + "column": 3, + "source_line": " #define stbir__simdf_store( ptr, reg ) _mm_storeu_ps( (float*)(ptr), reg )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_store" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_store1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1329, + "column": 3, + "source_line": " #define stbir__simdf_store1( ptr, reg ) _mm_store_ss( (float*)(ptr), reg )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_store1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_store2' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1330, + "column": 3, + "source_line": " #define stbir__simdf_store2( ptr, reg ) _mm_storel_epi64( (__m128i*)(ptr), _mm_castps_si128(reg) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_store2" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_store2h' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1331, + "column": 3, + "source_line": " #define stbir__simdf_store2h( ptr, reg ) _mm_storeh_pd( (double*)(ptr), _mm_castps_pd(reg) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_store2h" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_store' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1333, + "column": 3, + "source_line": " #define stbir__simdi_store( ptr, reg ) _mm_storeu_si128( (__m128i*)(ptr), reg )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_store" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_store1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1334, + "column": 3, + "source_line": " #define stbir__simdi_store1( ptr, reg ) _mm_store_ss( (float*)(ptr), _mm_castsi128_ps(reg) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_store1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_store2' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1335, + "column": 3, + "source_line": " #define stbir__simdi_store2( ptr, reg ) _mm_storel_epi64( (__m128i*)(ptr), (reg) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_store2" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__prefetch' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1337, + "column": 3, + "source_line": " #define stbir__prefetch( ptr ) _mm_prefetch((char*)(ptr), _MM_HINT_T0 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__prefetch" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_expand_u8_to_u32' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1339, + "column": 3, + "source_line": " #define stbir__simdi_expand_u8_to_u32(out0,out1,out2,out3,ireg) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_expand_u8_to_u32" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_expand_u8_to_1u32' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1350, + "column": 1, + "source_line": "#define stbir__simdi_expand_u8_to_1u32(out,ireg) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_expand_u8_to_1u32" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_expand_u16_to_u32' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1357, + "column": 3, + "source_line": " #define stbir__simdi_expand_u16_to_u32(out0,out1,ireg) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_expand_u16_to_u32" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_convert_float_to_i32' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1364, + "column": 3, + "source_line": " #define stbir__simdf_convert_float_to_i32( i, f ) (i) = _mm_cvttps_epi32(f)" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_convert_float_to_i32" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_convert_float_to_int' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1365, + "column": 3, + "source_line": " #define stbir__simdf_convert_float_to_int( f ) _mm_cvtt_ss2si(f)" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_convert_float_to_int" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_convert_float_to_uint8' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1366, + "column": 3, + "source_line": " #define stbir__simdf_convert_float_to_uint8( f ) ((unsigned char)_mm_cvtsi128_si32(_mm_cvttps_epi32(_mm_max_ps(_mm_min_ps(f,STBIR__CONSTF(STBIR_max_uint8_as_float)),_mm_setzero_ps()))))" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_convert_float_to_uint8" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_convert_float_to_short' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1367, + "column": 3, + "source_line": " #define stbir__simdf_convert_float_to_short( f ) ((unsigned short)_mm_cvtsi128_si32(_mm_cvttps_epi32(_mm_max_ps(_mm_min_ps(f,STBIR__CONSTF(STBIR_max_uint16_as_float)),_mm_setzero_ps()))))" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_convert_float_to_short" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_to_int' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1369, + "column": 3, + "source_line": " #define stbir__simdi_to_int( i ) _mm_cvtsi128_si32(i)" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_to_int" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_convert_i32_to_float' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1370, + "column": 3, + "source_line": " #define stbir__simdi_convert_i32_to_float(out, ireg) (out) = _mm_cvtepi32_ps( ireg )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_convert_i32_to_float" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_add' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1371, + "column": 3, + "source_line": " #define stbir__simdf_add( out, reg0, reg1 ) (out) = _mm_add_ps( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_add" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_mult' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1372, + "column": 3, + "source_line": " #define stbir__simdf_mult( out, reg0, reg1 ) (out) = _mm_mul_ps( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_mult" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_mult_mem' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1373, + "column": 3, + "source_line": " #define stbir__simdf_mult_mem( out, reg, ptr ) (out) = _mm_mul_ps( reg, _mm_loadu_ps( (float const*)(ptr) ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_mult_mem" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_mult1_mem' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1374, + "column": 3, + "source_line": " #define stbir__simdf_mult1_mem( out, reg, ptr ) (out) = _mm_mul_ss( reg, _mm_load_ss( (float const*)(ptr) ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_mult1_mem" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_add_mem' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1375, + "column": 3, + "source_line": " #define stbir__simdf_add_mem( out, reg, ptr ) (out) = _mm_add_ps( reg, _mm_loadu_ps( (float const*)(ptr) ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_add_mem" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_add1_mem' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1376, + "column": 3, + "source_line": " #define stbir__simdf_add1_mem( out, reg, ptr ) (out) = _mm_add_ss( reg, _mm_load_ss( (float const*)(ptr) ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_add1_mem" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_madd' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1380, + "column": 3, + "source_line": " #define stbir__simdf_madd( out, add, mul1, mul2 ) (out) = _mm_fmadd_ps( mul1, mul2, add )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_madd" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_madd1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1381, + "column": 3, + "source_line": " #define stbir__simdf_madd1( out, add, mul1, mul2 ) (out) = _mm_fmadd_ss( mul1, mul2, add )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_madd1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_madd_mem' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1382, + "column": 3, + "source_line": " #define stbir__simdf_madd_mem( out, add, mul, ptr ) (out) = _mm_fmadd_ps( mul, _mm_loadu_ps( (float const*)(ptr) ), add )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_madd_mem" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_madd1_mem' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1383, + "column": 3, + "source_line": " #define stbir__simdf_madd1_mem( out, add, mul, ptr ) (out) = _mm_fmadd_ss( mul, _mm_load_ss( (float const*)(ptr) ), add )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_madd1_mem" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_madd' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1385, + "column": 3, + "source_line": " #define stbir__simdf_madd( out, add, mul1, mul2 ) (out) = _mm_add_ps( add, _mm_mul_ps( mul1, mul2 ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_madd" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_madd1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1386, + "column": 3, + "source_line": " #define stbir__simdf_madd1( out, add, mul1, mul2 ) (out) = _mm_add_ss( add, _mm_mul_ss( mul1, mul2 ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_madd1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_madd_mem' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1387, + "column": 3, + "source_line": " #define stbir__simdf_madd_mem( out, add, mul, ptr ) (out) = _mm_add_ps( add, _mm_mul_ps( mul, _mm_loadu_ps( (float const*)(ptr) ) ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_madd_mem" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_madd1_mem' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1388, + "column": 3, + "source_line": " #define stbir__simdf_madd1_mem( out, add, mul, ptr ) (out) = _mm_add_ss( add, _mm_mul_ss( mul, _mm_load_ss( (float const*)(ptr) ) ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_madd1_mem" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_add1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1391, + "column": 3, + "source_line": " #define stbir__simdf_add1( out, reg0, reg1 ) (out) = _mm_add_ss( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_add1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_mult1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1392, + "column": 3, + "source_line": " #define stbir__simdf_mult1( out, reg0, reg1 ) (out) = _mm_mul_ss( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_mult1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_and' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1394, + "column": 3, + "source_line": " #define stbir__simdf_and( out, reg0, reg1 ) (out) = _mm_and_ps( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_and" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_or' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1395, + "column": 3, + "source_line": " #define stbir__simdf_or( out, reg0, reg1 ) (out) = _mm_or_ps( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_or" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_min' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1397, + "column": 3, + "source_line": " #define stbir__simdf_min( out, reg0, reg1 ) (out) = _mm_min_ps( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_min" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_max' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1398, + "column": 3, + "source_line": " #define stbir__simdf_max( out, reg0, reg1 ) (out) = _mm_max_ps( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_max" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_min1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1399, + "column": 3, + "source_line": " #define stbir__simdf_min1( out, reg0, reg1 ) (out) = _mm_min_ss( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_min1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_max1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1400, + "column": 3, + "source_line": " #define stbir__simdf_max1( out, reg0, reg1 ) (out) = _mm_max_ss( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_max1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_0123ABCDto3ABx' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1402, + "column": 3, + "source_line": " #define stbir__simdf_0123ABCDto3ABx( out, reg0, reg1 ) (out)=_mm_castsi128_ps( _mm_shuffle_epi32( _mm_castps_si128( _mm_shuffle_ps( reg1,reg0, (0<<0) + (1<<2) + (2<<4) + (3<<6) )), (3<<0) + (0<<2) + (1<<4) + (2<<6) ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_0123ABCDto3ABx" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_0123ABCDto23Ax' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1403, + "column": 3, + "source_line": " #define stbir__simdf_0123ABCDto23Ax( out, reg0, reg1 ) (out)=_mm_castsi128_ps( _mm_shuffle_epi32( _mm_castps_si128( _mm_shuffle_ps( reg1,reg0, (0<<0) + (1<<2) + (2<<4) + (3<<6) )), (2<<0) + (3<<2) + (0<<4) + (1<<6) ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_0123ABCDto23Ax" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_aaa1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1407, + "column": 3, + "source_line": " #define stbir__simdf_aaa1( out, alp, ones ) (out)=_mm_castsi128_ps( _mm_shuffle_epi32( _mm_castps_si128( _mm_movehl_ps( ones, alp ) ), (1<<0) + (1<<2) + (1<<4) + (2<<6) ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_aaa1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_1aaa' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1408, + "column": 3, + "source_line": " #define stbir__simdf_1aaa( out, alp, ones ) (out)=_mm_castsi128_ps( _mm_shuffle_epi32( _mm_castps_si128( _mm_movelh_ps( ones, alp ) ), (0<<0) + (2<<2) + (2<<4) + (2<<6) ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_1aaa" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_a1a1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1409, + "column": 3, + "source_line": " #define stbir__simdf_a1a1( out, alp, ones) (out) = _mm_or_ps( _mm_castsi128_ps( _mm_srli_epi64( _mm_castps_si128(alp), 32 ) ), STBIR_zeroones )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_a1a1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_1a1a' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1410, + "column": 3, + "source_line": " #define stbir__simdf_1a1a( out, alp, ones) (out) = _mm_or_ps( _mm_castsi128_ps( _mm_slli_epi64( _mm_castps_si128(alp), 32 ) ), STBIR_onezeros )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_1a1a" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_swiz' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1412, + "column": 3, + "source_line": " #define stbir__simdf_swiz( reg, one, two, three, four ) _mm_castsi128_ps( _mm_shuffle_epi32( _mm_castps_si128( reg ), (one<<0) + (two<<2) + (three<<4) + (four<<6) ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_swiz" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_and' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1414, + "column": 3, + "source_line": " #define stbir__simdi_and( out, reg0, reg1 ) (out) = _mm_and_si128( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_and" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_or' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1415, + "column": 3, + "source_line": " #define stbir__simdi_or( out, reg0, reg1 ) (out) = _mm_or_si128( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_or" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_16madd' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1416, + "column": 3, + "source_line": " #define stbir__simdi_16madd( out, reg0, reg1 ) (out) = _mm_madd_epi16( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_16madd" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_pack_to_8bytes' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1418, + "column": 3, + "source_line": " #define stbir__simdf_pack_to_8bytes(out,aa,bb) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_pack_to_8bytes" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_load4_transposed' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1432, + "column": 3, + "source_line": " #define stbir__simdf_load4_transposed( o0, o1, o2, o3, ptr ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_load4_transposed" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__interleave_pack_and_store_16_u8' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1449, + "column": 3, + "source_line": " #define stbir__interleave_pack_and_store_16_u8( ptr, r0, r1, r2, r3 ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__interleave_pack_and_store_16_u8" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_32shr' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1459, + "column": 3, + "source_line": " #define stbir__simdi_32shr( out, reg, imm ) out = _mm_srli_epi32( reg, imm )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_32shr" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR__CONST_32_TO_8' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1463, + "column": 5, + "source_line": " #define STBIR__CONST_32_TO_8( v ) (char)(unsigned char)((v)&255),(char)(unsigned char)(((v)>>8)&255),(char)(unsigned char)(((v)>>16)&255),(char)(unsigned char)(((v)>>24)&255)" + }, + "unit_kind": "macro", + "unit_name": "STBIR__CONST_32_TO_8" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR__CONST_4_32i' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1464, + "column": 5, + "source_line": " #define STBIR__CONST_4_32i( v ) STBIR__CONST_32_TO_8( v ), STBIR__CONST_32_TO_8( v ), STBIR__CONST_32_TO_8( v ), STBIR__CONST_32_TO_8( v )" + }, + "unit_kind": "macro", + "unit_name": "STBIR__CONST_4_32i" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR__CONST_4d_32i' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1465, + "column": 5, + "source_line": " #define STBIR__CONST_4d_32i( v0, v1, v2, v3 ) STBIR__CONST_32_TO_8( v0 ), STBIR__CONST_32_TO_8( v1 ), STBIR__CONST_32_TO_8( v2 ), STBIR__CONST_32_TO_8( v3 )" + }, + "unit_kind": "macro", + "unit_name": "STBIR__CONST_4d_32i" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR__CONST_4_32i' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1468, + "column": 5, + "source_line": " #define STBIR__CONST_4_32i( v ) (long long)((((stbir_uint64)(stbir_uint32)(v))<<32)|((stbir_uint64)(stbir_uint32)(v))),(long long)((((stbir_uint64)(stbir_uint32)(v))<<32)|((stbir_uint64)(stbir_uint32)(v)))" + }, + "unit_kind": "macro", + "unit_name": "STBIR__CONST_4_32i" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR__CONST_4d_32i' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1469, + "column": 5, + "source_line": " #define STBIR__CONST_4d_32i( v0, v1, v2, v3 ) (long long)((((stbir_uint64)(stbir_uint32)(v1))<<32)|((stbir_uint64)(stbir_uint32)(v0))),(long long)((((stbir_uint64)(stbir_uint32)(v3))<<32)|((stbir_uint64)(stbir_uint32)(v2)))" + }, + "unit_kind": "macro", + "unit_name": "STBIR__CONST_4d_32i" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR__SIMDF_CONST' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1472, + "column": 3, + "source_line": " #define STBIR__SIMDF_CONST(var, x) stbir__simdf var = { x, x, x, x }" + }, + "unit_kind": "macro", + "unit_name": "STBIR__SIMDF_CONST" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR__SIMDI_CONST' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1473, + "column": 3, + "source_line": " #define STBIR__SIMDI_CONST(var, x) stbir__simdi var = { STBIR__CONST_4_32i(x) }" + }, + "unit_kind": "macro", + "unit_name": "STBIR__SIMDI_CONST" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR__CONSTF' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1474, + "column": 3, + "source_line": " #define STBIR__CONSTF(var) (var)" + }, + "unit_kind": "macro", + "unit_name": "STBIR__CONSTF" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR__CONSTI' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1475, + "column": 3, + "source_line": " #define STBIR__CONSTI(var) (var)" + }, + "unit_kind": "macro", + "unit_name": "STBIR__CONSTI" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_pack_to_8words' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1479, + "column": 5, + "source_line": " #define stbir__simdf_pack_to_8words(out,reg0,reg1) out = _mm_packus_epi32(_mm_cvttps_epi32(_mm_max_ps(_mm_min_ps(reg0,STBIR__CONSTF(STBIR_max_uint16_as_float)),_mm_setzero_ps())), _mm_cvttps_epi32(_mm_max_ps(_mm_min_ps(reg1,STBIR__CONSTF(STBIR_max_uint16_as_float)),_mm_setzero_ps())))" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_pack_to_8words" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_pack_to_8words' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1484, + "column": 5, + "source_line": " #define stbir__simdf_pack_to_8words(out,reg0,reg1) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_pack_to_8words" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_load' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1505, + "column": 5, + "source_line": " #define stbir__simdf8_load( out, ptr ) (out) = _mm256_loadu_ps( (float const *)(ptr) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_load" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi8_load' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1506, + "column": 5, + "source_line": " #define stbir__simdi8_load( out, ptr ) (out) = _mm256_loadu_si256( (__m256i const *)(ptr) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi8_load" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_mult' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1507, + "column": 5, + "source_line": " #define stbir__simdf8_mult( out, a, b ) (out) = _mm256_mul_ps( (a), (b) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_mult" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_store' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1508, + "column": 5, + "source_line": " #define stbir__simdf8_store( ptr, out ) _mm256_storeu_ps( (float*)(ptr), out )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_store" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi8_store' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1509, + "column": 5, + "source_line": " #define stbir__simdi8_store( ptr, reg ) _mm256_storeu_si256( (__m256i*)(ptr), reg )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi8_store" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_frep8' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1510, + "column": 5, + "source_line": " #define stbir__simdf8_frep8( fval ) _mm256_set1_ps( fval )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_frep8" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_min' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1512, + "column": 5, + "source_line": " #define stbir__simdf8_min( out, reg0, reg1 ) (out) = _mm256_min_ps( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_min" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_max' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1513, + "column": 5, + "source_line": " #define stbir__simdf8_max( out, reg0, reg1 ) (out) = _mm256_max_ps( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_max" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_add4halves' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1515, + "column": 5, + "source_line": " #define stbir__simdf8_add4halves( out, bot4, top8 ) (out) = _mm_add_ps( bot4, _mm256_extractf128_ps( top8, 1 ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_add4halves" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_mult_mem' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1516, + "column": 5, + "source_line": " #define stbir__simdf8_mult_mem( out, reg, ptr ) (out) = _mm256_mul_ps( reg, _mm256_loadu_ps( (float const*)(ptr) ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_mult_mem" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_add_mem' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1517, + "column": 5, + "source_line": " #define stbir__simdf8_add_mem( out, reg, ptr ) (out) = _mm256_add_ps( reg, _mm256_loadu_ps( (float const*)(ptr) ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_add_mem" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_add' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1518, + "column": 5, + "source_line": " #define stbir__simdf8_add( out, a, b ) (out) = _mm256_add_ps( a, b )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_add" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_load1b' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1519, + "column": 5, + "source_line": " #define stbir__simdf8_load1b( out, ptr ) (out) = _mm256_broadcast_ss( ptr )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_load1b" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_load1rep4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1520, + "column": 5, + "source_line": " #define stbir__simdf_load1rep4( out, ptr ) (out) = _mm_broadcast_ss( ptr ) // avx load instruction" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_load1rep4" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi8_convert_i32_to_float' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1522, + "column": 5, + "source_line": " #define stbir__simdi8_convert_i32_to_float(out, ireg) (out) = _mm256_cvtepi32_ps( ireg )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi8_convert_i32_to_float" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_convert_float_to_i32' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1523, + "column": 5, + "source_line": " #define stbir__simdf8_convert_float_to_i32( i, f ) (i) = _mm256_cvttps_epi32(f)" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_convert_float_to_i32" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_bot4s' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1525, + "column": 5, + "source_line": " #define stbir__simdf8_bot4s( out, a, b ) (out) = _mm256_permute2f128_ps(a,b, (0<<0)+(2<<4) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_bot4s" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_top4s' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1526, + "column": 5, + "source_line": " #define stbir__simdf8_top4s( out, a, b ) (out) = _mm256_permute2f128_ps(a,b, (1<<0)+(3<<4) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_top4s" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_gettop4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1528, + "column": 5, + "source_line": " #define stbir__simdf8_gettop4( reg ) _mm256_extractf128_ps(reg,1)" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_gettop4" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi8_expand_u8_to_u32' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1532, + "column": 5, + "source_line": " #define stbir__simdi8_expand_u8_to_u32(out0,out1,ireg) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi8_expand_u8_to_u32" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_pack_to_16bytes' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1540, + "column": 5, + "source_line": " #define stbir__simdf8_pack_to_16bytes(out,aa,bb) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_pack_to_16bytes" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi8_expand_u16_to_u32' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1555, + "column": 5, + "source_line": " #define stbir__simdi8_expand_u16_to_u32(out,ireg) out = _mm256_unpacklo_epi16( _mm256_permute4x64_epi64(_mm256_castsi128_si256(ireg),(0<<0)+(2<<2)+(1<<4)+(3<<6)), _mm256_setzero_si256() );" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi8_expand_u16_to_u32" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_pack_to_16words' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1557, + "column": 5, + "source_line": " #define stbir__simdf8_pack_to_16words(out,aa,bb) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_pack_to_16words" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi8_expand_u8_to_u32' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1572, + "column": 5, + "source_line": " #define stbir__simdi8_expand_u8_to_u32(out0,out1,ireg) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi8_expand_u8_to_u32" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_pack_to_16bytes' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1581, + "column": 5, + "source_line": " #define stbir__simdf8_pack_to_16bytes(out,aa,bb) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_pack_to_16bytes" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi8_expand_u16_to_u32' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1599, + "column": 5, + "source_line": " #define stbir__simdi8_expand_u16_to_u32(out,ireg) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi8_expand_u16_to_u32" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_pack_to_16words' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1607, + "column": 5, + "source_line": " #define stbir__simdf8_pack_to_16words(out,aa,bb) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_pack_to_16words" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_0123to00001111' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1626, + "column": 5, + "source_line": " #define stbir__simdf8_0123to00001111( out, in ) (out) = _mm256_permutevar_ps ( in, stbir_00001111 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_0123to00001111" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_0123to22223333' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1629, + "column": 5, + "source_line": " #define stbir__simdf8_0123to22223333( out, in ) (out) = _mm256_permutevar_ps ( in, stbir_22223333 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_0123to22223333" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_0123to2222' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1631, + "column": 5, + "source_line": " #define stbir__simdf8_0123to2222( out, in ) (out) = stbir__simdf_swiz(_mm256_castps256_ps128(in), 2,2,2,2 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_0123to2222" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_load4b' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1633, + "column": 5, + "source_line": " #define stbir__simdf8_load4b( out, ptr ) (out) = _mm256_broadcast_ps( (__m128 const *)(ptr) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_load4b" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_0123to00112233' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1636, + "column": 5, + "source_line": " #define stbir__simdf8_0123to00112233( out, in ) (out) = _mm256_permutevar_ps ( in, stbir_00112233 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_0123to00112233" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_add4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1637, + "column": 5, + "source_line": " #define stbir__simdf8_add4( out, a8, b ) (out) = _mm256_add_ps( a8, _mm256_castps128_ps256( b ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_add4" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_load6z' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1640, + "column": 5, + "source_line": " #define stbir__simdf8_load6z( out, ptr ) (out) = _mm256_maskload_ps( ptr, stbir_load6 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_load6z" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_0123to00000000' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1642, + "column": 5, + "source_line": " #define stbir__simdf8_0123to00000000( out, in ) (out) = _mm256_shuffle_ps ( in, in, (0<<0)+(0<<2)+(0<<4)+(0<<6) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_0123to00000000" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_0123to11111111' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1643, + "column": 5, + "source_line": " #define stbir__simdf8_0123to11111111( out, in ) (out) = _mm256_shuffle_ps ( in, in, (1<<0)+(1<<2)+(1<<4)+(1<<6) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_0123to11111111" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_0123to22222222' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1644, + "column": 5, + "source_line": " #define stbir__simdf8_0123to22222222( out, in ) (out) = _mm256_shuffle_ps ( in, in, (2<<0)+(2<<2)+(2<<4)+(2<<6) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_0123to22222222" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_0123to33333333' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1645, + "column": 5, + "source_line": " #define stbir__simdf8_0123to33333333( out, in ) (out) = _mm256_shuffle_ps ( in, in, (3<<0)+(3<<2)+(3<<4)+(3<<6) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_0123to33333333" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_0123to21032103' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1646, + "column": 5, + "source_line": " #define stbir__simdf8_0123to21032103( out, in ) (out) = _mm256_shuffle_ps ( in, in, (2<<0)+(1<<2)+(0<<4)+(3<<6) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_0123to21032103" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_0123to32103210' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1647, + "column": 5, + "source_line": " #define stbir__simdf8_0123to32103210( out, in ) (out) = _mm256_shuffle_ps ( in, in, (3<<0)+(2<<2)+(1<<4)+(0<<6) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_0123to32103210" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_0123to12301230' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1648, + "column": 5, + "source_line": " #define stbir__simdf8_0123to12301230( out, in ) (out) = _mm256_shuffle_ps ( in, in, (1<<0)+(2<<2)+(3<<4)+(0<<6) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_0123to12301230" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_0123to10321032' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1649, + "column": 5, + "source_line": " #define stbir__simdf8_0123to10321032( out, in ) (out) = _mm256_shuffle_ps ( in, in, (1<<0)+(0<<2)+(3<<4)+(2<<6) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_0123to10321032" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_0123to30123012' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1650, + "column": 5, + "source_line": " #define stbir__simdf8_0123to30123012( out, in ) (out) = _mm256_shuffle_ps ( in, in, (3<<0)+(0<<2)+(1<<4)+(2<<6) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_0123to30123012" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_0123to11331133' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1652, + "column": 5, + "source_line": " #define stbir__simdf8_0123to11331133( out, in ) (out) = _mm256_shuffle_ps ( in, in, (1<<0)+(1<<2)+(3<<4)+(3<<6) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_0123to11331133" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_0123to00220022' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1653, + "column": 5, + "source_line": " #define stbir__simdf8_0123to00220022( out, in ) (out) = _mm256_shuffle_ps ( in, in, (0<<0)+(0<<2)+(2<<4)+(2<<6) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_0123to00220022" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_aaa1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1655, + "column": 5, + "source_line": " #define stbir__simdf8_aaa1( out, alp, ones ) (out) = _mm256_blend_ps( alp, ones, (1<<0)+(1<<1)+(1<<2)+(0<<3)+(1<<4)+(1<<5)+(1<<6)+(0<<7)); (out)=_mm256_shuffle_ps( out,out, (3<<0) + (3<<2) + (3<<4) + (0<<6) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_aaa1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_1aaa' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1656, + "column": 5, + "source_line": " #define stbir__simdf8_1aaa( out, alp, ones ) (out) = _mm256_blend_ps( alp, ones, (0<<0)+(1<<1)+(1<<2)+(1<<3)+(0<<4)+(1<<5)+(1<<6)+(1<<7)); (out)=_mm256_shuffle_ps( out,out, (1<<0) + (0<<2) + (0<<4) + (0<<6) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_1aaa" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_a1a1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1657, + "column": 5, + "source_line": " #define stbir__simdf8_a1a1( out, alp, ones) (out) = _mm256_blend_ps( alp, ones, (1<<0)+(0<<1)+(1<<2)+(0<<3)+(1<<4)+(0<<5)+(1<<6)+(0<<7)); (out)=_mm256_shuffle_ps( out,out, (1<<0) + (0<<2) + (3<<4) + (2<<6) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_a1a1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_1a1a' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1658, + "column": 5, + "source_line": " #define stbir__simdf8_1a1a( out, alp, ones) (out) = _mm256_blend_ps( alp, ones, (0<<0)+(1<<1)+(0<<2)+(1<<3)+(0<<4)+(1<<5)+(0<<6)+(1<<7)); (out)=_mm256_shuffle_ps( out,out, (1<<0) + (0<<2) + (3<<4) + (2<<6) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_1a1a" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_zero' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1660, + "column": 5, + "source_line": " #define stbir__simdf8_zero( reg ) (reg) = _mm256_setzero_ps()" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_zero" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_madd' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1663, + "column": 5, + "source_line": " #define stbir__simdf8_madd( out, add, mul1, mul2 ) (out) = _mm256_fmadd_ps( mul1, mul2, add )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_madd" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_madd_mem' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1664, + "column": 5, + "source_line": " #define stbir__simdf8_madd_mem( out, add, mul, ptr ) (out) = _mm256_fmadd_ps( mul, _mm256_loadu_ps( (float const*)(ptr) ), add )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_madd_mem" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_madd' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1667, + "column": 5, + "source_line": " #define stbir__simdf8_madd( out, add, mul1, mul2 ) (out) = _mm256_add_ps( add, _mm256_mul_ps( mul1, mul2 ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_madd" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_madd_mem' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1668, + "column": 5, + "source_line": " #define stbir__simdf8_madd_mem( out, add, mul, ptr ) (out) = _mm256_add_ps( add, _mm256_mul_ps( mul, _mm256_loadu_ps( (float const*)(ptr) ) ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_madd_mem" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_madd_mem4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1669, + "column": 5, + "source_line": " #define stbir__simdf8_madd_mem4( out, add, mul, ptr ) (out) = _mm256_add_ps( add, _mm256_setr_m128( _mm_mul_ps( mul, _mm_loadu_ps( (float const*)(ptr) ) ), _mm_setzero_ps() ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_madd_mem4" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__if_simdf8_cast_to_simdf4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1671, + "column": 5, + "source_line": " #define stbir__if_simdf8_cast_to_simdf4( val ) _mm256_castps256_ps128( val )" + }, + "unit_kind": "macro", + "unit_name": "stbir__if_simdf8_cast_to_simdf4" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir_simdi_castf' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1716, + "column": 3, + "source_line": " #define stbir_simdi_castf( reg ) vreinterpretq_u32_f32(reg)" + }, + "unit_kind": "macro", + "unit_name": "stbir_simdi_castf" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir_simdf_casti' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1717, + "column": 3, + "source_line": " #define stbir_simdf_casti( reg ) vreinterpretq_f32_u32(reg)" + }, + "unit_kind": "macro", + "unit_name": "stbir_simdf_casti" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_load' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1719, + "column": 3, + "source_line": " #define stbir__simdf_load( reg, ptr ) (reg) = vld1q_f32( (float const*)(ptr) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_load" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_load' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1720, + "column": 3, + "source_line": " #define stbir__simdi_load( reg, ptr ) (reg) = vld1q_u32( (uint32_t const*)(ptr) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_load" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_load1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1721, + "column": 3, + "source_line": " #define stbir__simdf_load1( out, ptr ) (out) = vld1q_dup_f32( (float const*)(ptr) ) // top values can be random (not denormal or nan for perf)" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_load1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_load1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1722, + "column": 3, + "source_line": " #define stbir__simdi_load1( out, ptr ) (out) = vld1q_dup_u32( (uint32_t const*)(ptr) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_load1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_load1z' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1723, + "column": 3, + "source_line": " #define stbir__simdf_load1z( out, ptr ) (out) = vld1q_lane_f32( (float const*)(ptr), vdupq_n_f32(0), 0 ) // top values must be zero" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_load1z" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_frep4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1724, + "column": 3, + "source_line": " #define stbir__simdf_frep4( fvar ) vdupq_n_f32( fvar )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_frep4" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_load1frep4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1725, + "column": 3, + "source_line": " #define stbir__simdf_load1frep4( out, fvar ) (out) = vdupq_n_f32( fvar )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_load1frep4" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_load2' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1726, + "column": 3, + "source_line": " #define stbir__simdf_load2( out, ptr ) (out) = vcombine_f32( vld1_f32( (float const*)(ptr) ), vcreate_f32(0) ) // top values can be random (not denormal or nan for perf)" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_load2" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_load2z' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1727, + "column": 3, + "source_line": " #define stbir__simdf_load2z( out, ptr ) (out) = vcombine_f32( vld1_f32( (float const*)(ptr) ), vcreate_f32(0) ) // top values must be zero" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_load2z" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_load2hmerge' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1728, + "column": 3, + "source_line": " #define stbir__simdf_load2hmerge( out, reg, ptr ) (out) = vcombine_f32( vget_low_f32(reg), vld1_f32( (float const*)(ptr) ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_load2hmerge" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_zeroP' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1730, + "column": 3, + "source_line": " #define stbir__simdf_zeroP() vdupq_n_f32(0)" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_zeroP" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_zero' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1731, + "column": 3, + "source_line": " #define stbir__simdf_zero( reg ) (reg) = vdupq_n_f32(0)" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_zero" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_store' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1733, + "column": 3, + "source_line": " #define stbir__simdf_store( ptr, reg ) vst1q_f32( (float*)(ptr), reg )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_store" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_store1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1734, + "column": 3, + "source_line": " #define stbir__simdf_store1( ptr, reg ) vst1q_lane_f32( (float*)(ptr), reg, 0)" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_store1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_store2' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1735, + "column": 3, + "source_line": " #define stbir__simdf_store2( ptr, reg ) vst1_f32( (float*)(ptr), vget_low_f32(reg) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_store2" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_store2h' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1736, + "column": 3, + "source_line": " #define stbir__simdf_store2h( ptr, reg ) vst1_f32( (float*)(ptr), vget_high_f32(reg) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_store2h" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_store' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1738, + "column": 3, + "source_line": " #define stbir__simdi_store( ptr, reg ) vst1q_u32( (uint32_t*)(ptr), reg )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_store" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_store1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1739, + "column": 3, + "source_line": " #define stbir__simdi_store1( ptr, reg ) vst1q_lane_u32( (uint32_t*)(ptr), reg, 0 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_store1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_store2' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1740, + "column": 3, + "source_line": " #define stbir__simdi_store2( ptr, reg ) vst1_u32( (uint32_t*)(ptr), vget_low_u32(reg) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_store2" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__prefetch' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1742, + "column": 3, + "source_line": " #define stbir__prefetch( ptr )" + }, + "unit_kind": "macro", + "unit_name": "stbir__prefetch" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_expand_u8_to_u32' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1744, + "column": 3, + "source_line": " #define stbir__simdi_expand_u8_to_u32(out0,out1,out2,out3,ireg) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_expand_u8_to_u32" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_expand_u8_to_1u32' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1754, + "column": 3, + "source_line": " #define stbir__simdi_expand_u8_to_1u32(out,ireg) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_expand_u8_to_1u32" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_expand_u16_to_u32' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1760, + "column": 3, + "source_line": " #define stbir__simdi_expand_u16_to_u32(out0,out1,ireg) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_expand_u16_to_u32" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_convert_float_to_i32' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1767, + "column": 3, + "source_line": " #define stbir__simdf_convert_float_to_i32( i, f ) (i) = vreinterpretq_u32_s32( vcvtq_s32_f32(f) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_convert_float_to_i32" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_convert_float_to_int' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1768, + "column": 3, + "source_line": " #define stbir__simdf_convert_float_to_int( f ) vgetq_lane_s32(vcvtq_s32_f32(f), 0)" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_convert_float_to_int" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_to_int' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1769, + "column": 3, + "source_line": " #define stbir__simdi_to_int( i ) (int)vgetq_lane_u32(i, 0)" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_to_int" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_convert_float_to_uint8' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1770, + "column": 3, + "source_line": " #define stbir__simdf_convert_float_to_uint8( f ) ((unsigned char)vgetq_lane_s32(vcvtq_s32_f32(vmaxq_f32(vminq_f32(f,STBIR__CONSTF(STBIR_max_uint8_as_float)),vdupq_n_f32(0))), 0))" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_convert_float_to_uint8" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_convert_float_to_short' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1771, + "column": 3, + "source_line": " #define stbir__simdf_convert_float_to_short( f ) ((unsigned short)vgetq_lane_s32(vcvtq_s32_f32(vmaxq_f32(vminq_f32(f,STBIR__CONSTF(STBIR_max_uint16_as_float)),vdupq_n_f32(0))), 0))" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_convert_float_to_short" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_convert_i32_to_float' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1772, + "column": 3, + "source_line": " #define stbir__simdi_convert_i32_to_float(out, ireg) (out) = vcvtq_f32_s32( vreinterpretq_s32_u32(ireg) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_convert_i32_to_float" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_add' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1773, + "column": 3, + "source_line": " #define stbir__simdf_add( out, reg0, reg1 ) (out) = vaddq_f32( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_add" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_mult' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1774, + "column": 3, + "source_line": " #define stbir__simdf_mult( out, reg0, reg1 ) (out) = vmulq_f32( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_mult" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_mult_mem' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1775, + "column": 3, + "source_line": " #define stbir__simdf_mult_mem( out, reg, ptr ) (out) = vmulq_f32( reg, vld1q_f32( (float const*)(ptr) ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_mult_mem" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_mult1_mem' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1776, + "column": 3, + "source_line": " #define stbir__simdf_mult1_mem( out, reg, ptr ) (out) = vmulq_f32( reg, vld1q_dup_f32( (float const*)(ptr) ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_mult1_mem" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_add_mem' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1777, + "column": 3, + "source_line": " #define stbir__simdf_add_mem( out, reg, ptr ) (out) = vaddq_f32( reg, vld1q_f32( (float const*)(ptr) ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_add_mem" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_add1_mem' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1778, + "column": 3, + "source_line": " #define stbir__simdf_add1_mem( out, reg, ptr ) (out) = vaddq_f32( reg, vld1q_dup_f32( (float const*)(ptr) ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_add1_mem" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_madd' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1781, + "column": 3, + "source_line": " #define stbir__simdf_madd( out, add, mul1, mul2 ) (out) = vfmaq_f32( add, mul1, mul2 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_madd" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_madd1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1782, + "column": 3, + "source_line": " #define stbir__simdf_madd1( out, add, mul1, mul2 ) (out) = vfmaq_f32( add, mul1, mul2 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_madd1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_madd_mem' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1783, + "column": 3, + "source_line": " #define stbir__simdf_madd_mem( out, add, mul, ptr ) (out) = vfmaq_f32( add, mul, vld1q_f32( (float const*)(ptr) ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_madd_mem" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_madd1_mem' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1784, + "column": 3, + "source_line": " #define stbir__simdf_madd1_mem( out, add, mul, ptr ) (out) = vfmaq_f32( add, mul, vld1q_dup_f32( (float const*)(ptr) ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_madd1_mem" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_madd' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1786, + "column": 3, + "source_line": " #define stbir__simdf_madd( out, add, mul1, mul2 ) (out) = vaddq_f32( add, vmulq_f32( mul1, mul2 ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_madd" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_madd1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1787, + "column": 3, + "source_line": " #define stbir__simdf_madd1( out, add, mul1, mul2 ) (out) = vaddq_f32( add, vmulq_f32( mul1, mul2 ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_madd1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_madd_mem' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1788, + "column": 3, + "source_line": " #define stbir__simdf_madd_mem( out, add, mul, ptr ) (out) = vaddq_f32( add, vmulq_f32( mul, vld1q_f32( (float const*)(ptr) ) ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_madd_mem" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_madd1_mem' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1789, + "column": 3, + "source_line": " #define stbir__simdf_madd1_mem( out, add, mul, ptr ) (out) = vaddq_f32( add, vmulq_f32( mul, vld1q_dup_f32( (float const*)(ptr) ) ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_madd1_mem" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_add1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1792, + "column": 3, + "source_line": " #define stbir__simdf_add1( out, reg0, reg1 ) (out) = vaddq_f32( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_add1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_mult1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1793, + "column": 3, + "source_line": " #define stbir__simdf_mult1( out, reg0, reg1 ) (out) = vmulq_f32( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_mult1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_and' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1795, + "column": 3, + "source_line": " #define stbir__simdf_and( out, reg0, reg1 ) (out) = vreinterpretq_f32_u32( vandq_u32( vreinterpretq_u32_f32(reg0), vreinterpretq_u32_f32(reg1) ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_and" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_or' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1796, + "column": 3, + "source_line": " #define stbir__simdf_or( out, reg0, reg1 ) (out) = vreinterpretq_f32_u32( vorrq_u32( vreinterpretq_u32_f32(reg0), vreinterpretq_u32_f32(reg1) ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_or" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_min' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1798, + "column": 3, + "source_line": " #define stbir__simdf_min( out, reg0, reg1 ) (out) = vminq_f32( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_min" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_max' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1799, + "column": 3, + "source_line": " #define stbir__simdf_max( out, reg0, reg1 ) (out) = vmaxq_f32( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_max" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_min1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1800, + "column": 3, + "source_line": " #define stbir__simdf_min1( out, reg0, reg1 ) (out) = vminq_f32( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_min1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_max1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1801, + "column": 3, + "source_line": " #define stbir__simdf_max1( out, reg0, reg1 ) (out) = vmaxq_f32( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_max1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_0123ABCDto3ABx' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1803, + "column": 3, + "source_line": " #define stbir__simdf_0123ABCDto3ABx( out, reg0, reg1 ) (out) = vextq_f32( reg0, reg1, 3 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_0123ABCDto3ABx" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_0123ABCDto23Ax' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1804, + "column": 3, + "source_line": " #define stbir__simdf_0123ABCDto23Ax( out, reg0, reg1 ) (out) = vextq_f32( reg0, reg1, 2 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_0123ABCDto23Ax" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_a1a1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1806, + "column": 3, + "source_line": " #define stbir__simdf_a1a1( out, alp, ones ) (out) = vzipq_f32(vuzpq_f32(alp, alp).val[1], ones).val[0]" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_a1a1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_1a1a' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1807, + "column": 3, + "source_line": " #define stbir__simdf_1a1a( out, alp, ones ) (out) = vzipq_f32(ones, vuzpq_f32(alp, alp).val[0]).val[0]" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_1a1a" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_aaa1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1811, + "column": 5, + "source_line": " #define stbir__simdf_aaa1( out, alp, ones ) (out) = vcopyq_laneq_f32(vdupq_n_f32(vgetq_lane_f32(alp, 3)), 3, ones, 3)" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_aaa1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_1aaa' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1812, + "column": 5, + "source_line": " #define stbir__simdf_1aaa( out, alp, ones ) (out) = vcopyq_laneq_f32(vdupq_n_f32(vgetq_lane_f32(alp, 0)), 0, ones, 0)" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_1aaa" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir_make16' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1815, + "column": 7, + "source_line": " #define stbir_make16(a,b,c,d) vcombine_u8( \\" + }, + "unit_kind": "macro", + "unit_name": "stbir_make16" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir_make16' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1827, + "column": 7, + "source_line": " #define stbir_make16(a,b,c,d) (uint8x16_t){4*a+0,4*a+1,4*a+2,4*a+3,4*b+0,4*b+1,4*b+2,4*b+3,4*c+0,4*c+1,4*c+2,4*c+3,4*d+0,4*d+1,4*d+2,4*d+3}" + }, + "unit_kind": "macro", + "unit_name": "stbir_make16" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir_make16x2' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1828, + "column": 7, + "source_line": " #define stbir_make16x2(a,b) (uint8x16x2_t){{vreinterpretq_u8_f32(a),vreinterpretq_u8_f32(b)}}" + }, + "unit_kind": "macro", + "unit_name": "stbir_make16x2" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_swiz' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1831, + "column": 5, + "source_line": " #define stbir__simdf_swiz( reg, one, two, three, four ) vreinterpretq_f32_u8( vqtbl1q_u8( vreinterpretq_u8_f32(reg), stbir_make16(one, two, three, four) ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_swiz" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_swiz2' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1832, + "column": 5, + "source_line": " #define stbir__simdf_swiz2( rega, regb, one, two, three, four ) vreinterpretq_f32_u8( vqtbl2q_u8( stbir_make16x2(rega,regb), stbir_make16(one, two, three, four) ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_swiz2" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_16madd' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1834, + "column": 5, + "source_line": " #define stbir__simdi_16madd( out, reg0, reg1 ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_16madd" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_aaa1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1845, + "column": 5, + "source_line": " #define stbir__simdf_aaa1( out, alp, ones ) (out) = vsetq_lane_f32(1.0f, vdupq_n_f32(vgetq_lane_f32(alp, 3)), 3)" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_aaa1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_1aaa' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1846, + "column": 5, + "source_line": " #define stbir__simdf_1aaa( out, alp, ones ) (out) = vsetq_lane_f32(1.0f, vdupq_n_f32(vgetq_lane_f32(alp, 0)), 0)" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_1aaa" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir_make8' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1854, + "column": 7, + "source_line": " #define stbir_make8(a,b) vcreate_u8( \\" + }, + "unit_kind": "macro", + "unit_name": "stbir_make8" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir_make8x2' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1858, + "column": 7, + "source_line": " #define stbir_make8x2(reg) (uint8x8x2_t){ { vget_low_u8(vreinterpretq_u8_f32(reg)), vget_high_u8(vreinterpretq_u8_f32(reg)) } }" + }, + "unit_kind": "macro", + "unit_name": "stbir_make8x2" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir_make8' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1859, + "column": 7, + "source_line": " #define stbir_make8(a,b) (uint8x8_t){4*a+0,4*a+1,4*a+2,4*a+3,4*b+0,4*b+1,4*b+2,4*b+3}" + }, + "unit_kind": "macro", + "unit_name": "stbir_make8" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_swiz' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1862, + "column": 5, + "source_line": " #define stbir__simdf_swiz( reg, one, two, three, four ) vreinterpretq_f32_u8( vcombine_u8( \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_swiz" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_16madd' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1866, + "column": 5, + "source_line": " #define stbir__simdi_16madd( out, reg0, reg1 ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_16madd" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_and' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1879, + "column": 3, + "source_line": " #define stbir__simdi_and( out, reg0, reg1 ) (out) = vandq_u32( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_and" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_or' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1880, + "column": 3, + "source_line": " #define stbir__simdi_or( out, reg0, reg1 ) (out) = vorrq_u32( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_or" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_pack_to_8bytes' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1882, + "column": 3, + "source_line": " #define stbir__simdf_pack_to_8bytes(out,aa,bb) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_pack_to_8bytes" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_pack_to_8words' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1892, + "column": 3, + "source_line": " #define stbir__simdf_pack_to_8words(out,aa,bb) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_pack_to_8words" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__interleave_pack_and_store_16_u8' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1901, + "column": 3, + "source_line": " #define stbir__interleave_pack_and_store_16_u8( ptr, r0, r1, r2, r3 ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__interleave_pack_and_store_16_u8" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_load4_transposed' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1913, + "column": 3, + "source_line": " #define stbir__simdf_load4_transposed( o0, o1, o2, o3, ptr ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_load4_transposed" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_32shr' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1922, + "column": 3, + "source_line": " #define stbir__simdi_32shr( out, reg, imm ) out = vshrq_n_u32( reg, imm )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_32shr" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR__SIMDF_CONST' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1925, + "column": 5, + "source_line": " #define STBIR__SIMDF_CONST(var, x) __declspec(align(8)) float var[] = { x, x, x, x }" + }, + "unit_kind": "macro", + "unit_name": "STBIR__SIMDF_CONST" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR__SIMDI_CONST' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1926, + "column": 5, + "source_line": " #define STBIR__SIMDI_CONST(var, x) __declspec(align(8)) uint32_t var[] = { x, x, x, x }" + }, + "unit_kind": "macro", + "unit_name": "STBIR__SIMDI_CONST" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR__CONSTF' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1927, + "column": 5, + "source_line": " #define STBIR__CONSTF(var) (*(const float32x4_t*)var)" + }, + "unit_kind": "macro", + "unit_name": "STBIR__CONSTF" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR__CONSTI' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1928, + "column": 5, + "source_line": " #define STBIR__CONSTI(var) (*(const uint32x4_t*)var)" + }, + "unit_kind": "macro", + "unit_name": "STBIR__CONSTI" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR__SIMDF_CONST' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1930, + "column": 5, + "source_line": " #define STBIR__SIMDF_CONST(var, x) stbir__simdf var = { x, x, x, x }" + }, + "unit_kind": "macro", + "unit_name": "STBIR__SIMDF_CONST" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR__SIMDI_CONST' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1931, + "column": 5, + "source_line": " #define STBIR__SIMDI_CONST(var, x) stbir__simdi var = { x, x, x, x }" + }, + "unit_kind": "macro", + "unit_name": "STBIR__SIMDI_CONST" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR__CONSTF' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1932, + "column": 5, + "source_line": " #define STBIR__CONSTF(var) (var)" + }, + "unit_kind": "macro", + "unit_name": "STBIR__CONSTF" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR__CONSTI' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1933, + "column": 5, + "source_line": " #define STBIR__CONSTI(var) (var)" + }, + "unit_kind": "macro", + "unit_name": "STBIR__CONSTI" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir_simdi_castf' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1981, + "column": 3, + "source_line": " #define stbir_simdi_castf( reg ) (reg)" + }, + "unit_kind": "macro", + "unit_name": "stbir_simdi_castf" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir_simdf_casti' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1982, + "column": 3, + "source_line": " #define stbir_simdf_casti( reg ) (reg)" + }, + "unit_kind": "macro", + "unit_name": "stbir_simdf_casti" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_load' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1984, + "column": 3, + "source_line": " #define stbir__simdf_load( reg, ptr ) (reg) = wasm_v128_load( (void const*)(ptr) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_load" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_load' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1985, + "column": 3, + "source_line": " #define stbir__simdi_load( reg, ptr ) (reg) = wasm_v128_load( (void const*)(ptr) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_load" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_load1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1986, + "column": 3, + "source_line": " #define stbir__simdf_load1( out, ptr ) (out) = wasm_v128_load32_splat( (void const*)(ptr) ) // top values can be random (not denormal or nan for perf)" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_load1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_load1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1987, + "column": 3, + "source_line": " #define stbir__simdi_load1( out, ptr ) (out) = wasm_v128_load32_splat( (void const*)(ptr) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_load1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_load1z' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1988, + "column": 3, + "source_line": " #define stbir__simdf_load1z( out, ptr ) (out) = wasm_v128_load32_zero( (void const*)(ptr) ) // top values must be zero" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_load1z" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_frep4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1989, + "column": 3, + "source_line": " #define stbir__simdf_frep4( fvar ) wasm_f32x4_splat( fvar )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_frep4" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_load1frep4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1990, + "column": 3, + "source_line": " #define stbir__simdf_load1frep4( out, fvar ) (out) = wasm_f32x4_splat( fvar )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_load1frep4" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_load2' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1991, + "column": 3, + "source_line": " #define stbir__simdf_load2( out, ptr ) (out) = wasm_v128_load64_splat( (void const*)(ptr) ) // top values can be random (not denormal or nan for perf)" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_load2" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_load2z' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1992, + "column": 3, + "source_line": " #define stbir__simdf_load2z( out, ptr ) (out) = wasm_v128_load64_zero( (void const*)(ptr) ) // top values must be zero" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_load2z" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_load2hmerge' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1993, + "column": 3, + "source_line": " #define stbir__simdf_load2hmerge( out, reg, ptr ) (out) = wasm_v128_load64_lane( (void const*)(ptr), reg, 1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_load2hmerge" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_zeroP' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1995, + "column": 3, + "source_line": " #define stbir__simdf_zeroP() wasm_f32x4_const_splat(0)" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_zeroP" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_zero' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1996, + "column": 3, + "source_line": " #define stbir__simdf_zero( reg ) (reg) = wasm_f32x4_const_splat(0)" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_zero" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_store' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1998, + "column": 3, + "source_line": " #define stbir__simdf_store( ptr, reg ) wasm_v128_store( (void*)(ptr), reg )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_store" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_store1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1999, + "column": 3, + "source_line": " #define stbir__simdf_store1( ptr, reg ) wasm_v128_store32_lane( (void*)(ptr), reg, 0 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_store1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_store2' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2000, + "column": 3, + "source_line": " #define stbir__simdf_store2( ptr, reg ) wasm_v128_store64_lane( (void*)(ptr), reg, 0 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_store2" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_store2h' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2001, + "column": 3, + "source_line": " #define stbir__simdf_store2h( ptr, reg ) wasm_v128_store64_lane( (void*)(ptr), reg, 1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_store2h" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_store' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2003, + "column": 3, + "source_line": " #define stbir__simdi_store( ptr, reg ) wasm_v128_store( (void*)(ptr), reg )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_store" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_store1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2004, + "column": 3, + "source_line": " #define stbir__simdi_store1( ptr, reg ) wasm_v128_store32_lane( (void*)(ptr), reg, 0 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_store1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_store2' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2005, + "column": 3, + "source_line": " #define stbir__simdi_store2( ptr, reg ) wasm_v128_store64_lane( (void*)(ptr), reg, 0 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_store2" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__prefetch' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2007, + "column": 3, + "source_line": " #define stbir__prefetch( ptr )" + }, + "unit_kind": "macro", + "unit_name": "stbir__prefetch" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_expand_u8_to_u32' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2009, + "column": 3, + "source_line": " #define stbir__simdi_expand_u8_to_u32(out0,out1,out2,out3,ireg) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_expand_u8_to_u32" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_expand_u8_to_1u32' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2019, + "column": 3, + "source_line": " #define stbir__simdi_expand_u8_to_1u32(out,ireg) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_expand_u8_to_1u32" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_expand_u16_to_u32' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2025, + "column": 3, + "source_line": " #define stbir__simdi_expand_u16_to_u32(out0,out1,ireg) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_expand_u16_to_u32" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_convert_float_to_i32' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2031, + "column": 3, + "source_line": " #define stbir__simdf_convert_float_to_i32( i, f ) (i) = wasm_i32x4_trunc_sat_f32x4(f)" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_convert_float_to_i32" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_convert_float_to_int' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2032, + "column": 3, + "source_line": " #define stbir__simdf_convert_float_to_int( f ) wasm_i32x4_extract_lane(wasm_i32x4_trunc_sat_f32x4(f), 0)" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_convert_float_to_int" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_to_int' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2033, + "column": 3, + "source_line": " #define stbir__simdi_to_int( i ) wasm_i32x4_extract_lane(i, 0)" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_to_int" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_convert_float_to_uint8' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2034, + "column": 3, + "source_line": " #define stbir__simdf_convert_float_to_uint8( f ) ((unsigned char)wasm_i32x4_extract_lane(wasm_i32x4_trunc_sat_f32x4(wasm_f32x4_max(wasm_f32x4_min(f,STBIR_max_uint8_as_float),wasm_f32x4_const_splat(0))), 0))" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_convert_float_to_uint8" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_convert_float_to_short' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2035, + "column": 3, + "source_line": " #define stbir__simdf_convert_float_to_short( f ) ((unsigned short)wasm_i32x4_extract_lane(wasm_i32x4_trunc_sat_f32x4(wasm_f32x4_max(wasm_f32x4_min(f,STBIR_max_uint16_as_float),wasm_f32x4_const_splat(0))), 0))" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_convert_float_to_short" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_convert_i32_to_float' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2036, + "column": 3, + "source_line": " #define stbir__simdi_convert_i32_to_float(out, ireg) (out) = wasm_f32x4_convert_i32x4(ireg)" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_convert_i32_to_float" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_add' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2037, + "column": 3, + "source_line": " #define stbir__simdf_add( out, reg0, reg1 ) (out) = wasm_f32x4_add( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_add" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_mult' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2038, + "column": 3, + "source_line": " #define stbir__simdf_mult( out, reg0, reg1 ) (out) = wasm_f32x4_mul( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_mult" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_mult_mem' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2039, + "column": 3, + "source_line": " #define stbir__simdf_mult_mem( out, reg, ptr ) (out) = wasm_f32x4_mul( reg, wasm_v128_load( (void const*)(ptr) ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_mult_mem" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_mult1_mem' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2040, + "column": 3, + "source_line": " #define stbir__simdf_mult1_mem( out, reg, ptr ) (out) = wasm_f32x4_mul( reg, wasm_v128_load32_splat( (void const*)(ptr) ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_mult1_mem" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_add_mem' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2041, + "column": 3, + "source_line": " #define stbir__simdf_add_mem( out, reg, ptr ) (out) = wasm_f32x4_add( reg, wasm_v128_load( (void const*)(ptr) ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_add_mem" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_add1_mem' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2042, + "column": 3, + "source_line": " #define stbir__simdf_add1_mem( out, reg, ptr ) (out) = wasm_f32x4_add( reg, wasm_v128_load32_splat( (void const*)(ptr) ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_add1_mem" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_madd' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2044, + "column": 3, + "source_line": " #define stbir__simdf_madd( out, add, mul1, mul2 ) (out) = wasm_f32x4_add( add, wasm_f32x4_mul( mul1, mul2 ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_madd" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_madd1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2045, + "column": 3, + "source_line": " #define stbir__simdf_madd1( out, add, mul1, mul2 ) (out) = wasm_f32x4_add( add, wasm_f32x4_mul( mul1, mul2 ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_madd1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_madd_mem' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2046, + "column": 3, + "source_line": " #define stbir__simdf_madd_mem( out, add, mul, ptr ) (out) = wasm_f32x4_add( add, wasm_f32x4_mul( mul, wasm_v128_load( (void const*)(ptr) ) ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_madd_mem" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_madd1_mem' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2047, + "column": 3, + "source_line": " #define stbir__simdf_madd1_mem( out, add, mul, ptr ) (out) = wasm_f32x4_add( add, wasm_f32x4_mul( mul, wasm_v128_load32_splat( (void const*)(ptr) ) ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_madd1_mem" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_add1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2049, + "column": 3, + "source_line": " #define stbir__simdf_add1( out, reg0, reg1 ) (out) = wasm_f32x4_add( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_add1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_mult1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2050, + "column": 3, + "source_line": " #define stbir__simdf_mult1( out, reg0, reg1 ) (out) = wasm_f32x4_mul( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_mult1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_and' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2052, + "column": 3, + "source_line": " #define stbir__simdf_and( out, reg0, reg1 ) (out) = wasm_v128_and( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_and" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_or' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2053, + "column": 3, + "source_line": " #define stbir__simdf_or( out, reg0, reg1 ) (out) = wasm_v128_or( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_or" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_min' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2055, + "column": 3, + "source_line": " #define stbir__simdf_min( out, reg0, reg1 ) (out) = wasm_f32x4_min( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_min" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_max' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2056, + "column": 3, + "source_line": " #define stbir__simdf_max( out, reg0, reg1 ) (out) = wasm_f32x4_max( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_max" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_min1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2057, + "column": 3, + "source_line": " #define stbir__simdf_min1( out, reg0, reg1 ) (out) = wasm_f32x4_min( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_min1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_max1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2058, + "column": 3, + "source_line": " #define stbir__simdf_max1( out, reg0, reg1 ) (out) = wasm_f32x4_max( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_max1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_0123ABCDto3ABx' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2060, + "column": 3, + "source_line": " #define stbir__simdf_0123ABCDto3ABx( out, reg0, reg1 ) (out) = wasm_i32x4_shuffle( reg0, reg1, 3, 4, 5, -1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_0123ABCDto3ABx" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_0123ABCDto23Ax' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2061, + "column": 3, + "source_line": " #define stbir__simdf_0123ABCDto23Ax( out, reg0, reg1 ) (out) = wasm_i32x4_shuffle( reg0, reg1, 2, 3, 4, -1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_0123ABCDto23Ax" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_aaa1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2063, + "column": 3, + "source_line": " #define stbir__simdf_aaa1(out,alp,ones) (out) = wasm_i32x4_shuffle(alp, ones, 3, 3, 3, 4)" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_aaa1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_1aaa' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2064, + "column": 3, + "source_line": " #define stbir__simdf_1aaa(out,alp,ones) (out) = wasm_i32x4_shuffle(alp, ones, 4, 0, 0, 0)" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_1aaa" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_a1a1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2065, + "column": 3, + "source_line": " #define stbir__simdf_a1a1(out,alp,ones) (out) = wasm_i32x4_shuffle(alp, ones, 1, 4, 3, 4)" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_a1a1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_1a1a' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2066, + "column": 3, + "source_line": " #define stbir__simdf_1a1a(out,alp,ones) (out) = wasm_i32x4_shuffle(alp, ones, 4, 0, 4, 2)" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_1a1a" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_swiz' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2068, + "column": 3, + "source_line": " #define stbir__simdf_swiz( reg, one, two, three, four ) wasm_i32x4_shuffle(reg, reg, one, two, three, four)" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_swiz" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_and' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2070, + "column": 3, + "source_line": " #define stbir__simdi_and( out, reg0, reg1 ) (out) = wasm_v128_and( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_and" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_or' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2071, + "column": 3, + "source_line": " #define stbir__simdi_or( out, reg0, reg1 ) (out) = wasm_v128_or( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_or" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_16madd' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2072, + "column": 3, + "source_line": " #define stbir__simdi_16madd( out, reg0, reg1 ) (out) = wasm_i32x4_dot_i16x8( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_16madd" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_pack_to_8bytes' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2074, + "column": 3, + "source_line": " #define stbir__simdf_pack_to_8bytes(out,aa,bb) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_pack_to_8bytes" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_pack_to_8words' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2084, + "column": 3, + "source_line": " #define stbir__simdf_pack_to_8words(out,aa,bb) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_pack_to_8words" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__interleave_pack_and_store_16_u8' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2093, + "column": 3, + "source_line": " #define stbir__interleave_pack_and_store_16_u8( ptr, r0, r1, r2, r3 ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__interleave_pack_and_store_16_u8" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_load4_transposed' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2102, + "column": 3, + "source_line": " #define stbir__simdf_load4_transposed( o0, o1, o2, o3, ptr ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_load4_transposed" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_32shr' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2118, + "column": 3, + "source_line": " #define stbir__simdi_32shr( out, reg, imm ) out = wasm_u32x4_shr( reg, imm )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_32shr" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR__SIMDF_CONST' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2121, + "column": 3, + "source_line": " #define STBIR__SIMDF_CONST(var, x) stbir__simdf var = (v128_t)(stbir__f32x4){ x, x, x, x }" + }, + "unit_kind": "macro", + "unit_name": "STBIR__SIMDF_CONST" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR__SIMDI_CONST' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2122, + "column": 3, + "source_line": " #define STBIR__SIMDI_CONST(var, x) stbir__simdi var = { x, x, x, x }" + }, + "unit_kind": "macro", + "unit_name": "STBIR__SIMDI_CONST" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR__CONSTF' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2123, + "column": 3, + "source_line": " #define STBIR__CONSTF(var) (var)" + }, + "unit_kind": "macro", + "unit_name": "STBIR__CONSTF" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR__CONSTI' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2124, + "column": 3, + "source_line": " #define STBIR__CONSTI(var) (var)" + }, + "unit_kind": "macro", + "unit_name": "STBIR__CONSTI" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__if_simdf8_cast_to_simdf4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2210, + "column": 3, + "source_line": " #define stbir__if_simdf8_cast_to_simdf4( val ) ( val )" + }, + "unit_kind": "macro", + "unit_name": "stbir__if_simdf8_cast_to_simdf4" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_0123to3333' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2536, + "column": 1, + "source_line": "#define stbir__simdf_0123to3333( out, reg ) (out) = stbir__simdf_swiz( reg, 3,3,3,3 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_0123to3333" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_0123to2222' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2537, + "column": 1, + "source_line": "#define stbir__simdf_0123to2222( out, reg ) (out) = stbir__simdf_swiz( reg, 2,2,2,2 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_0123to2222" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_0123to1111' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2538, + "column": 1, + "source_line": "#define stbir__simdf_0123to1111( out, reg ) (out) = stbir__simdf_swiz( reg, 1,1,1,1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_0123to1111" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_0123to0000' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2539, + "column": 1, + "source_line": "#define stbir__simdf_0123to0000( out, reg ) (out) = stbir__simdf_swiz( reg, 0,0,0,0 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_0123to0000" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_0123to0003' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2540, + "column": 1, + "source_line": "#define stbir__simdf_0123to0003( out, reg ) (out) = stbir__simdf_swiz( reg, 0,0,0,3 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_0123to0003" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_0123to0001' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2541, + "column": 1, + "source_line": "#define stbir__simdf_0123to0001( out, reg ) (out) = stbir__simdf_swiz( reg, 0,0,0,1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_0123to0001" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_0123to1122' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2542, + "column": 1, + "source_line": "#define stbir__simdf_0123to1122( out, reg ) (out) = stbir__simdf_swiz( reg, 1,1,2,2 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_0123to1122" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_0123to2333' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2543, + "column": 1, + "source_line": "#define stbir__simdf_0123to2333( out, reg ) (out) = stbir__simdf_swiz( reg, 2,3,3,3 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_0123to2333" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_0123to0023' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2544, + "column": 1, + "source_line": "#define stbir__simdf_0123to0023( out, reg ) (out) = stbir__simdf_swiz( reg, 0,0,2,3 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_0123to0023" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_0123to1230' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2545, + "column": 1, + "source_line": "#define stbir__simdf_0123to1230( out, reg ) (out) = stbir__simdf_swiz( reg, 1,2,3,0 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_0123to1230" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_0123to2103' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2546, + "column": 1, + "source_line": "#define stbir__simdf_0123to2103( out, reg ) (out) = stbir__simdf_swiz( reg, 2,1,0,3 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_0123to2103" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_0123to3210' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2547, + "column": 1, + "source_line": "#define stbir__simdf_0123to3210( out, reg ) (out) = stbir__simdf_swiz( reg, 3,2,1,0 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_0123to3210" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_0123to2301' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2548, + "column": 1, + "source_line": "#define stbir__simdf_0123to2301( out, reg ) (out) = stbir__simdf_swiz( reg, 2,3,0,1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_0123to2301" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_0123to3012' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2549, + "column": 1, + "source_line": "#define stbir__simdf_0123to3012( out, reg ) (out) = stbir__simdf_swiz( reg, 3,0,1,2 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_0123to3012" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_0123to0011' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2550, + "column": 1, + "source_line": "#define stbir__simdf_0123to0011( out, reg ) (out) = stbir__simdf_swiz( reg, 0,0,1,1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_0123to0011" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_0123to1100' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2551, + "column": 1, + "source_line": "#define stbir__simdf_0123to1100( out, reg ) (out) = stbir__simdf_swiz( reg, 1,1,0,0 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_0123to1100" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_0123to2233' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2552, + "column": 1, + "source_line": "#define stbir__simdf_0123to2233( out, reg ) (out) = stbir__simdf_swiz( reg, 2,2,3,3 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_0123to2233" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_0123to1133' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2553, + "column": 1, + "source_line": "#define stbir__simdf_0123to1133( out, reg ) (out) = stbir__simdf_swiz( reg, 1,1,3,3 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_0123to1133" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_0123to0022' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2554, + "column": 1, + "source_line": "#define stbir__simdf_0123to0022( out, reg ) (out) = stbir__simdf_swiz( reg, 0,0,2,2 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_0123to0022" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_0123to1032' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2555, + "column": 1, + "source_line": "#define stbir__simdf_0123to1032( out, reg ) (out) = stbir__simdf_swiz( reg, 1,0,3,2 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_0123to1032" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_SIMD_STREAMOUT_PTR' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2581, + "column": 1, + "source_line": "#define STBIR_SIMD_STREAMOUT_PTR( star ) STBIR_STREAMOUT_PTR( star )" + }, + "unit_kind": "macro", + "unit_name": "STBIR_SIMD_STREAMOUT_PTR" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_SIMD_NO_UNROLL' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2582, + "column": 1, + "source_line": "#define STBIR_SIMD_NO_UNROLL(ptr) STBIR_NO_UNROLL(ptr)" + }, + "unit_kind": "macro", + "unit_name": "STBIR_SIMD_NO_UNROLL" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_SIMD_STREAMOUT_PTR' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2719, + "column": 1, + "source_line": "#define STBIR_SIMD_STREAMOUT_PTR( star ) STBIR_STREAMOUT_PTR( star )" + }, + "unit_kind": "macro", + "unit_name": "STBIR_SIMD_STREAMOUT_PTR" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_SIMD_NO_UNROLL' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2720, + "column": 1, + "source_line": "#define STBIR_SIMD_NO_UNROLL(ptr)" + }, + "unit_kind": "macro", + "unit_name": "STBIR_SIMD_NO_UNROLL" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_PROFILE_FUNC' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2736, + "column": 3, + "source_line": " #define STBIR_PROFILE_FUNC() __rdtsc()" + }, + "unit_kind": "macro", + "unit_name": "STBIR_PROFILE_FUNC" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_PROFILE_FUNC' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2753, + "column": 3, + "source_line": " #define STBIR_PROFILE_FUNC() _ReadStatusReg(ARM64_CNTVCT)" + }, + "unit_kind": "macro", + "unit_name": "STBIR_PROFILE_FUNC" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_PROFILE_START_ll' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2781, + "column": 1, + "source_line": "#define STBIR_PROFILE_START_ll( info, wh ) { stbir_uint64 wh##thiszonetime = STBIR_PROFILE_FUNC(); stbir_uint64 * wh##save_parent_excluded_ptr = info->current_zone_excluded_ptr; stbir_uint64 wh##current_zone_excluded = 0; info->current_zone_excluded_ptr = &wh##current_zone_excluded;" + }, + "unit_kind": "macro", + "unit_name": "STBIR_PROFILE_START_ll" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_PROFILE_END_ll' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2782, + "column": 1, + "source_line": "#define STBIR_PROFILE_END_ll( info, wh ) wh##thiszonetime = STBIR_PROFILE_FUNC() - wh##thiszonetime; info->profile.named.wh += wh##thiszonetime - wh##current_zone_excluded; *wh##save_parent_excluded_ptr += wh##thiszonetime; info->current_zone_excluded_ptr = wh##save_parent_excluded_ptr; }" + }, + "unit_kind": "macro", + "unit_name": "STBIR_PROFILE_END_ll" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_PROFILE_FIRST_START_ll' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2783, + "column": 1, + "source_line": "#define STBIR_PROFILE_FIRST_START_ll( info, wh ) { int i; info->current_zone_excluded_ptr = &info->profile.named.total; for(i=0;iprofile.array);i++) info->profile.array[i]=0; } STBIR_PROFILE_START_ll( info, wh );" + }, + "unit_kind": "macro", + "unit_name": "STBIR_PROFILE_FIRST_START_ll" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_PROFILE_CLEAR_EXTRAS_ll' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2784, + "column": 1, + "source_line": "#define STBIR_PROFILE_CLEAR_EXTRAS_ll( info, num ) { int extra; for(extra=1;extra<(num);extra++) { int i; for(i=0;iprofile.array);i++) (info)[extra].profile.array[i]=0; } }" + }, + "unit_kind": "macro", + "unit_name": "STBIR_PROFILE_CLEAR_EXTRAS_ll" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_PROFILE_START' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2787, + "column": 1, + "source_line": "#define STBIR_PROFILE_START( wh ) STBIR_PROFILE_START_ll( split_info, wh )" + }, + "unit_kind": "macro", + "unit_name": "STBIR_PROFILE_START" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_PROFILE_END' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2788, + "column": 1, + "source_line": "#define STBIR_PROFILE_END( wh ) STBIR_PROFILE_END_ll( split_info, wh )" + }, + "unit_kind": "macro", + "unit_name": "STBIR_PROFILE_END" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_PROFILE_FIRST_START' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2789, + "column": 1, + "source_line": "#define STBIR_PROFILE_FIRST_START( wh ) STBIR_PROFILE_FIRST_START_ll( split_info, wh )" + }, + "unit_kind": "macro", + "unit_name": "STBIR_PROFILE_FIRST_START" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_PROFILE_CLEAR_EXTRAS' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2790, + "column": 1, + "source_line": "#define STBIR_PROFILE_CLEAR_EXTRAS() STBIR_PROFILE_CLEAR_EXTRAS_ll( split_info, split_count )" + }, + "unit_kind": "macro", + "unit_name": "STBIR_PROFILE_CLEAR_EXTRAS" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_PROFILE_BUILD_START' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2793, + "column": 1, + "source_line": "#define STBIR_PROFILE_BUILD_START( wh ) STBIR_PROFILE_START_ll( profile_info, wh )" + }, + "unit_kind": "macro", + "unit_name": "STBIR_PROFILE_BUILD_START" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_PROFILE_BUILD_END' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2794, + "column": 1, + "source_line": "#define STBIR_PROFILE_BUILD_END( wh ) STBIR_PROFILE_END_ll( profile_info, wh )" + }, + "unit_kind": "macro", + "unit_name": "STBIR_PROFILE_BUILD_END" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_PROFILE_BUILD_FIRST_START' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2795, + "column": 1, + "source_line": "#define STBIR_PROFILE_BUILD_FIRST_START( wh ) STBIR_PROFILE_FIRST_START_ll( profile_info, wh )" + }, + "unit_kind": "macro", + "unit_name": "STBIR_PROFILE_BUILD_FIRST_START" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_PROFILE_BUILD_CLEAR' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2796, + "column": 1, + "source_line": "#define STBIR_PROFILE_BUILD_CLEAR( info ) { int i; for(i=0;iprofile.array);i++) info->profile.array[i]=0; }" + }, + "unit_kind": "macro", + "unit_name": "STBIR_PROFILE_BUILD_CLEAR" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_PROFILE_START' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2806, + "column": 1, + "source_line": "#define STBIR_PROFILE_START( wh )" + }, + "unit_kind": "macro", + "unit_name": "STBIR_PROFILE_START" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_PROFILE_END' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2807, + "column": 1, + "source_line": "#define STBIR_PROFILE_END( wh )" + }, + "unit_kind": "macro", + "unit_name": "STBIR_PROFILE_END" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_PROFILE_FIRST_START' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2808, + "column": 1, + "source_line": "#define STBIR_PROFILE_FIRST_START( wh )" + }, + "unit_kind": "macro", + "unit_name": "STBIR_PROFILE_FIRST_START" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_PROFILE_CLEAR_EXTRAS' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2809, + "column": 1, + "source_line": "#define STBIR_PROFILE_CLEAR_EXTRAS( )" + }, + "unit_kind": "macro", + "unit_name": "STBIR_PROFILE_CLEAR_EXTRAS" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_PROFILE_BUILD_START' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2811, + "column": 1, + "source_line": "#define STBIR_PROFILE_BUILD_START( wh )" + }, + "unit_kind": "macro", + "unit_name": "STBIR_PROFILE_BUILD_START" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_PROFILE_BUILD_END' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2812, + "column": 1, + "source_line": "#define STBIR_PROFILE_BUILD_END( wh )" + }, + "unit_kind": "macro", + "unit_name": "STBIR_PROFILE_BUILD_END" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_PROFILE_BUILD_FIRST_START' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2813, + "column": 1, + "source_line": "#define STBIR_PROFILE_BUILD_FIRST_START( wh )" + }, + "unit_kind": "macro", + "unit_name": "STBIR_PROFILE_BUILD_FIRST_START" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_PROFILE_BUILD_CLEAR' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2814, + "column": 1, + "source_line": "#define STBIR_PROFILE_BUILD_CLEAR( info )" + }, + "unit_kind": "macro", + "unit_name": "STBIR_PROFILE_BUILD_CLEAR" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_CEILF' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2821, + "column": 1, + "source_line": "#define STBIR_CEILF(x) ((float)ceil((float)(x)))" + }, + "unit_kind": "macro", + "unit_name": "STBIR_CEILF" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_FLOORF' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2822, + "column": 1, + "source_line": "#define STBIR_FLOORF(x) ((float)floor((float)(x)))" + }, + "unit_kind": "macro", + "unit_name": "STBIR_FLOORF" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_CEILF' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2824, + "column": 1, + "source_line": "#define STBIR_CEILF(x) ceilf(x)" + }, + "unit_kind": "macro", + "unit_name": "STBIR_CEILF" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_FLOORF' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2825, + "column": 1, + "source_line": "#define STBIR_FLOORF(x) floorf(x)" + }, + "unit_kind": "macro", + "unit_name": "STBIR_FLOORF" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_MEMCPY' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2832, + "column": 1, + "source_line": "#define STBIR_MEMCPY( dest, src, len ) memcpy( dest, src, len )" + }, + "unit_kind": "macro", + "unit_name": "STBIR_MEMCPY" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_MOVE_1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 3698, + "column": 3, + "source_line": " #define STBIR_MOVE_1( dest, src ) { STBIR_NO_UNROLL(dest); ((stbir_uint32*)(dest))[0] = ((stbir_uint32*)(src))[0]; }" + }, + "unit_kind": "macro", + "unit_name": "STBIR_MOVE_1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_MOVE_2' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 3699, + "column": 3, + "source_line": " #define STBIR_MOVE_2( dest, src ) { STBIR_NO_UNROLL(dest); ((stbir_uint64*)(dest))[0] = ((stbir_uint64*)(src))[0]; }" + }, + "unit_kind": "macro", + "unit_name": "STBIR_MOVE_2" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_MOVE_4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 3701, + "column": 3, + "source_line": " #define STBIR_MOVE_4( dest, src ) { stbir__simdf t; STBIR_NO_UNROLL(dest); stbir__simdf_load( t, src ); stbir__simdf_store( dest, t ); }" + }, + "unit_kind": "macro", + "unit_name": "STBIR_MOVE_4" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_MOVE_4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 3703, + "column": 3, + "source_line": " #define STBIR_MOVE_4( dest, src ) { STBIR_NO_UNROLL(dest); ((stbir_uint64*)(dest))[0] = ((stbir_uint64*)(src))[0]; ((stbir_uint64*)(dest))[1] = ((stbir_uint64*)(src))[1]; }" + }, + "unit_kind": "macro", + "unit_name": "STBIR_MOVE_4" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__1_coeff_only' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4710, + "column": 1, + "source_line": "#define stbir__1_coeff_only() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__1_coeff_only" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__2_coeff_only' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4716, + "column": 1, + "source_line": "#define stbir__2_coeff_only() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__2_coeff_only" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__3_coeff_only' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4725, + "column": 1, + "source_line": "#define stbir__3_coeff_only() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__3_coeff_only" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__store_output_tiny' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4735, + "column": 1, + "source_line": "#define stbir__store_output_tiny() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__store_output_tiny" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__4_coeff_start' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4741, + "column": 1, + "source_line": "#define stbir__4_coeff_start() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__4_coeff_start" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__4_coeff_continue_from_4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4747, + "column": 1, + "source_line": "#define stbir__4_coeff_continue_from_4( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__4_coeff_continue_from_4" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__1_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4752, + "column": 1, + "source_line": "#define stbir__1_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__1_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__2_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4758, + "column": 1, + "source_line": "#define stbir__2_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__2_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__3_coeff_setup' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4764, + "column": 1, + "source_line": "#define stbir__3_coeff_setup() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__3_coeff_setup" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__3_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4768, + "column": 1, + "source_line": "#define stbir__3_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__3_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__store_output' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4773, + "column": 1, + "source_line": "#define stbir__store_output() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__store_output" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__1_coeff_only' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4785, + "column": 1, + "source_line": "#define stbir__1_coeff_only() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__1_coeff_only" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__2_coeff_only' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4789, + "column": 1, + "source_line": "#define stbir__2_coeff_only() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__2_coeff_only" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__3_coeff_only' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4794, + "column": 1, + "source_line": "#define stbir__3_coeff_only() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__3_coeff_only" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__store_output_tiny' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4800, + "column": 1, + "source_line": "#define stbir__store_output_tiny() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__store_output_tiny" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__4_coeff_start' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4806, + "column": 1, + "source_line": "#define stbir__4_coeff_start() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__4_coeff_start" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__4_coeff_continue_from_4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4813, + "column": 1, + "source_line": "#define stbir__4_coeff_continue_from_4( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__4_coeff_continue_from_4" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__1_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4819, + "column": 1, + "source_line": "#define stbir__1_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__1_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__2_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4822, + "column": 1, + "source_line": "#define stbir__2_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__2_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__3_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4826, + "column": 1, + "source_line": "#define stbir__3_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__3_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__store_output' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4831, + "column": 1, + "source_line": "#define stbir__store_output() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__store_output" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__1_coeff_only' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4849, + "column": 1, + "source_line": "#define stbir__1_coeff_only() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__1_coeff_only" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__2_coeff_only' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4857, + "column": 1, + "source_line": "#define stbir__2_coeff_only() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__2_coeff_only" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__3_coeff_only' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4864, + "column": 1, + "source_line": "#define stbir__3_coeff_only() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__3_coeff_only" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__store_output_tiny' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4874, + "column": 1, + "source_line": "#define stbir__store_output_tiny() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__store_output_tiny" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__4_coeff_start' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4884, + "column": 1, + "source_line": "#define stbir__4_coeff_start() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__4_coeff_start" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__4_coeff_continue_from_4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4891, + "column": 1, + "source_line": "#define stbir__4_coeff_continue_from_4( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__4_coeff_continue_from_4" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__1_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4897, + "column": 1, + "source_line": "#define stbir__1_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__1_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__2_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4905, + "column": 1, + "source_line": "#define stbir__2_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__2_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__3_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4912, + "column": 1, + "source_line": "#define stbir__3_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__3_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__store_output' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4919, + "column": 1, + "source_line": "#define stbir__store_output() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__store_output" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__4_coeff_start' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4931, + "column": 1, + "source_line": "#define stbir__4_coeff_start() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__4_coeff_start" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__4_coeff_continue_from_4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4940, + "column": 1, + "source_line": "#define stbir__4_coeff_continue_from_4( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__4_coeff_continue_from_4" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__1_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4948, + "column": 1, + "source_line": "#define stbir__1_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__1_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__2_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4955, + "column": 1, + "source_line": "#define stbir__2_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__2_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__3_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4960, + "column": 1, + "source_line": "#define stbir__3_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__3_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__store_output' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4969, + "column": 1, + "source_line": "#define stbir__store_output() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__store_output" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__1_coeff_only' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4982, + "column": 1, + "source_line": "#define stbir__1_coeff_only() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__1_coeff_only" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__2_coeff_only' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4988, + "column": 1, + "source_line": "#define stbir__2_coeff_only() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__2_coeff_only" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__3_coeff_only' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4998, + "column": 1, + "source_line": "#define stbir__3_coeff_only() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__3_coeff_only" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__store_output_tiny' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5010, + "column": 1, + "source_line": "#define stbir__store_output_tiny() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__store_output_tiny" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__4_coeff_start' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5017, + "column": 1, + "source_line": "#define stbir__4_coeff_start() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__4_coeff_start" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__4_coeff_continue_from_4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5032, + "column": 1, + "source_line": "#define stbir__4_coeff_continue_from_4( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__4_coeff_continue_from_4" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__1_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5046, + "column": 1, + "source_line": "#define stbir__1_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__1_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__2_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5051, + "column": 1, + "source_line": "#define stbir__2_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__2_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__3_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5059, + "column": 1, + "source_line": "#define stbir__3_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__3_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__store_output' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5070, + "column": 1, + "source_line": "#define stbir__store_output() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__store_output" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__1_coeff_only' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5089, + "column": 1, + "source_line": "#define stbir__1_coeff_only() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__1_coeff_only" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__2_coeff_only' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5097, + "column": 1, + "source_line": "#define stbir__2_coeff_only() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__2_coeff_only" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__3_coeff_only' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5108, + "column": 1, + "source_line": "#define stbir__3_coeff_only() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__3_coeff_only" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__store_output_tiny' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5122, + "column": 1, + "source_line": "#define stbir__store_output_tiny() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__store_output_tiny" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__4_coeff_start' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5133, + "column": 1, + "source_line": "#define stbir__4_coeff_start() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__4_coeff_start" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__4_coeff_continue_from_4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5142, + "column": 1, + "source_line": "#define stbir__4_coeff_continue_from_4( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__4_coeff_continue_from_4" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__1_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5150, + "column": 1, + "source_line": "#define stbir__1_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__1_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__2_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5155, + "column": 1, + "source_line": "#define stbir__2_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__2_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__3_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5161, + "column": 2, + "source_line": " #define stbir__3_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__3_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__store_output' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5169, + "column": 1, + "source_line": "#define stbir__store_output() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__store_output" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__4_coeff_start' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5189, + "column": 1, + "source_line": "#define stbir__4_coeff_start() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__4_coeff_start" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__4_coeff_continue_from_4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5200, + "column": 1, + "source_line": "#define stbir__4_coeff_continue_from_4( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__4_coeff_continue_from_4" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__1_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5210, + "column": 1, + "source_line": "#define stbir__1_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__1_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__2_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5216, + "column": 1, + "source_line": "#define stbir__2_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__2_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__3_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5226, + "column": 1, + "source_line": "#define stbir__3_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__3_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__store_output' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5238, + "column": 1, + "source_line": "#define stbir__store_output() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__store_output" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__1_coeff_only' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5262, + "column": 1, + "source_line": "#define stbir__1_coeff_only() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__1_coeff_only" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__2_coeff_only' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5269, + "column": 1, + "source_line": "#define stbir__2_coeff_only() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__2_coeff_only" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__3_coeff_only' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5280, + "column": 1, + "source_line": "#define stbir__3_coeff_only() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__3_coeff_only" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__store_output_tiny' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5295, + "column": 1, + "source_line": "#define stbir__store_output_tiny() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__store_output_tiny" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__4_coeff_start' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5303, + "column": 1, + "source_line": "#define stbir__4_coeff_start() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__4_coeff_start" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__4_coeff_continue_from_4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5322, + "column": 1, + "source_line": "#define stbir__4_coeff_continue_from_4( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__4_coeff_continue_from_4" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__1_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5340, + "column": 1, + "source_line": "#define stbir__1_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__1_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__2_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5346, + "column": 1, + "source_line": "#define stbir__2_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__2_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__3_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5356, + "column": 1, + "source_line": "#define stbir__3_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__3_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__store_output' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5370, + "column": 1, + "source_line": "#define stbir__store_output() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__store_output" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__1_coeff_only' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5389, + "column": 1, + "source_line": "#define stbir__1_coeff_only() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__1_coeff_only" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__2_coeff_only' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5396, + "column": 1, + "source_line": "#define stbir__2_coeff_only() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__2_coeff_only" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__3_coeff_only' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5405, + "column": 1, + "source_line": "#define stbir__3_coeff_only() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__3_coeff_only" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__store_output_tiny' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5416, + "column": 1, + "source_line": "#define stbir__store_output_tiny() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__store_output_tiny" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__4_coeff_start' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5424, + "column": 1, + "source_line": "#define stbir__4_coeff_start() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__4_coeff_start" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__4_coeff_continue_from_4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5433, + "column": 1, + "source_line": "#define stbir__4_coeff_continue_from_4( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__4_coeff_continue_from_4" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__1_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5441, + "column": 1, + "source_line": "#define stbir__1_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__1_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__2_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5446, + "column": 1, + "source_line": "#define stbir__2_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__2_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__3_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5452, + "column": 2, + "source_line": " #define stbir__3_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__3_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__store_output' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5460, + "column": 1, + "source_line": "#define stbir__store_output() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__store_output" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__4_coeff_start' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5469, + "column": 1, + "source_line": "#define stbir__4_coeff_start() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__4_coeff_start" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__4_coeff_continue_from_4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5482, + "column": 1, + "source_line": "#define stbir__4_coeff_continue_from_4( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__4_coeff_continue_from_4" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__1_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5494, + "column": 1, + "source_line": "#define stbir__1_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__1_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__2_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5500, + "column": 1, + "source_line": "#define stbir__2_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__2_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__3_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5508, + "column": 1, + "source_line": "#define stbir__3_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__3_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__store_output' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5518, + "column": 1, + "source_line": "#define stbir__store_output() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__store_output" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__1_coeff_only' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5529, + "column": 1, + "source_line": "#define stbir__1_coeff_only() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__1_coeff_only" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__2_coeff_only' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5538, + "column": 1, + "source_line": "#define stbir__2_coeff_only() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__2_coeff_only" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__3_coeff_only' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5552, + "column": 1, + "source_line": "#define stbir__3_coeff_only() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__3_coeff_only" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__store_output_tiny' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5571, + "column": 1, + "source_line": "#define stbir__store_output_tiny() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__store_output_tiny" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__4_coeff_start' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5580, + "column": 1, + "source_line": "#define stbir__4_coeff_start() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__4_coeff_start" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__4_coeff_continue_from_4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5604, + "column": 1, + "source_line": "#define stbir__4_coeff_continue_from_4( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__4_coeff_continue_from_4" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__1_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5627, + "column": 1, + "source_line": "#define stbir__1_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__1_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__2_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5635, + "column": 1, + "source_line": "#define stbir__2_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__2_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__3_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5648, + "column": 1, + "source_line": "#define stbir__3_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__3_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__store_output' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5666, + "column": 1, + "source_line": "#define stbir__store_output() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__store_output" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__1_coeff_only' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5688, + "column": 1, + "source_line": "#define stbir__1_coeff_only() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__1_coeff_only" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__2_coeff_only' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5696, + "column": 1, + "source_line": "#define stbir__2_coeff_only() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__2_coeff_only" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__3_coeff_only' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5707, + "column": 1, + "source_line": "#define stbir__3_coeff_only() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__3_coeff_only" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__store_output_tiny' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5721, + "column": 1, + "source_line": "#define stbir__store_output_tiny() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__store_output_tiny" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__4_coeff_start' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5730, + "column": 1, + "source_line": "#define stbir__4_coeff_start() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__4_coeff_start" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__4_coeff_continue_from_4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5743, + "column": 1, + "source_line": "#define stbir__4_coeff_continue_from_4( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__4_coeff_continue_from_4" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__1_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5755, + "column": 1, + "source_line": "#define stbir__1_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__1_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__2_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5760, + "column": 1, + "source_line": "#define stbir__2_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__2_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__3_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5767, + "column": 1, + "source_line": "#define stbir__3_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__3_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__store_output' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5777, + "column": 1, + "source_line": "#define stbir__store_output() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__store_output" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__4_coeff_start' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5793, + "column": 1, + "source_line": "#define stbir__4_coeff_start() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__4_coeff_start" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__4_coeff_continue_from_4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5810, + "column": 1, + "source_line": "#define stbir__4_coeff_continue_from_4( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__4_coeff_continue_from_4" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__1_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5826, + "column": 1, + "source_line": "#define stbir__1_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__1_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__2_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5833, + "column": 1, + "source_line": "#define stbir__2_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__2_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__3_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5843, + "column": 1, + "source_line": "#define stbir__3_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__3_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__store_output' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5856, + "column": 1, + "source_line": "#define stbir__store_output() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__store_output" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__1_coeff_only' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5869, + "column": 1, + "source_line": "#define stbir__1_coeff_only() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__1_coeff_only" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__2_coeff_only' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5880, + "column": 1, + "source_line": "#define stbir__2_coeff_only() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__2_coeff_only" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__3_coeff_only' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5899, + "column": 1, + "source_line": "#define stbir__3_coeff_only() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__3_coeff_only" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__store_output_tiny' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5926, + "column": 1, + "source_line": "#define stbir__store_output_tiny() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__store_output_tiny" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__4_coeff_start' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5938, + "column": 1, + "source_line": "#define stbir__4_coeff_start() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__4_coeff_start" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__4_coeff_continue_from_4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5974, + "column": 1, + "source_line": "#define stbir__4_coeff_continue_from_4( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__4_coeff_continue_from_4" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__1_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 6009, + "column": 1, + "source_line": "#define stbir__1_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__1_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__2_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 6020, + "column": 1, + "source_line": "#define stbir__2_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__2_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__3_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 6039, + "column": 1, + "source_line": "#define stbir__3_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__3_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__store_output' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 6066, + "column": 1, + "source_line": "#define stbir__store_output() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__store_output" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR__FLOAT_BUFFER_IS_EMPTY' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 6372, + "column": 1, + "source_line": "#define STBIR__FLOAT_BUFFER_IS_EMPTY(ptr) ((ptr)[0]==STBIR__FLOAT_EMPTY_MARKER)" + }, + "unit_kind": "macro", + "unit_name": "STBIR__FLOAT_BUFFER_IS_EMPTY" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR__FREE_AND_CLEAR' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 6819, + "column": 3, + "source_line": " #define STBIR__FREE_AND_CLEAR( ptr ) { if ( ptr ) { void * p = (ptr); (ptr) = 0; STBIR_FREE( p, info->user_data); } }" + }, + "unit_kind": "macro", + "unit_name": "STBIR__FREE_AND_CLEAR" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR__NEXT_PTR' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 7143, + "column": 5, + "source_line": " #define STBIR__NEXT_PTR( ptr, size, ntype ) if ( alloced ) { void * p = STBIR_MALLOC( size, user_data); if ( p == 0 ) { stbir__free_internal_mem( info ); return 0; } (ptr) = (ntype*)p; }" + }, + "unit_kind": "macro", + "unit_name": "STBIR__NEXT_PTR" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR__NEXT_PTR' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 7145, + "column": 5, + "source_line": " #define STBIR__NEXT_PTR( ptr, size, ntype ) advance_mem = (void*) ( ( ((size_t)advance_mem) + 15 ) & ~15 ); if ( alloced ) ptr = (ntype*)advance_mem; advance_mem = (char*)(((size_t)advance_mem) + (size));" + }, + "unit_kind": "macro", + "unit_name": "STBIR__NEXT_PTR" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_RETURN_ERROR_AND_ASSERT' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 7891, + "column": 3, + "source_line": " #define STBIR_RETURN_ERROR_AND_ASSERT( exp ) STBIR_ASSERT( !(exp) ); if (exp) return 0;" + }, + "unit_kind": "macro", + "unit_name": "STBIR_RETURN_ERROR_AND_ASSERT" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_strs_join2' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8253, + "column": 1, + "source_line": "#define STBIR_strs_join2( start, mid, end ) start##mid##end" + }, + "unit_kind": "macro", + "unit_name": "STBIR_strs_join2" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_strs_join1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8254, + "column": 1, + "source_line": "#define STBIR_strs_join1( start, mid, end ) STBIR_strs_join2( start, mid, end )" + }, + "unit_kind": "macro", + "unit_name": "STBIR_strs_join1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_strs_join24' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8256, + "column": 1, + "source_line": "#define STBIR_strs_join24( start, mid1, mid2, end ) start##mid1##mid2##end" + }, + "unit_kind": "macro", + "unit_name": "STBIR_strs_join24" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_strs_join14' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8257, + "column": 1, + "source_line": "#define STBIR_strs_join14( start, mid1, mid2, end ) STBIR_strs_join24( start, mid1, mid2, end )" + }, + "unit_kind": "macro", + "unit_name": "STBIR_strs_join14" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR__CODER_NAME' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8262, + "column": 1, + "source_line": "#define STBIR__CODER_NAME( name ) STBIR_strs_join1( name, _, stbir__decode_suffix )" + }, + "unit_kind": "macro", + "unit_name": "STBIR__CODER_NAME" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR__CODER_NAME' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8264, + "column": 1, + "source_line": "#define STBIR__CODER_NAME( name ) name" + }, + "unit_kind": "macro", + "unit_name": "STBIR__CODER_NAME" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__decode_simdf8_flip' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8268, + "column": 1, + "source_line": "#define stbir__decode_simdf8_flip(reg) STBIR_strs_join1( STBIR_strs_join1( STBIR_strs_join1( STBIR_strs_join1( stbir__simdf8_0123to,stbir__decode_order0,stbir__decode_order1),stbir__decode_order2,stbir__decode_order3),stbir__decode_order0,stbir__decode_order1),stbir__decode_order2,stbir__decode_order3)(reg, reg)" + }, + "unit_kind": "macro", + "unit_name": "stbir__decode_simdf8_flip" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__decode_simdf4_flip' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8269, + "column": 1, + "source_line": "#define stbir__decode_simdf4_flip(reg) STBIR_strs_join1( STBIR_strs_join1( stbir__simdf_0123to,stbir__decode_order0,stbir__decode_order1),stbir__decode_order2,stbir__decode_order3)(reg, reg)" + }, + "unit_kind": "macro", + "unit_name": "stbir__decode_simdf4_flip" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__encode_simdf8_unflip' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8270, + "column": 1, + "source_line": "#define stbir__encode_simdf8_unflip(reg) STBIR_strs_join1( STBIR_strs_join1( STBIR_strs_join1( STBIR_strs_join1( stbir__simdf8_0123to,stbir__encode_order0,stbir__encode_order1),stbir__encode_order2,stbir__encode_order3),stbir__encode_order0,stbir__encode_order1),stbir__encode_order2,stbir__encode_order3)(reg, reg)" + }, + "unit_kind": "macro", + "unit_name": "stbir__encode_simdf8_unflip" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__encode_simdf4_unflip' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8271, + "column": 1, + "source_line": "#define stbir__encode_simdf4_unflip(reg) STBIR_strs_join1( STBIR_strs_join1( stbir__simdf_0123to,stbir__encode_order0,stbir__encode_order1),stbir__encode_order2,stbir__encode_order3)(reg, reg)" + }, + "unit_kind": "macro", + "unit_name": "stbir__encode_simdf4_unflip" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__decode_simdf8_flip' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8281, + "column": 1, + "source_line": "#define stbir__decode_simdf8_flip(reg)" + }, + "unit_kind": "macro", + "unit_name": "stbir__decode_simdf8_flip" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__decode_simdf4_flip' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8282, + "column": 1, + "source_line": "#define stbir__decode_simdf4_flip(reg)" + }, + "unit_kind": "macro", + "unit_name": "stbir__decode_simdf4_flip" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__encode_simdf8_unflip' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8283, + "column": 1, + "source_line": "#define stbir__encode_simdf8_unflip(reg)" + }, + "unit_kind": "macro", + "unit_name": "stbir__encode_simdf8_unflip" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__encode_simdf4_unflip' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8284, + "column": 1, + "source_line": "#define stbir__encode_simdf4_unflip(reg)" + }, + "unit_kind": "macro", + "unit_name": "stbir__encode_simdf4_unflip" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__min_max_shift20' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8747, + "column": 1, + "source_line": "#define stbir__min_max_shift20( i, f ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__min_max_shift20" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__scale_and_convert' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8752, + "column": 1, + "source_line": "#define stbir__scale_and_convert( i, f ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__scale_and_convert" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__linear_to_srgb_finish' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8758, + "column": 1, + "source_line": "#define stbir__linear_to_srgb_finish( i, f ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__linear_to_srgb_finish" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_table_lookup2' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8768, + "column": 1, + "source_line": "#define stbir__simdi_table_lookup2( v0,v1, table ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_table_lookup2" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_table_lookup3' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8779, + "column": 1, + "source_line": "#define stbir__simdi_table_lookup3( v0,v1,v2, table ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_table_lookup3" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_table_lookup4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8793, + "column": 1, + "source_line": "#define stbir__simdi_table_lookup4( v0,v1,v2,v3, table ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_table_lookup4" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir_scalar_hi_clamp' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 9750, + "column": 3, + "source_line": " #define stbir_scalar_hi_clamp( v ) if ( v > STBIR_FLOAT_HIGH_CLAMP ) v = STBIR_FLOAT_HIGH_CLAMP;" + }, + "unit_kind": "macro", + "unit_name": "stbir_scalar_hi_clamp" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir_scalar_hi_clamp' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 9752, + "column": 3, + "source_line": " #define stbir_scalar_hi_clamp( v )" + }, + "unit_kind": "macro", + "unit_name": "stbir_scalar_hi_clamp" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir_scalar_lo_clamp' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 9755, + "column": 3, + "source_line": " #define stbir_scalar_lo_clamp( v ) if ( v < STBIR_FLOAT_LOW_CLAMP ) v = STBIR_FLOAT_LOW_CLAMP;" + }, + "unit_kind": "macro", + "unit_name": "stbir_scalar_lo_clamp" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir_scalar_lo_clamp' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 9757, + "column": 3, + "source_line": " #define stbir_scalar_lo_clamp( v )" + }, + "unit_kind": "macro", + "unit_name": "stbir_scalar_lo_clamp" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_chans' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 9896, + "column": 1, + "source_line": "#define STBIR_chans( start, end ) STBIR_strs_join14(start,STBIR__vertical_channels,end,_cont)" + }, + "unit_kind": "macro", + "unit_name": "STBIR_chans" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_chans' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 9898, + "column": 1, + "source_line": "#define STBIR_chans( start, end ) STBIR_strs_join1(start,STBIR__vertical_channels,end)" + }, + "unit_kind": "macro", + "unit_name": "STBIR_chans" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbIF0' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 9902, + "column": 1, + "source_line": "#define stbIF0( code ) code" + }, + "unit_kind": "macro", + "unit_name": "stbIF0" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbIF0' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 9904, + "column": 1, + "source_line": "#define stbIF0( code )" + }, + "unit_kind": "macro", + "unit_name": "stbIF0" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbIF1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 9907, + "column": 1, + "source_line": "#define stbIF1( code ) code" + }, + "unit_kind": "macro", + "unit_name": "stbIF1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbIF1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 9909, + "column": 1, + "source_line": "#define stbIF1( code )" + }, + "unit_kind": "macro", + "unit_name": "stbIF1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbIF2' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 9912, + "column": 1, + "source_line": "#define stbIF2( code ) code" + }, + "unit_kind": "macro", + "unit_name": "stbIF2" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbIF2' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 9914, + "column": 1, + "source_line": "#define stbIF2( code )" + }, + "unit_kind": "macro", + "unit_name": "stbIF2" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbIF3' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 9917, + "column": 1, + "source_line": "#define stbIF3( code ) code" + }, + "unit_kind": "macro", + "unit_name": "stbIF3" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbIF3' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 9919, + "column": 1, + "source_line": "#define stbIF3( code )" + }, + "unit_kind": "macro", + "unit_name": "stbIF3" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbIF4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 9922, + "column": 1, + "source_line": "#define stbIF4( code ) code" + }, + "unit_kind": "macro", + "unit_name": "stbIF4" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbIF4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 9924, + "column": 1, + "source_line": "#define stbIF4( code )" + }, + "unit_kind": "macro", + "unit_name": "stbIF4" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbIF5' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 9927, + "column": 1, + "source_line": "#define stbIF5( code ) code" + }, + "unit_kind": "macro", + "unit_name": "stbIF5" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbIF5' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 9929, + "column": 1, + "source_line": "#define stbIF5( code )" + }, + "unit_kind": "macro", + "unit_name": "stbIF5" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbIF6' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 9932, + "column": 1, + "source_line": "#define stbIF6( code ) code" + }, + "unit_kind": "macro", + "unit_name": "stbIF6" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbIF6' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 9934, + "column": 1, + "source_line": "#define stbIF6( code )" + }, + "unit_kind": "macro", + "unit_name": "stbIF6" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbIF7' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 9937, + "column": 1, + "source_line": "#define stbIF7( code ) code" + }, + "unit_kind": "macro", + "unit_name": "stbIF7" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbIF7' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 9939, + "column": 1, + "source_line": "#define stbIF7( code )" + }, + "unit_kind": "macro", + "unit_name": "stbIF7" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_chans' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 10282, + "column": 1, + "source_line": "#define STBIR_chans( start, end ) STBIR_strs_join1(start,STBIR__horizontal_channels,end)" + }, + "unit_kind": "macro", + "unit_name": "STBIR_chans" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__2_coeff_only' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 10285, + "column": 1, + "source_line": "#define stbir__2_coeff_only() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__2_coeff_only" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__2_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 10291, + "column": 1, + "source_line": "#define stbir__2_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__2_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__3_coeff_only' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 10297, + "column": 1, + "source_line": "#define stbir__3_coeff_only() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__3_coeff_only" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__3_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 10303, + "column": 1, + "source_line": "#define stbir__3_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__3_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__3_coeff_setup' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 10309, + "column": 1, + "source_line": "#define stbir__3_coeff_setup()" + }, + "unit_kind": "macro", + "unit_name": "stbir__3_coeff_setup" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__4_coeff_start' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 10313, + "column": 1, + "source_line": "#define stbir__4_coeff_start() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__4_coeff_start" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__4_coeff_continue_from_4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 10319, + "column": 1, + "source_line": "#define stbir__4_coeff_continue_from_4( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__4_coeff_continue_from_4" + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'stbir_uint64'.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 396, + "column": 1, + "source_line": "typedef unsigned __int64 stbir_uint64;" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 472, + "column": 1, + "source_line": "STBIRDEF unsigned char * stbir_resize_uint8_srgb( const unsigned char *input_pixels , int input_w , int input_h, int input_stride_in_bytes," + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 476, + "column": 1, + "source_line": "STBIRDEF unsigned char * stbir_resize_uint8_linear( const unsigned char *input_pixels , int input_w , int input_h, int input_stride_in_bytes," + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 480, + "column": 1, + "source_line": "STBIRDEF float * stbir_resize_float_linear( const float *input_pixels , int input_w , int input_h, int input_stride_in_bytes," + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 526, + "column": 1, + "source_line": "STBIRDEF void * stbir_resize( const void *input_pixels , int input_w , int input_h, int input_stride_in_bytes," + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 606, + "column": 1, + "source_line": "STBIRDEF void stbir_resize_init( STBIR_RESIZE * resize," + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 615, + "column": 1, + "source_line": "STBIRDEF void stbir_set_datatypes( STBIR_RESIZE * resize, stbir_datatype input_type, stbir_datatype output_type );" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 616, + "column": 1, + "source_line": "STBIRDEF void stbir_set_pixel_callbacks( STBIR_RESIZE * resize, stbir_input_callback * input_cb, stbir_output_callback * output_cb ); // no callbacks by default" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 617, + "column": 1, + "source_line": "STBIRDEF void stbir_set_user_data( STBIR_RESIZE * resize, void * user_data ); // pass back STBIR_RESIZE* by default" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 618, + "column": 1, + "source_line": "STBIRDEF void stbir_set_buffer_ptrs( STBIR_RESIZE * resize, const void * input_pixels, int input_stride_in_bytes, void * output_pixels, int output_stride_in_bytes );" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 627, + "column": 1, + "source_line": "STBIRDEF int stbir_set_pixel_layouts( STBIR_RESIZE * resize, stbir_pixel_layout input_pixel_layout, stbir_pixel_layout output_pixel_layout ); // sets new buffer layouts" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 628, + "column": 1, + "source_line": "STBIRDEF int stbir_set_edgemodes( STBIR_RESIZE * resize, stbir_edge horizontal_edge, stbir_edge vertical_edge ); // CLAMP by default" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 630, + "column": 1, + "source_line": "STBIRDEF int stbir_set_filters( STBIR_RESIZE * resize, stbir_filter horizontal_filter, stbir_filter vertical_filter ); // STBIR_DEFAULT_FILTER_UPSAMPLE/DOWNSAMPLE by default" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 631, + "column": 1, + "source_line": "STBIRDEF int stbir_set_filter_callbacks( STBIR_RESIZE * resize, stbir__kernel_callback * horizontal_filter, stbir__support_callback * horizontal_support, stbir__kernel_callback * vertical_filter, stbir__support_callback * vertical_support );" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 633, + "column": 1, + "source_line": "STBIRDEF int stbir_set_pixel_subrect( STBIR_RESIZE * resize, int subx, int suby, int subw, int subh ); // sets both sub-regions (full regions by default)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 634, + "column": 1, + "source_line": "STBIRDEF int stbir_set_input_subrect( STBIR_RESIZE * resize, double s0, double t0, double s1, double t1 ); // sets input sub-region (full region by default)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 635, + "column": 1, + "source_line": "STBIRDEF int stbir_set_output_pixel_subrect( STBIR_RESIZE * resize, int subx, int suby, int subw, int subh ); // sets output sub-region (full region by default)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 641, + "column": 1, + "source_line": "STBIRDEF int stbir_set_non_pm_alpha_speed_over_quality( STBIR_RESIZE * resize, int non_pma_alpha_speed_over_quality );" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 653, + "column": 1, + "source_line": "STBIRDEF int stbir_build_samplers( STBIR_RESIZE * resize );" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 656, + "column": 1, + "source_line": "STBIRDEF void stbir_free_samplers( STBIR_RESIZE * resize );" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 661, + "column": 1, + "source_line": "STBIRDEF int stbir_resize_extended( STBIR_RESIZE * resize );" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 676, + "column": 1, + "source_line": "STBIRDEF int stbir_build_samplers_with_splits( STBIR_RESIZE * resize, int try_splits );" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 689, + "column": 1, + "source_line": "STBIRDEF int stbir_resize_extended_split( STBIR_RESIZE * resize, int split_start, int split_count );" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 767, + "column": 1, + "source_line": "STBIRDEF void stbir_resize_build_profile_info( STBIR_PROFILE_INFO * out_info, STBIR_RESIZE const * resize );" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 770, + "column": 1, + "source_line": "STBIRDEF void stbir_resize_extended_profile_info( STBIR_PROFILE_INFO * out_info, STBIR_RESIZE const * resize );" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 773, + "column": 1, + "source_line": "STBIRDEF void stbir_resize_split_profile_info( STBIR_PROFILE_INFO * out_info, STBIR_RESIZE const * resize, int split_start, int split_num );" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 904, + "column": 1, + "source_line": "static unsigned char stbir__type_size[] = {" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_FIELD_DECLARATION", + "message": "Nested aggregate field definitions are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 977, + "column": 3, + "source_line": " union" + }, + "unit_kind": "struct_field", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_FIELD_DECLARATION", + "message": "Nested aggregate field definitions are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1013, + "column": 3, + "source_line": " union" + }, + "unit_kind": "struct_field", + "unit_name": null + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1077, + "column": 1, + "source_line": "static stbir__inline int stbir__min(int a, int b)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__inline" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1082, + "column": 1, + "source_line": "static stbir__inline int stbir__max(int a, int b)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__inline" + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1087, + "column": 1, + "source_line": "static float stbir__srgb_uchar_to_linear_float[256] = {" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1122, + "column": 1, + "source_line": "static const stbir_uint32 fp32_to_srgb8_tab4[104] = {" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1138, + "column": 1, + "source_line": "static stbir__inline stbir_uint8 stbir__linear_to_srgb_uchar(float in)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__inline" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__simdf'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1405, + "column": 3, + "source_line": " static const stbir__simdf STBIR_zeroones = { 0.0f,1.0f,0.0f,1.0f };" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__simdf" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__simdf'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1406, + "column": 3, + "source_line": " static const stbir__simdf STBIR_onezeros = { 1.0f,0.0f,1.0f,0.0f };" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__simdf" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR__SIMDI_CONST'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1481, + "column": 5, + "source_line": " static STBIR__SIMDI_CONST(stbir__s32_32768, 32768);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR__SIMDI_CONST" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR__SIMDI_CONST'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1482, + "column": 5, + "source_line": " static STBIR__SIMDI_CONST(stbir__s16_32768, ((32768<<16)|32768));" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR__SIMDI_CONST" + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1625, + "column": 5, + "source_line": " static __m256i stbir_00001111 = { STBIR__CONST_4d_32i( 0, 0, 0, 0 ), STBIR__CONST_4d_32i( 1, 1, 1, 1 ) };" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1628, + "column": 5, + "source_line": " static __m256i stbir_22223333 = { STBIR__CONST_4d_32i( 2, 2, 2, 2 ), STBIR__CONST_4d_32i( 3, 3, 3, 3 ) };" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1635, + "column": 5, + "source_line": " static __m256i stbir_00112233 = { STBIR__CONST_4d_32i( 0, 0, 1, 1 ), STBIR__CONST_4d_32i( 2, 2, 3, 3 ) };" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1639, + "column": 5, + "source_line": " static __m256i stbir_load6 = { STBIR__CONST_4_32i( 0x80000000 ), STBIR__CONST_4d_32i( 0x80000000, 0x80000000, 0, 0 ) };" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1679, + "column": 3, + "source_line": " static stbir__inline float stbir_simd_floorf(float x) // martins floorf" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__inline" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1696, + "column": 3, + "source_line": " static stbir__inline float stbir_simd_ceilf(float x) // martins ceilf" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__inline" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'stbir_make16x2'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1821, + "column": 7, + "source_line": " static stbir__inline uint8x16x2_t stbir_make16x2(float32x4_t rega,float32x4_t regb)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir_make16x2" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'stbir_make8x2'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1849, + "column": 7, + "source_line": " static stbir__inline uint8x8x2_t stbir_make8x2(float32x4_t reg)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir_make8x2" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1940, + "column": 3, + "source_line": " static stbir__inline float stbir_simd_floorf(float x)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__inline" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1958, + "column": 3, + "source_line": " static stbir__inline float stbir_simd_ceilf(float x)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__inline" + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Compiler-specific declaration attributes are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2120, + "column": 3, + "source_line": " typedef float stbir__f32x4 __attribute__((__vector_size__(16), __aligned__(16)));" + }, + "unit_kind": "attribute_declaration", + "unit_name": null + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2130, + "column": 3, + "source_line": " static stbir__inline float stbir_simd_floorf(float x)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__inline" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2139, + "column": 3, + "source_line": " static stbir__inline float stbir_simd_ceilf(float x)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__inline" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__simdf8'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2178, + "column": 3, + "source_line": " static const stbir__simdf8 STBIR_max_uint16_as_float_inverted8 = { stbir__max_uint16_as_float_inverted,stbir__max_uint16_as_float_inverted,stbir__max_uint16_as_float_inverted,stbir__max_uint16_as_float_inverted,stbir__max_uint16_as_float_inverted,stbir__max_uint16_as_float_inverted,stbir__max_uint16_as_float_inverted,stbir__max_uint16_as_float_inverted };" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__simdf8" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__simdf8'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2179, + "column": 3, + "source_line": " static const stbir__simdf8 STBIR_max_uint8_as_float_inverted8 = { stbir__max_uint8_as_float_inverted,stbir__max_uint8_as_float_inverted,stbir__max_uint8_as_float_inverted,stbir__max_uint8_as_float_inverted,stbir__max_uint8_as_float_inverted,stbir__max_uint8_as_float_inverted,stbir__max_uint8_as_float_inverted,stbir__max_uint8_as_float_inverted };" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__simdf8" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__simdf8'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2180, + "column": 3, + "source_line": " static const stbir__simdf8 STBIR_ones8 = { 1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0 };" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__simdf8" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__simdf8'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2181, + "column": 3, + "source_line": " static const stbir__simdf8 STBIR_simd_point58 = { 0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5 };" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__simdf8" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__simdf8'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2182, + "column": 3, + "source_line": " static const stbir__simdf8 STBIR_max_uint8_as_float8 = { stbir__max_uint8_as_float,stbir__max_uint8_as_float,stbir__max_uint8_as_float,stbir__max_uint8_as_float, stbir__max_uint8_as_float,stbir__max_uint8_as_float,stbir__max_uint8_as_float,stbir__max_uint8_as_float };" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__simdf8" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__simdf8'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2183, + "column": 3, + "source_line": " static const stbir__simdf8 STBIR_max_uint16_as_float8 = { stbir__max_uint16_as_float,stbir__max_uint16_as_float,stbir__max_uint16_as_float,stbir__max_uint16_as_float, stbir__max_uint16_as_float,stbir__max_uint16_as_float,stbir__max_uint16_as_float,stbir__max_uint16_as_float };" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__simdf8" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2237, + "column": 3, + "source_line": " static stbir__inline float stbir__half_to_float( stbir__FP16 h )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__inline" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2251, + "column": 3, + "source_line": " static stbir__inline stbir__FP16 stbir__float_to_half(float val)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__inline" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2301, + "column": 3, + "source_line": " static stbir__inline void stbir__half_to_float_SIMD(float * output, stbir__FP16 const * input)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__inline" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2306, + "column": 3, + "source_line": " static stbir__inline void stbir__float_to_half_SIMD(stbir__FP16 * output, float const * input)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__inline" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2311, + "column": 3, + "source_line": " static stbir__inline float stbir__half_to_float( stbir__FP16 h )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__inline" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2316, + "column": 3, + "source_line": " static stbir__inline stbir__FP16 stbir__float_to_half( float f )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__inline" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2326, + "column": 3, + "source_line": " stbir__inline static void stbir__half_to_float_SIMD(float * output, void const * input)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__inline" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2380, + "column": 3, + "source_line": " stbir__inline static void stbir__float_to_half_SIMD(void * output, float const * input)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__inline" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2462, + "column": 3, + "source_line": " static stbir__inline void stbir__half_to_float_SIMD(float * output, stbir__FP16 const * input)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__inline" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2470, + "column": 3, + "source_line": " static stbir__inline void stbir__float_to_half_SIMD(stbir__FP16 * output, float const * input)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__inline" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2478, + "column": 3, + "source_line": " static stbir__inline float stbir__half_to_float( stbir__FP16 h )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__inline" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2483, + "column": 3, + "source_line": " static stbir__inline stbir__FP16 stbir__float_to_half( float f )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__inline" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2490, + "column": 3, + "source_line": " static stbir__inline void stbir__half_to_float_SIMD(float * output, stbir__FP16 const * input)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__inline" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2497, + "column": 3, + "source_line": " static stbir__inline void stbir__float_to_half_SIMD(stbir__FP16 * output, float const * input)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__inline" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2504, + "column": 3, + "source_line": " static stbir__inline float stbir__half_to_float( stbir__FP16 h )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__inline" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2509, + "column": 3, + "source_line": " static stbir__inline stbir__FP16 stbir__float_to_half( float f )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__inline" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2516, + "column": 3, + "source_line": " static stbir__inline void stbir__half_to_float_SIMD(float * output, stbir__FP16 const * input)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__inline" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2523, + "column": 3, + "source_line": " static stbir__inline void stbir__float_to_half_SIMD(stbir__FP16 * output, float const * input)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__inline" + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2564, + "column": 1, + "source_line": "static const int STBIR_mask[9] = { 0,0,0,-1,-1,-1,0,0,0 };" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR__SIMDF_CONST'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2566, + "column": 1, + "source_line": "static const STBIR__SIMDF_CONST(STBIR_max_uint8_as_float, stbir__max_uint8_as_float);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR__SIMDF_CONST" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR__SIMDF_CONST'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2567, + "column": 1, + "source_line": "static const STBIR__SIMDF_CONST(STBIR_max_uint16_as_float, stbir__max_uint16_as_float);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR__SIMDF_CONST" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR__SIMDF_CONST'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2568, + "column": 1, + "source_line": "static const STBIR__SIMDF_CONST(STBIR_max_uint8_as_float_inverted, stbir__max_uint8_as_float_inverted);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR__SIMDF_CONST" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR__SIMDF_CONST'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2569, + "column": 1, + "source_line": "static const STBIR__SIMDF_CONST(STBIR_max_uint16_as_float_inverted, stbir__max_uint16_as_float_inverted);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR__SIMDF_CONST" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR__SIMDF_CONST'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2571, + "column": 1, + "source_line": "static const STBIR__SIMDF_CONST(STBIR_simd_point5, 0.5f);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR__SIMDF_CONST" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR__SIMDF_CONST'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2572, + "column": 1, + "source_line": "static const STBIR__SIMDF_CONST(STBIR_ones, 1.0f);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR__SIMDF_CONST" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR__SIMDI_CONST'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2573, + "column": 1, + "source_line": "static const STBIR__SIMDI_CONST(STBIR_almost_zero, (127 - 13) << 23);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR__SIMDI_CONST" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR__SIMDI_CONST'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2574, + "column": 1, + "source_line": "static const STBIR__SIMDI_CONST(STBIR_almost_one, 0x3f7fffff);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR__SIMDI_CONST" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR__SIMDI_CONST'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2575, + "column": 1, + "source_line": "static const STBIR__SIMDI_CONST(STBIR_mantissa_mask, 0xff);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR__SIMDI_CONST" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR__SIMDI_CONST'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2576, + "column": 1, + "source_line": "static const STBIR__SIMDI_CONST(STBIR_topscale, 0x02000000);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR__SIMDI_CONST" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2735, + "column": 3, + "source_line": " STBIRDEF stbir_uint64 __rdtsc();" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR_PROFILE_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2740, + "column": 3, + "source_line": " static stbir__inline stbir_uint64 STBIR_PROFILE_FUNC()" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR_PROFILE_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR_PROFILE_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2757, + "column": 3, + "source_line": " static stbir__inline stbir_uint64 STBIR_PROFILE_FUNC()" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR_PROFILE_FUNC" + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 3102, + "column": 1, + "source_line": "static stbir__edge_wrap_func * stbir__edge_wrap_slow[] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 3110, + "column": 1, + "source_line": "stbir__inline static int stbir__edge_wrap(stbir_edge edge, int n, int max)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__inline" + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'STBIR_ONLY_PROFILE_BUILD_GET_INFO'.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 3931, + "column": 1, + "source_line": "static void stbir__calculate_filters( stbir__sampler * samp, stbir__sampler * other_axis_for_pivot, void * user_data STBIR_ONLY_PROFILE_BUILD_GET_INFO )" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'STBIR_ONLY_PROFILE_GET_SPLIT_INFO'.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4610, + "column": 1, + "source_line": "static void stbir__decode_scanline(stbir__info const * stbir_info, int n, float * output_buffer STBIR_ONLY_PROFILE_GET_SPLIT_INFO )" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 6161, + "column": 1, + "source_line": "static STBIR_VERTICAL_GATHERFUNC * stbir__vertical_gathers[ 8 ] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 6166, + "column": 1, + "source_line": "static STBIR_VERTICAL_GATHERFUNC * stbir__vertical_gathers_continues[ 8 ] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 6173, + "column": 1, + "source_line": "static STBIR_VERTICAL_SCATTERFUNC * stbir__vertical_scatter_sets[ 8 ] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 6178, + "column": 1, + "source_line": "static STBIR_VERTICAL_SCATTERFUNC * stbir__vertical_scatter_blends[ 8 ] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'STBIR_ONLY_PROFILE_GET_SPLIT_INFO'.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 6184, + "column": 1, + "source_line": "static void stbir__encode_scanline( stbir__info const * stbir_info, void *output_buffer_data, float * encode_buffer, int row STBIR_ONLY_PROFILE_GET_SPLIT_INFO )" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'STBIR_ONLY_PROFILE_GET_SPLIT_INFO'.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 6236, + "column": 1, + "source_line": "static void stbir__resample_horizontal_gather(stbir__info const * stbir_info, float* output_buffer, float const * input_buffer STBIR_ONLY_PROFILE_GET_SPLIT_INFO )" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 6570, + "column": 1, + "source_line": "static stbir__kernel_callback * stbir__builtin_kernels[] = { 0, stbir__filter_trapezoid, stbir__filter_triangle, stbir__filter_cubic, stbir__filter_catmullrom, stbir__filter_mitchell, stbir__filter_point };" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 6571, + "column": 1, + "source_line": "static stbir__support_callback * stbir__builtin_supports[] = { 0, stbir__support_trapezoid, stbir__support_one, stbir__support_two, stbir__support_two, stbir__support_two, stbir__support_zeropoint5 };" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 6883, + "column": 1, + "source_line": "static stbir__horizontal_gather_channels_func ** stbir__horizontal_gather_n_coeffs_funcs[8] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 6888, + "column": 1, + "source_line": "static stbir__horizontal_gather_channels_func ** stbir__horizontal_gather_channels_funcs[8] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 6896, + "column": 1, + "source_line": "static float stbir__compute_weights[5][STBIR_RESIZE_CLASSIFICATIONS][4]= // 5 = 0=1chan, 1=2chan, 2=3chan, 3=4chan, 4=7chan" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 6957, + "column": 1, + "source_line": "static STBIR__V_FIRST_INFO STBIR__V_FIRST_INFO_BUFFER = {0};" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 7034, + "column": 1, + "source_line": "static unsigned char stbir__pixel_channels[] = {" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 7042, + "column": 1, + "source_line": "static stbir_internal_pixel_layout stbir__pixel_layout_convert_public_to_internal[] = {" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'STBIR_ONLY_PROFILE_BUILD_GET_INFO'.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 7048, + "column": 1, + "source_line": "static stbir__info * stbir__alloc_internal_mem_and_build_samplers( stbir__sampler * horizontal, stbir__sampler * vertical, stbir__contributors * conservative, stbir_pixel_layout input_pixel_layout_public, stbir_pixel_layout output_pixel_layout_public, int splits, int new_x, int new_y, int fast_alpha, void * user_data STBIR_ONLY_PROFILE_BUILD_GET_INFO )" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 7720, + "column": 1, + "source_line": "STBIRDEF void stbir_resize_init( STBIR_RESIZE * resize," + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 7739, + "column": 1, + "source_line": "STBIRDEF void stbir_set_datatypes( STBIR_RESIZE * resize, stbir_datatype input_type, stbir_datatype output_type ) // by default, datatype from resize_init" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 7747, + "column": 1, + "source_line": "STBIRDEF void stbir_set_pixel_callbacks( STBIR_RESIZE * resize, stbir_input_callback * input_cb, stbir_output_callback * output_cb ) // no callbacks by default" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 7759, + "column": 1, + "source_line": "STBIRDEF void stbir_set_user_data( STBIR_RESIZE * resize, void * user_data ) // pass back STBIR_RESIZE* by default" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 7766, + "column": 1, + "source_line": "STBIRDEF void stbir_set_buffer_ptrs( STBIR_RESIZE * resize, const void * input_pixels, int input_stride_in_bytes, void * output_pixels, int output_stride_in_bytes )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 7777, + "column": 1, + "source_line": "STBIRDEF int stbir_set_edgemodes( STBIR_RESIZE * resize, stbir_edge horizontal_edge, stbir_edge vertical_edge ) // CLAMP by default" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 7785, + "column": 1, + "source_line": "STBIRDEF int stbir_set_filters( STBIR_RESIZE * resize, stbir_filter horizontal_filter, stbir_filter vertical_filter ) // STBIR_DEFAULT_FILTER_UPSAMPLE/DOWNSAMPLE by default" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 7793, + "column": 1, + "source_line": "STBIRDEF int stbir_set_filter_callbacks( STBIR_RESIZE * resize, stbir__kernel_callback * horizontal_filter, stbir__support_callback * horizontal_support, stbir__kernel_callback * vertical_filter, stbir__support_callback * vertical_support )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 7801, + "column": 1, + "source_line": "STBIRDEF int stbir_set_pixel_layouts( STBIR_RESIZE * resize, stbir_pixel_layout input_pixel_layout, stbir_pixel_layout output_pixel_layout ) // sets new pixel layouts" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 7810, + "column": 1, + "source_line": "STBIRDEF int stbir_set_non_pm_alpha_speed_over_quality( STBIR_RESIZE * resize, int non_pma_alpha_speed_over_quality ) // sets alpha speed" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 7817, + "column": 1, + "source_line": "STBIRDEF int stbir_set_input_subrect( STBIR_RESIZE * resize, double s0, double t0, double s1, double t1 ) // sets input region (full region by default)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 7835, + "column": 1, + "source_line": "STBIRDEF int stbir_set_output_pixel_subrect( STBIR_RESIZE * resize, int subx, int suby, int subw, int subh ) // sets input region (full region by default)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 7850, + "column": 1, + "source_line": "STBIRDEF int stbir_set_pixel_subrect( STBIR_RESIZE * resize, int subx, int suby, int subw, int subh ) // sets both regions (full regions by default)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 7949, + "column": 1, + "source_line": "STBIRDEF void stbir_free_samplers( STBIR_RESIZE * resize )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 7959, + "column": 1, + "source_line": "STBIRDEF int stbir_build_samplers_with_splits( STBIR_RESIZE * resize, int splits )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 7975, + "column": 1, + "source_line": "STBIRDEF int stbir_build_samplers( STBIR_RESIZE * resize )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 7980, + "column": 1, + "source_line": "STBIRDEF int stbir_resize_extended( STBIR_RESIZE * resize )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8024, + "column": 1, + "source_line": "STBIRDEF int stbir_resize_extended_split( STBIR_RESIZE * resize, int split_start, int split_count )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8120, + "column": 1, + "source_line": "STBIRDEF unsigned char * stbir_resize_uint8_linear( const unsigned char *input_pixels , int input_w , int input_h, int input_stride_in_bytes," + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8129, + "column": 1, + "source_line": "STBIRDEF unsigned char * stbir_resize_uint8_srgb( const unsigned char *input_pixels , int input_w , int input_h, int input_stride_in_bytes," + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8139, + "column": 1, + "source_line": "STBIRDEF float * stbir_resize_float_linear( const float *input_pixels , int input_w , int input_h, int input_stride_in_bytes," + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8149, + "column": 1, + "source_line": "STBIRDEF void * stbir_resize( const void *input_pixels , int input_w , int input_h, int input_stride_in_bytes," + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8161, + "column": 1, + "source_line": "STBIRDEF void stbir_resize_build_profile_info( STBIR_PROFILE_INFO * info, STBIR_RESIZE const * resize )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8179, + "column": 1, + "source_line": "STBIRDEF void stbir_resize_split_profile_info( STBIR_PROFILE_INFO * info, STBIR_RESIZE const * resize, int split_start, int split_count )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8219, + "column": 1, + "source_line": "STBIRDEF void stbir_resize_extended_profile_info( STBIR_PROFILE_INFO * info, STBIR_RESIZE const * resize )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR__CODER_NAME'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8293, + "column": 1, + "source_line": "static float * STBIR__CODER_NAME( stbir__decode_uint8_linear_scaled )( float * decodep, int width_times_channels, void const * inputp )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR__CODER_NAME" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR__CODER_NAME'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8395, + "column": 1, + "source_line": "static void STBIR__CODER_NAME( stbir__encode_uint8_linear_scaled )( void * outputp, int width_times_channels, float const * encode )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR__CODER_NAME" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR__CODER_NAME'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8512, + "column": 1, + "source_line": "static float * STBIR__CODER_NAME(stbir__decode_uint8_linear)( float * decodep, int width_times_channels, void const * inputp )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR__CODER_NAME" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR__CODER_NAME'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8607, + "column": 1, + "source_line": "static void STBIR__CODER_NAME( stbir__encode_uint8_linear )( void * outputp, int width_times_channels, float const * encode )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR__CODER_NAME" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR__CODER_NAME'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8706, + "column": 1, + "source_line": "static float * STBIR__CODER_NAME(stbir__decode_uint8_srgb)( float * decodep, int width_times_channels, void const * inputp )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR__CODER_NAME" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR__CODER_NAME'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8810, + "column": 1, + "source_line": "static void STBIR__CODER_NAME( stbir__encode_uint8_srgb )( void * outputp, int width_times_channels, float const * encode )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR__CODER_NAME" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR__CODER_NAME'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8897, + "column": 1, + "source_line": "static float * STBIR__CODER_NAME(stbir__decode_uint8_srgb4_linearalpha)( float * decodep, int width_times_channels, void const * inputp )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR__CODER_NAME" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR__CODER_NAME'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8915, + "column": 1, + "source_line": "static void STBIR__CODER_NAME( stbir__encode_uint8_srgb4_linearalpha )( void * outputp, int width_times_channels, float const * encode )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR__CODER_NAME" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR__CODER_NAME'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8984, + "column": 1, + "source_line": "static float * STBIR__CODER_NAME(stbir__decode_uint8_srgb2_linearalpha)( float * decodep, int width_times_channels, void const * inputp )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR__CODER_NAME" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR__CODER_NAME'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 9009, + "column": 1, + "source_line": "static void STBIR__CODER_NAME( stbir__encode_uint8_srgb2_linearalpha )( void * outputp, int width_times_channels, float const * encode )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR__CODER_NAME" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR__CODER_NAME'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 9072, + "column": 1, + "source_line": "static float * STBIR__CODER_NAME(stbir__decode_uint16_linear_scaled)( float * decodep, int width_times_channels, void const * inputp )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR__CODER_NAME" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR__CODER_NAME'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 9162, + "column": 1, + "source_line": "static void STBIR__CODER_NAME(stbir__encode_uint16_linear_scaled)( void * outputp, int width_times_channels, float const * encode )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR__CODER_NAME" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR__CODER_NAME'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 9278, + "column": 1, + "source_line": "static float * STBIR__CODER_NAME(stbir__decode_uint16_linear)( float * decodep, int width_times_channels, void const * inputp )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR__CODER_NAME" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR__CODER_NAME'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 9364, + "column": 1, + "source_line": "static void STBIR__CODER_NAME(stbir__encode_uint16_linear)( void * outputp, int width_times_channels, float const * encode )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR__CODER_NAME" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR__CODER_NAME'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 9462, + "column": 1, + "source_line": "static float * STBIR__CODER_NAME(stbir__decode_half_float_linear)( float * decodep, int width_times_channels, void const * inputp )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR__CODER_NAME" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR__CODER_NAME'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 9549, + "column": 1, + "source_line": "static void STBIR__CODER_NAME( stbir__encode_half_float_linear )( void * outputp, int width_times_channels, float const * encode )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR__CODER_NAME" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR__CODER_NAME'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 9633, + "column": 1, + "source_line": "static float * STBIR__CODER_NAME(stbir__decode_float_linear)( float * decodep, int width_times_channels, void const * inputp )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR__CODER_NAME" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR__CODER_NAME'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 9737, + "column": 1, + "source_line": "static void STBIR__CODER_NAME( stbir__encode_float_linear )( void * outputp, int width_times_channels, float const * encode )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR__CODER_NAME" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR_chans'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 9942, + "column": 1, + "source_line": "static void STBIR_chans( stbir__vertical_scatter_with_,_coeffs)( float ** outputs, float const * vertical_coefficients, float const * input, float const * input_end )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR_chans" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR_chans'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 10114, + "column": 1, + "source_line": "static void STBIR_chans( stbir__vertical_gather_with_,_coeffs)( float * outputp, float const * vertical_coefficients, float const ** inputs, float const * input0_end )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR_chans" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR_chans'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 10328, + "column": 1, + "source_line": "static void STBIR_chans( stbir__horizontal_gather_,_channels_with_1_coeff)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR_chans" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR_chans'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 10341, + "column": 1, + "source_line": "static void STBIR_chans( stbir__horizontal_gather_,_channels_with_2_coeffs)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR_chans" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR_chans'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 10354, + "column": 1, + "source_line": "static void STBIR_chans( stbir__horizontal_gather_,_channels_with_3_coeffs)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR_chans" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR_chans'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 10367, + "column": 1, + "source_line": "static void STBIR_chans( stbir__horizontal_gather_,_channels_with_4_coeffs)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR_chans" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR_chans'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 10380, + "column": 1, + "source_line": "static void STBIR_chans( stbir__horizontal_gather_,_channels_with_5_coeffs)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR_chans" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR_chans'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 10394, + "column": 1, + "source_line": "static void STBIR_chans( stbir__horizontal_gather_,_channels_with_6_coeffs)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR_chans" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR_chans'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 10408, + "column": 1, + "source_line": "static void STBIR_chans( stbir__horizontal_gather_,_channels_with_7_coeffs)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR_chans" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR_chans'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 10424, + "column": 1, + "source_line": "static void STBIR_chans( stbir__horizontal_gather_,_channels_with_8_coeffs)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR_chans" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR_chans'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 10438, + "column": 1, + "source_line": "static void STBIR_chans( stbir__horizontal_gather_,_channels_with_9_coeffs)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR_chans" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR_chans'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 10453, + "column": 1, + "source_line": "static void STBIR_chans( stbir__horizontal_gather_,_channels_with_10_coeffs)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR_chans" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR_chans'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 10468, + "column": 1, + "source_line": "static void STBIR_chans( stbir__horizontal_gather_,_channels_with_11_coeffs)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR_chans" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR_chans'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 10484, + "column": 1, + "source_line": "static void STBIR_chans( stbir__horizontal_gather_,_channels_with_12_coeffs)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR_chans" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR_chans'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 10499, + "column": 1, + "source_line": "static void STBIR_chans( stbir__horizontal_gather_,_channels_with_n_coeffs_mod0 )( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR_chans" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR_chans'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 10521, + "column": 1, + "source_line": "static void STBIR_chans( stbir__horizontal_gather_,_channels_with_n_coeffs_mod1 )( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR_chans" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR_chans'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 10544, + "column": 1, + "source_line": "static void STBIR_chans( stbir__horizontal_gather_,_channels_with_n_coeffs_mod2 )( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR_chans" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR_chans'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 10568, + "column": 1, + "source_line": "static void STBIR_chans( stbir__horizontal_gather_,_channels_with_n_coeffs_mod3 )( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR_chans" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR_chans'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 10593, + "column": 1, + "source_line": "static stbir__horizontal_gather_channels_func * STBIR_chans(stbir__horizontal_gather_,_channels_with_n_coeffs_funcs)[4]=" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR_chans" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR_chans'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 10601, + "column": 1, + "source_line": "static stbir__horizontal_gather_channels_func * STBIR_chans(stbir__horizontal_gather_,_channels_funcs)[12]=" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR_chans" + }, + { + "code": "C_CONFLICTING_TYPEDEF", + "message": "Conflicting typedef declarations for 'stbir_uint8'.", + "severity": "error", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 399, + "column": 1, + "source_line": "typedef uint8_t stbir_uint8;" + }, + "unit_kind": "typedef", + "unit_name": "stbir_uint8" + }, + { + "code": "C_CONFLICTING_TYPEDEF", + "message": "Conflicting typedef declarations for 'stbir_uint16'.", + "severity": "error", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 400, + "column": 1, + "source_line": "typedef uint16_t stbir_uint16;" + }, + "unit_kind": "typedef", + "unit_name": "stbir_uint16" + }, + { + "code": "C_CONFLICTING_TYPEDEF", + "message": "Conflicting typedef declarations for 'stbir_uint32'.", + "severity": "error", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 401, + "column": 1, + "source_line": "typedef uint32_t stbir_uint32;" + }, + "unit_kind": "typedef", + "unit_name": "stbir_uint32" + }, + { + "code": "C_CONFLICTING_TYPEDEF", + "message": "Conflicting typedef declarations for 'stbir__FP16'.", + "severity": "error", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2221, + "column": 3, + "source_line": " typedef float16_t stbir__FP16;" + }, + "unit_kind": "typedef", + "unit_name": "stbir__FP16" + }, + { + "code": "C_CONFLICTING_TYPEDEF", + "message": "Conflicting typedef declarations for 'stbir__FP16'.", + "severity": "error", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2226, + "column": 3, + "source_line": " typedef union stbir__FP16" + }, + "unit_kind": "typedef", + "unit_name": "stbir__FP16" + }, + { + "code": "C_DUPLICATE_FUNCTION_DEFINITION", + "message": "Duplicate definition for function 'stbir_overlapping_memcpy'.", + "severity": "error", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2840, + "column": 1, + "source_line": "static void stbir_overlapping_memcpy( void * dest, void const * src, size_t bytes )" + }, + "unit_kind": "function", + "unit_name": "stbir_overlapping_memcpy" + } + ] + } + }, + "functions": { + "stbir_simd_memcpy": { + "name": "stbir_simd_memcpy", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "dest", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * dest", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * dest", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "src", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void const * src", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [ + "const" + ], + "source_text": "const void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void const * src", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [ + "const" + ], + "source_text": "const void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "bytes", + "type": { + "reference": "size_t" + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2592, + "column": 1, + "source_line": "static void stbir_simd_memcpy( void * dest, void const * src, size_t bytes )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 2592, + "column": 1, + "source_line": "static void stbir_simd_memcpy( void * dest, void const * src, size_t bytes )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 2680, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbir_overlapping_memcpy": { + "name": "stbir_overlapping_memcpy", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "dest", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * dest", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * dest", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "src", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void const * src", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [ + "const" + ], + "source_text": "const void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void const * src", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [ + "const" + ], + "source_text": "const void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "bytes", + "type": { + "reference": "size_t" + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2685, + "column": 1, + "source_line": "static void stbir_overlapping_memcpy( void * dest, void const * src, size_t bytes )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 2685, + "column": 1, + "source_line": "static void stbir_overlapping_memcpy( void * dest, void const * src, size_t bytes )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 2714, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbir__filter_trapezoid": { + "name": "stbir__filter_trapezoid", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "scale", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float scale" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float scale" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "user_data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2890, + "column": 1, + "source_line": "static float stbir__filter_trapezoid(float x, float scale, void * user_data)" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 2890, + "column": 1, + "source_line": "static float stbir__filter_trapezoid(float x, float scale, void * user_data)" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 2909, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbir__support_trapezoid": { + "name": "stbir__support_trapezoid", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "scale", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float scale" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float scale" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "user_data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2911, + "column": 1, + "source_line": "static float stbir__support_trapezoid(float scale, void * user_data)" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 2911, + "column": 1, + "source_line": "static float stbir__support_trapezoid(float scale, void * user_data)" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 2915, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbir__filter_triangle": { + "name": "stbir__filter_triangle", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "s", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float s" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float s" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "user_data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2917, + "column": 1, + "source_line": "static float stbir__filter_triangle(float x, float s, void * user_data)" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 2917, + "column": 1, + "source_line": "static float stbir__filter_triangle(float x, float s, void * user_data)" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 2928, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbir__filter_point": { + "name": "stbir__filter_point", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "s", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float s" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float s" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "user_data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2930, + "column": 1, + "source_line": "static float stbir__filter_point(float x, float s, void * user_data)" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 2930, + "column": 1, + "source_line": "static float stbir__filter_point(float x, float s, void * user_data)" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 2937, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbir__filter_cubic": { + "name": "stbir__filter_cubic", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "s", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float s" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float s" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "user_data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2939, + "column": 1, + "source_line": "static float stbir__filter_cubic(float x, float s, void * user_data)" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 2939, + "column": 1, + "source_line": "static float stbir__filter_cubic(float x, float s, void * user_data)" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 2952, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbir__filter_catmullrom": { + "name": "stbir__filter_catmullrom", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "s", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float s" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float s" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "user_data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2954, + "column": 1, + "source_line": "static float stbir__filter_catmullrom(float x, float s, void * user_data)" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 2954, + "column": 1, + "source_line": "static float stbir__filter_catmullrom(float x, float s, void * user_data)" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 2967, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbir__filter_mitchell": { + "name": "stbir__filter_mitchell", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "s", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float s" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float s" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "user_data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2969, + "column": 1, + "source_line": "static float stbir__filter_mitchell(float x, float s, void * user_data)" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 2969, + "column": 1, + "source_line": "static float stbir__filter_mitchell(float x, float s, void * user_data)" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 2982, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbir__support_zeropoint5": { + "name": "stbir__support_zeropoint5", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float s" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float s" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "user_data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2984, + "column": 1, + "source_line": "static float stbir__support_zeropoint5(float s, void * user_data)" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 2984, + "column": 1, + "source_line": "static float stbir__support_zeropoint5(float s, void * user_data)" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 2989, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbir__support_one": { + "name": "stbir__support_one", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float s" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float s" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "user_data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2991, + "column": 1, + "source_line": "static float stbir__support_one(float s, void * user_data)" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 2991, + "column": 1, + "source_line": "static float stbir__support_one(float s, void * user_data)" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 2996, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbir__support_two": { + "name": "stbir__support_two", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float s" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float s" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "user_data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2998, + "column": 1, + "source_line": "static float stbir__support_two(float s, void * user_data)" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 2998, + "column": 1, + "source_line": "static float stbir__support_two(float s, void * user_data)" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 3003, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbir__get_filter_pixel_width": { + "name": "stbir__get_filter_pixel_width", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "support", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__support_callback * support", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__support_callback" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__support_callback * support", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__support_callback" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "scale", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float scale" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float scale" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "user_data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 3007, + "column": 1, + "source_line": "static int stbir__get_filter_pixel_width(stbir__support_callback * support, float scale, void * user_data)" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 3007, + "column": 1, + "source_line": "static int stbir__get_filter_pixel_width(stbir__support_callback * support, float scale, void * user_data)" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 3015, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbir__get_coefficient_width": { + "name": "stbir__get_coefficient_width", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "samp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__sampler * samp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__sampler" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__sampler * samp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__sampler" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "is_gather", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int is_gather" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int is_gather" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "user_data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 3019, + "column": 1, + "source_line": "static int stbir__get_coefficient_width(stbir__sampler * samp, int is_gather, void * user_data)" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 3019, + "column": 1, + "source_line": "static int stbir__get_coefficient_width(stbir__sampler * samp, int is_gather, void * user_data)" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 3036, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbir__get_contributors": { + "name": "stbir__get_contributors", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "samp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__sampler * samp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__sampler" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__sampler * samp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__sampler" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "is_gather", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int is_gather" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int is_gather" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 3038, + "column": 1, + "source_line": "static int stbir__get_contributors(stbir__sampler * samp, int is_gather)" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 3038, + "column": 1, + "source_line": "static int stbir__get_contributors(stbir__sampler * samp, int is_gather)" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 3044, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbir__edge_zero_full": { + "name": "stbir__edge_zero_full", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "max", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int max" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int max" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 3046, + "column": 1, + "source_line": "static int stbir__edge_zero_full( int n, int max )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 3046, + "column": 1, + "source_line": "static int stbir__edge_zero_full( int n, int max )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 3051, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbir__edge_clamp_full": { + "name": "stbir__edge_clamp_full", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "max", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int max" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int max" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 3053, + "column": 1, + "source_line": "static int stbir__edge_clamp_full( int n, int max )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 3053, + "column": 1, + "source_line": "static int stbir__edge_clamp_full( int n, int max )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 3062, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbir__edge_reflect_full": { + "name": "stbir__edge_reflect_full", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "max", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int max" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int max" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 3064, + "column": 1, + "source_line": "static int stbir__edge_reflect_full( int n, int max )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 3064, + "column": 1, + "source_line": "static int stbir__edge_reflect_full( int n, int max )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 3084, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbir__edge_wrap_full": { + "name": "stbir__edge_wrap_full", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "max", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int max" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int max" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 3086, + "column": 1, + "source_line": "static int stbir__edge_wrap_full( int n, int max )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 3086, + "column": 1, + "source_line": "static int stbir__edge_wrap_full( int n, int max )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 3099, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbir__get_extents": { + "name": "stbir__get_extents", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "samp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__sampler * samp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__sampler" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__sampler * samp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__sampler" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "scanline_extents", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__extents * scanline_extents", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__extents" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__extents * scanline_extents", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__extents" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 3121, + "column": 1, + "source_line": "static void stbir__get_extents( stbir__sampler * samp, stbir__extents * scanline_extents )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 3121, + "column": 1, + "source_line": "static void stbir__get_extents( stbir__sampler * samp, stbir__extents * scanline_extents )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 3291, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbir__calculate_in_pixel_range": { + "name": "stbir__calculate_in_pixel_range", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "first_pixel", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int * first_pixel", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int * first_pixel", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "last_pixel", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int * last_pixel", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int * last_pixel", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "out_pixel_center", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float out_pixel_center" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float out_pixel_center" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "out_filter_radius", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float out_filter_radius" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float out_filter_radius" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "inv_scale", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float inv_scale" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float inv_scale" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "out_shift", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float out_shift" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float out_shift" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "input_size", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int input_size" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int input_size" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "edge", + "type": { + "reference": "stbir_edge" + }, + "declared_type": { + "reference": "stbir_edge" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 3293, + "column": 1, + "source_line": "static void stbir__calculate_in_pixel_range( int * first_pixel, int * last_pixel, float out_pixel_center, float out_filter_radius, float inv_scale, float out_shift, int input_size, stbir_edge edge )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 3293, + "column": 1, + "source_line": "static void stbir__calculate_in_pixel_range( int * first_pixel, int * last_pixel, float out_pixel_center, float out_filter_radius, float inv_scale, float out_shift, int input_size, stbir_edge edge )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 3316, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbir__calculate_coefficients_for_gather_upsample": { + "name": "stbir__calculate_coefficients_for_gather_upsample", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "out_filter_radius", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float out_filter_radius" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float out_filter_radius" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "kernel", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__kernel_callback * kernel", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__kernel_callback" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__kernel_callback * kernel", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__kernel_callback" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "scale_info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__scale_info * scale_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__scale_info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__scale_info * scale_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__scale_info" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "num_contributors", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_contributors" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_contributors" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "contributors", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__contributors * contributors", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__contributors" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__contributors * contributors", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__contributors" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "coefficient_group", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * coefficient_group", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * coefficient_group", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "coefficient_width", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int coefficient_width" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int coefficient_width" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "edge", + "type": { + "reference": "stbir_edge" + }, + "declared_type": { + "reference": "stbir_edge" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "user_data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 3318, + "column": 1, + "source_line": "static void stbir__calculate_coefficients_for_gather_upsample( float out_filter_radius, stbir__kernel_callback * kernel, stbir__scale_info * scale_info, int num_contributors, stbir__contributors* contributors, float* coefficient_group, int coefficient_width, stbir_edge edge, void * user_data )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 3318, + "column": 1, + "source_line": "static void stbir__calculate_coefficients_for_gather_upsample( float out_filter_radius, stbir__kernel_callback * kernel, stbir__scale_info * scale_info, int num_contributors, stbir__contributors* contributors, float* coefficient_group, int coefficient_width, stbir_edge edge, void * user_data )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 3378, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbir__insert_coeff": { + "name": "stbir__insert_coeff", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "contribs", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__contributors * contribs", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__contributors" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__contributors * contribs", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__contributors" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "coeffs", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * coeffs", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * coeffs", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "new_pixel", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int new_pixel" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int new_pixel" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "new_coeff", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float new_coeff" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float new_coeff" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "max_width", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int max_width" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int max_width" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 3380, + "column": 1, + "source_line": "static void stbir__insert_coeff( stbir__contributors * contribs, float * coeffs, int new_pixel, float new_coeff, int max_width )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 3380, + "column": 1, + "source_line": "static void stbir__insert_coeff( stbir__contributors * contribs, float * coeffs, int new_pixel, float new_coeff, int max_width )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 3420, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbir__calculate_out_pixel_range": { + "name": "stbir__calculate_out_pixel_range", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "first_pixel", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int * first_pixel", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int * first_pixel", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "last_pixel", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int * last_pixel", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int * last_pixel", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "in_pixel_center", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float in_pixel_center" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float in_pixel_center" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "in_pixels_radius", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float in_pixels_radius" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float in_pixels_radius" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "scale", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float scale" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float scale" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "out_shift", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float out_shift" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float out_shift" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "out_size", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int out_size" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int out_size" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 3422, + "column": 1, + "source_line": "static void stbir__calculate_out_pixel_range( int * first_pixel, int * last_pixel, float in_pixel_center, float in_pixels_radius, float scale, float out_shift, int out_size )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 3422, + "column": 1, + "source_line": "static void stbir__calculate_out_pixel_range( int * first_pixel, int * last_pixel, float in_pixel_center, float in_pixels_radius, float scale, float out_shift, int out_size )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 3437, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbir__calculate_coefficients_for_gather_downsample": { + "name": "stbir__calculate_coefficients_for_gather_downsample", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "start", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int start" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int start" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "end", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int end" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int end" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "in_pixels_radius", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float in_pixels_radius" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float in_pixels_radius" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "kernel", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__kernel_callback * kernel", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__kernel_callback" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__kernel_callback * kernel", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__kernel_callback" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "scale_info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__scale_info * scale_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__scale_info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__scale_info * scale_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__scale_info" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "coefficient_width", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int coefficient_width" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int coefficient_width" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "num_contributors", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_contributors" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_contributors" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "contributors", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__contributors * contributors", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__contributors" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__contributors * contributors", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__contributors" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "coefficient_group", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * coefficient_group", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * coefficient_group", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "user_data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 3439, + "column": 1, + "source_line": "static void stbir__calculate_coefficients_for_gather_downsample( int start, int end, float in_pixels_radius, stbir__kernel_callback * kernel, stbir__scale_info * scale_info, int coefficient_width, int num_contributors, stbir__contributors * contributors, float * coefficient_group, void * user_data )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 3439, + "column": 1, + "source_line": "static void stbir__calculate_coefficients_for_gather_downsample( int start, int end, float in_pixels_radius, stbir__kernel_callback * kernel, stbir__scale_info * scale_info, int coefficient_width, int num_contributors, stbir__contributors * contributors, float * coefficient_group, void * user_data )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 3515, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbir__cleanup_gathered_coefficients": { + "name": "stbir__cleanup_gathered_coefficients", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "edge", + "type": { + "reference": "stbir_edge" + }, + "declared_type": { + "reference": "stbir_edge" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "filter_info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__filter_extent_info * filter_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__filter_extent_info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__filter_extent_info * filter_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__filter_extent_info" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "scale_info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__scale_info * scale_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__scale_info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__scale_info * scale_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__scale_info" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "num_contributors", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_contributors" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_contributors" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "contributors", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__contributors * contributors", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__contributors" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__contributors * contributors", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__contributors" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "coefficient_group", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * coefficient_group", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * coefficient_group", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "coefficient_width", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int coefficient_width" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int coefficient_width" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 3523, + "column": 1, + "source_line": "static void stbir__cleanup_gathered_coefficients( stbir_edge edge, stbir__filter_extent_info* filter_info, stbir__scale_info * scale_info, int num_contributors, stbir__contributors* contributors, float * coefficient_group, int coefficient_width )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 3523, + "column": 1, + "source_line": "static void stbir__cleanup_gathered_coefficients( stbir_edge edge, stbir__filter_extent_info* filter_info, stbir__scale_info * scale_info, int num_contributors, stbir__contributors* contributors, float * coefficient_group, int coefficient_width )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 3692, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbir__pack_coefficients": { + "name": "stbir__pack_coefficients", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "num_contributors", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_contributors" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_contributors" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "contributors", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__contributors * contributors", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__contributors" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__contributors * contributors", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__contributors" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "coefficents", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * coefficents", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * coefficents", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "coefficient_width", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int coefficient_width" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int coefficient_width" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "widest", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int widest" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int widest" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "row0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int row0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int row0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "row1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int row1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int row1" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 3696, + "column": 1, + "source_line": "static int stbir__pack_coefficients( int num_contributors, stbir__contributors* contributors, float * coefficents, int coefficient_width, int widest, int row0, int row1 ) " + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 3696, + "column": 1, + "source_line": "static int stbir__pack_coefficients( int num_contributors, stbir__contributors* contributors, float * coefficents, int coefficient_width, int widest, int row0, int row1 ) " + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 3929, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbir__fancy_alpha_weight_4ch": { + "name": "stbir__fancy_alpha_weight_4ch", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "out_buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * out_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * out_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "width_times_channels", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width_times_channels" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width_times_channels" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4138, + "column": 1, + "source_line": "static void stbir__fancy_alpha_weight_4ch( float * out_buffer, int width_times_channels )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 4138, + "column": 1, + "source_line": "static void stbir__fancy_alpha_weight_4ch( float * out_buffer, int width_times_channels )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 4232, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbir__fancy_alpha_weight_2ch": { + "name": "stbir__fancy_alpha_weight_2ch", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "out_buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * out_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * out_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "width_times_channels", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width_times_channels" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width_times_channels" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4234, + "column": 1, + "source_line": "static void stbir__fancy_alpha_weight_2ch( float * out_buffer, int width_times_channels )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 4234, + "column": 1, + "source_line": "static void stbir__fancy_alpha_weight_2ch( float * out_buffer, int width_times_channels )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 4302, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbir__fancy_alpha_unweight_4ch": { + "name": "stbir__fancy_alpha_unweight_4ch", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "encode_buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * encode_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * encode_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "width_times_channels", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width_times_channels" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width_times_channels" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4304, + "column": 1, + "source_line": "static void stbir__fancy_alpha_unweight_4ch( float * encode_buffer, int width_times_channels )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 4304, + "column": 1, + "source_line": "static void stbir__fancy_alpha_unweight_4ch( float * encode_buffer, int width_times_channels )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 4351, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbir__fancy_alpha_unweight_2ch": { + "name": "stbir__fancy_alpha_unweight_2ch", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "encode_buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * encode_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * encode_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "width_times_channels", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width_times_channels" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width_times_channels" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4354, + "column": 1, + "source_line": "static void stbir__fancy_alpha_unweight_2ch( float * encode_buffer, int width_times_channels )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 4354, + "column": 1, + "source_line": "static void stbir__fancy_alpha_unweight_2ch( float * encode_buffer, int width_times_channels )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 4370, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbir__simple_alpha_weight_4ch": { + "name": "stbir__simple_alpha_weight_4ch", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "decode_buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * decode_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * decode_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "width_times_channels", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width_times_channels" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width_times_channels" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4372, + "column": 1, + "source_line": "static void stbir__simple_alpha_weight_4ch( float * decode_buffer, int width_times_channels )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 4372, + "column": 1, + "source_line": "static void stbir__simple_alpha_weight_4ch( float * decode_buffer, int width_times_channels )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 4426, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbir__simple_alpha_weight_2ch": { + "name": "stbir__simple_alpha_weight_2ch", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "decode_buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * decode_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * decode_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "width_times_channels", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width_times_channels" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width_times_channels" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4428, + "column": 1, + "source_line": "static void stbir__simple_alpha_weight_2ch( float * decode_buffer, int width_times_channels )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 4428, + "column": 1, + "source_line": "static void stbir__simple_alpha_weight_2ch( float * decode_buffer, int width_times_channels )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 4461, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbir__simple_alpha_unweight_4ch": { + "name": "stbir__simple_alpha_unweight_4ch", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "encode_buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * encode_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * encode_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "width_times_channels", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width_times_channels" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width_times_channels" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4463, + "column": 1, + "source_line": "static void stbir__simple_alpha_unweight_4ch( float * encode_buffer, int width_times_channels )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 4463, + "column": 1, + "source_line": "static void stbir__simple_alpha_unweight_4ch( float * encode_buffer, int width_times_channels )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 4494, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbir__simple_alpha_unweight_2ch": { + "name": "stbir__simple_alpha_unweight_2ch", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "encode_buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * encode_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * encode_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "width_times_channels", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width_times_channels" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width_times_channels" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4496, + "column": 1, + "source_line": "static void stbir__simple_alpha_unweight_2ch( float * encode_buffer, int width_times_channels )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 4496, + "column": 1, + "source_line": "static void stbir__simple_alpha_unweight_2ch( float * encode_buffer, int width_times_channels )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 4507, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbir__simple_flip_3ch": { + "name": "stbir__simple_flip_3ch", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "decode_buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * decode_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * decode_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "width_times_channels", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width_times_channels" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width_times_channels" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 4511, + "column": 1, + "source_line": "static void stbir__simple_flip_3ch( float * decode_buffer, int width_times_channels )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 4511, + "column": 1, + "source_line": "static void stbir__simple_flip_3ch( float * decode_buffer, int width_times_channels )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 4606, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbir__get_ring_buffer_entry": { + "name": "stbir__get_ring_buffer_entry", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "parameters": [ + { + "name": "stbir_info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__info const * stbir_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__info const * stbir_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__info" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "split_info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__per_split_info const * split_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__per_split_info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__per_split_info const * split_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__per_split_info" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "index", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int index" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int index" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6218, + "column": 1, + "source_line": "static float* stbir__get_ring_buffer_entry(stbir__info const * stbir_info, stbir__per_split_info const * split_info, int index )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 6218, + "column": 1, + "source_line": "static float* stbir__get_ring_buffer_entry(stbir__info const * stbir_info, stbir__per_split_info const * split_info, int index )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 6227, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbir__get_ring_buffer_scanline": { + "name": "stbir__get_ring_buffer_scanline", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "parameters": [ + { + "name": "stbir_info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__info const * stbir_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__info const * stbir_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__info" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "split_info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__per_split_info const * split_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__per_split_info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__per_split_info const * split_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__per_split_info" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "get_scanline", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int get_scanline" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int get_scanline" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6230, + "column": 1, + "source_line": "static float* stbir__get_ring_buffer_scanline(stbir__info const * stbir_info, stbir__per_split_info const * split_info, int get_scanline)" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 6230, + "column": 1, + "source_line": "static float* stbir__get_ring_buffer_scanline(stbir__info const * stbir_info, stbir__per_split_info const * split_info, int get_scanline)" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 6234, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbir__resample_vertical_gather": { + "name": "stbir__resample_vertical_gather", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "stbir_info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__info const * stbir_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__info const * stbir_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__info" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "split_info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__per_split_info * split_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__per_split_info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__per_split_info * split_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__per_split_info" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "contrib_n0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int contrib_n0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int contrib_n0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "contrib_n1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int contrib_n1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int contrib_n1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "vertical_coefficients", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float const * vertical_coefficients", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [ + "const" + ], + "source_text": "const float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float const * vertical_coefficients", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [ + "const" + ], + "source_text": "const float" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6248, + "column": 1, + "source_line": "static void stbir__resample_vertical_gather(stbir__info const * stbir_info, stbir__per_split_info* split_info, int n, int contrib_n0, int contrib_n1, float const * vertical_coefficients )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 6248, + "column": 1, + "source_line": "static void stbir__resample_vertical_gather(stbir__info const * stbir_info, stbir__per_split_info* split_info, int n, int contrib_n0, int contrib_n1, float const * vertical_coefficients )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 6287, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbir__decode_and_resample_for_vertical_gather_loop": { + "name": "stbir__decode_and_resample_for_vertical_gather_loop", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "stbir_info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__info const * stbir_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__info const * stbir_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__info" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "split_info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__per_split_info * split_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__per_split_info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__per_split_info * split_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__per_split_info" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6289, + "column": 1, + "source_line": "static void stbir__decode_and_resample_for_vertical_gather_loop(stbir__info const * stbir_info, stbir__per_split_info* split_info, int n)" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 6289, + "column": 1, + "source_line": "static void stbir__decode_and_resample_for_vertical_gather_loop(stbir__info const * stbir_info, stbir__per_split_info* split_info, int n)" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 6308, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbir__vertical_gather_loop": { + "name": "stbir__vertical_gather_loop", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "stbir_info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__info const * stbir_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__info const * stbir_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__info" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "split_info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__per_split_info * split_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__per_split_info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__per_split_info * split_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__per_split_info" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "split_count", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int split_count" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int split_count" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6310, + "column": 1, + "source_line": "static void stbir__vertical_gather_loop( stbir__info const * stbir_info, stbir__per_split_info* split_info, int split_count )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 6310, + "column": 1, + "source_line": "static void stbir__vertical_gather_loop( stbir__info const * stbir_info, stbir__per_split_info* split_info, int split_count )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 6369, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbir__encode_first_scanline_from_scatter": { + "name": "stbir__encode_first_scanline_from_scatter", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "stbir_info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__info const * stbir_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__info const * stbir_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__info" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "split_info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__per_split_info * split_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__per_split_info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__per_split_info * split_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__per_split_info" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6374, + "column": 1, + "source_line": "static void stbir__encode_first_scanline_from_scatter(stbir__info const * stbir_info, stbir__per_split_info* split_info)" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 6374, + "column": 1, + "source_line": "static void stbir__encode_first_scanline_from_scatter(stbir__info const * stbir_info, stbir__per_split_info* split_info)" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 6389, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbir__horizontal_resample_and_encode_first_scanline_from_scatter": { + "name": "stbir__horizontal_resample_and_encode_first_scanline_from_scatter", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "stbir_info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__info const * stbir_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__info const * stbir_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__info" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "split_info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__per_split_info * split_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__per_split_info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__per_split_info * split_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__per_split_info" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6391, + "column": 1, + "source_line": "static void stbir__horizontal_resample_and_encode_first_scanline_from_scatter(stbir__info const * stbir_info, stbir__per_split_info* split_info)" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 6391, + "column": 1, + "source_line": "static void stbir__horizontal_resample_and_encode_first_scanline_from_scatter(stbir__info const * stbir_info, stbir__per_split_info* split_info)" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 6410, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbir__resample_vertical_scatter": { + "name": "stbir__resample_vertical_scatter", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "stbir_info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__info const * stbir_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__info const * stbir_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__info" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "split_info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__per_split_info * split_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__per_split_info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__per_split_info * split_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__per_split_info" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "vertical_coefficients", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float const * vertical_coefficients", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [ + "const" + ], + "source_text": "const float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float const * vertical_coefficients", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [ + "const" + ], + "source_text": "const float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "vertical_buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float const * vertical_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [ + "const" + ], + "source_text": "const float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float const * vertical_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [ + "const" + ], + "source_text": "const float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "vertical_buffer_end", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float const * vertical_buffer_end", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [ + "const" + ], + "source_text": "const float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float const * vertical_buffer_end", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [ + "const" + ], + "source_text": "const float" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6412, + "column": 1, + "source_line": "static void stbir__resample_vertical_scatter(stbir__info const * stbir_info, stbir__per_split_info* split_info, int n0, int n1, float const * vertical_coefficients, float const * vertical_buffer, float const * vertical_buffer_end )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 6412, + "column": 1, + "source_line": "static void stbir__resample_vertical_scatter(stbir__info const * stbir_info, stbir__per_split_info* split_info, int n0, int n1, float const * vertical_coefficients, float const * vertical_buffer, float const * vertical_buffer_end )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 6440, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbir__vertical_scatter_loop": { + "name": "stbir__vertical_scatter_loop", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "stbir_info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__info const * stbir_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__info const * stbir_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__info" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "split_info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__per_split_info * split_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__per_split_info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__per_split_info * split_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__per_split_info" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "split_count", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int split_count" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int split_count" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6444, + "column": 1, + "source_line": "static void stbir__vertical_scatter_loop( stbir__info const * stbir_info, stbir__per_split_info* split_info, int split_count )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 6444, + "column": 1, + "source_line": "static void stbir__vertical_scatter_loop( stbir__info const * stbir_info, stbir__per_split_info* split_info, int split_count )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 6567, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbir__set_sampler": { + "name": "stbir__set_sampler", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "samp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__sampler * samp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__sampler" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__sampler * samp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__sampler" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "filter", + "type": { + "reference": "stbir_filter" + }, + "declared_type": { + "reference": "stbir_filter" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "kernel", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__kernel_callback * kernel", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__kernel_callback" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__kernel_callback * kernel", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__kernel_callback" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "support", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__support_callback * support", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__support_callback" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__support_callback * support", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__support_callback" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "edge", + "type": { + "reference": "stbir_edge" + }, + "declared_type": { + "reference": "stbir_edge" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "scale_info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__scale_info * scale_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__scale_info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__scale_info * scale_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__scale_info" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "always_gather", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int always_gather" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int always_gather" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "user_data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6573, + "column": 1, + "source_line": "static void stbir__set_sampler(stbir__sampler * samp, stbir_filter filter, stbir__kernel_callback * kernel, stbir__support_callback * support, stbir_edge edge, stbir__scale_info * scale_info, int always_gather, void * user_data )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 6573, + "column": 1, + "source_line": "static void stbir__set_sampler(stbir__sampler * samp, stbir_filter filter, stbir__kernel_callback * kernel, stbir__support_callback * support, stbir_edge edge, stbir__scale_info * scale_info, int always_gather, void * user_data )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 6653, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbir__get_conservative_extents": { + "name": "stbir__get_conservative_extents", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "samp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__sampler * samp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__sampler" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__sampler * samp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__sampler" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "range", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__contributors * range", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__contributors" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__contributors * range", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__contributors" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "user_data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user_data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6655, + "column": 1, + "source_line": "static void stbir__get_conservative_extents( stbir__sampler * samp, stbir__contributors * range, void * user_data )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 6655, + "column": 1, + "source_line": "static void stbir__get_conservative_extents( stbir__sampler * samp, stbir__contributors * range, void * user_data )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 6745, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbir__get_split_info": { + "name": "stbir__get_split_info", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "split_info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__per_split_info * split_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__per_split_info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__per_split_info * split_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__per_split_info" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "splits", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int splits" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int splits" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "output_height", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int output_height" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int output_height" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "vertical_pixel_margin", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int vertical_pixel_margin" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int vertical_pixel_margin" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "input_full_height", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int input_full_height" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int input_full_height" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "is_gather", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int is_gather" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int is_gather" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "contribs", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__contributors * contribs", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__contributors" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__contributors * contribs", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__contributors" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6747, + "column": 1, + "source_line": "static void stbir__get_split_info( stbir__per_split_info* split_info, int splits, int output_height, int vertical_pixel_margin, int input_full_height, int is_gather, stbir__contributors * contribs )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 6747, + "column": 1, + "source_line": "static void stbir__get_split_info( stbir__per_split_info* split_info, int splits, int output_height, int vertical_pixel_margin, int input_full_height, int is_gather, stbir__contributors * contribs )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 6815, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbir__free_internal_mem": { + "name": "stbir__free_internal_mem", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__info *info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__info *info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__info" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6817, + "column": 1, + "source_line": "static void stbir__free_internal_mem( stbir__info *info )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 6817, + "column": 1, + "source_line": "static void stbir__free_internal_mem( stbir__info *info )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 6866, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbir__get_max_split": { + "name": "stbir__get_max_split", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "splits", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int splits" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int splits" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "height", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int height" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int height" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6868, + "column": 1, + "source_line": "static int stbir__get_max_split( int splits, int height )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 6868, + "column": 1, + "source_line": "static int stbir__get_max_split( int splits, int height )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 6881, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbir__should_do_vertical_first": { + "name": "stbir__should_do_vertical_first", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "weights_table", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float weights_table[STBIR_RESIZE_CLASSIFICATIONS][4]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "4", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float weights_table[STBIR_RESIZE_CLASSIFICATIONS][4]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STBIR_RESIZE_CLASSIFICATIONS", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "4", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "horizontal_filter_pixel_width", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int horizontal_filter_pixel_width" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int horizontal_filter_pixel_width" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "horizontal_scale", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float horizontal_scale" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float horizontal_scale" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "horizontal_output_size", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int horizontal_output_size" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int horizontal_output_size" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "vertical_filter_pixel_width", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int vertical_filter_pixel_width" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int vertical_filter_pixel_width" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "vertical_scale", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float vertical_scale" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float vertical_scale" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "vertical_output_size", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int vertical_output_size" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int vertical_output_size" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "is_gather", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int is_gather" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int is_gather" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STBIR__V_FIRST_INFO * info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STBIR__V_FIRST_INFO" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STBIR__V_FIRST_INFO * info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STBIR__V_FIRST_INFO" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6985, + "column": 1, + "source_line": "static int stbir__should_do_vertical_first( float weights_table[STBIR_RESIZE_CLASSIFICATIONS][4], int horizontal_filter_pixel_width, float horizontal_scale, int horizontal_output_size, int vertical_filter_pixel_width, float vertical_scale, int vertical_output_size, int is_gather, STBIR__V_FIRST_INFO * info )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 6985, + "column": 1, + "source_line": "static int stbir__should_do_vertical_first( float weights_table[STBIR_RESIZE_CLASSIFICATIONS][4], int horizontal_filter_pixel_width, float horizontal_scale, int horizontal_output_size, int vertical_filter_pixel_width, float vertical_scale, int vertical_output_size, int is_gather, STBIR__V_FIRST_INFO * info )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 7031, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbir__perform_resize": { + "name": "stbir__perform_resize", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__info const * info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__info const * info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__info" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "split_start", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int split_start" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int split_start" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "split_count", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int split_count" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int split_count" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 7380, + "column": 1, + "source_line": "static int stbir__perform_resize( stbir__info const * info, int split_start, int split_count )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 7380, + "column": 1, + "source_line": "static int stbir__perform_resize( stbir__info const * info, int split_start, int split_count )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 7394, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbir__update_info_from_resize": { + "name": "stbir__update_info_from_resize", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__info * info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__info * info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__info" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "resize", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STBIR_RESIZE * resize", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STBIR_RESIZE" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STBIR_RESIZE * resize", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STBIR_RESIZE" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 7396, + "column": 1, + "source_line": "static void stbir__update_info_from_resize( stbir__info * info, STBIR_RESIZE * resize )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 7396, + "column": 1, + "source_line": "static void stbir__update_info_from_resize( stbir__info * info, STBIR_RESIZE * resize )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 7543, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbir__clip": { + "name": "stbir__clip", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "outx", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int * outx", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int * outx", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "outsubw", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int * outsubw", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int * outsubw", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "outw", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int outw" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int outw" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "u0", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "double * u0", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "double * u0", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "u1", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "double * u1", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "double * u1", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 7545, + "column": 1, + "source_line": "static void stbir__clip( int * outx, int * outsubw, int outw, double * u0, double * u1 )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 7545, + "column": 1, + "source_line": "static void stbir__clip( int * outx, int * outsubw, int outw, double * u0, double * u1 )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 7568, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbir__double_to_rational": { + "name": "stbir__double_to_rational", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double f" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double f" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "limit", + "type": { + "reference": "stbir_uint32" + }, + "declared_type": { + "reference": "stbir_uint32" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "numer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir_uint32 *numer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir_uint32" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir_uint32 *numer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir_uint32" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "denom", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir_uint32 *denom", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir_uint32" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir_uint32 *denom", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir_uint32" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "limit_denom", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int limit_denom" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int limit_denom" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 7571, + "column": 1, + "source_line": "static int stbir__double_to_rational(double f, stbir_uint32 limit, stbir_uint32 *numer, stbir_uint32 *denom, int limit_denom ) // limit_denom (1) or limit numer (0)" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 7571, + "column": 1, + "source_line": "static int stbir__double_to_rational(double f, stbir_uint32 limit, stbir_uint32 *numer, stbir_uint32 *denom, int limit_denom ) // limit_denom (1) or limit numer (0)" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 7646, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbir__calculate_region_transform": { + "name": "stbir__calculate_region_transform", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "scale_info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__scale_info * scale_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__scale_info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbir__scale_info * scale_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbir__scale_info" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "output_full_range", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int output_full_range" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int output_full_range" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "output_offset", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int * output_offset", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int * output_offset", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "output_sub_range", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int output_sub_range" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int output_sub_range" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "input_full_range", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int input_full_range" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int input_full_range" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "input_s0", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double input_s0" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double input_s0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "input_s1", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double input_s1" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double input_s1" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 7648, + "column": 1, + "source_line": "static int stbir__calculate_region_transform( stbir__scale_info * scale_info, int output_full_range, int * output_offset, int output_sub_range, int input_full_range, double input_s0, double input_s1 )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 7648, + "column": 1, + "source_line": "static int stbir__calculate_region_transform( stbir__scale_info * scale_info, int output_full_range, int * output_offset, int output_sub_range, int input_full_range, double input_s0, double input_s1 )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 7695, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbir__init_and_set_layout": { + "name": "stbir__init_and_set_layout", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "resize", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STBIR_RESIZE * resize", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STBIR_RESIZE" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STBIR_RESIZE * resize", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STBIR_RESIZE" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "pixel_layout", + "type": { + "reference": "stbir_pixel_layout" + }, + "declared_type": { + "reference": "stbir_pixel_layout" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "data_type", + "type": { + "reference": "stbir_datatype" + }, + "declared_type": { + "reference": "stbir_datatype" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 7698, + "column": 1, + "source_line": "static void stbir__init_and_set_layout( STBIR_RESIZE * resize, stbir_pixel_layout pixel_layout, stbir_datatype data_type )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 7698, + "column": 1, + "source_line": "static void stbir__init_and_set_layout( STBIR_RESIZE * resize, stbir_pixel_layout pixel_layout, stbir_datatype data_type )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 7718, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbir__perform_build": { + "name": "stbir__perform_build", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "resize", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STBIR_RESIZE * resize", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STBIR_RESIZE" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STBIR_RESIZE * resize", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STBIR_RESIZE" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "splits", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int splits" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int splits" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 7876, + "column": 1, + "source_line": "static int stbir__perform_build( STBIR_RESIZE * resize, int splits )" + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 7876, + "column": 1, + "source_line": "static int stbir__perform_build( STBIR_RESIZE * resize, int splits )" + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 7947, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbir_quick_resize_helper": { + "name": "stbir_quick_resize_helper", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "parameters": [ + { + "name": "input_pixels", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const void *input_pixels", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [ + "const" + ], + "source_text": "const void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const void *input_pixels", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [ + "const" + ], + "source_text": "const void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "input_w", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int input_w" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int input_w" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "input_h", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int input_h" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int input_h" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "input_stride_in_bytes", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int input_stride_in_bytes" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int input_stride_in_bytes" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "output_pixels", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *output_pixels", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *output_pixels", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "output_w", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int output_w" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int output_w" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "output_h", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int output_h" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int output_h" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "output_stride_in_bytes", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int output_stride_in_bytes" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int output_stride_in_bytes" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "pixel_layout", + "type": { + "reference": "stbir_pixel_layout" + }, + "declared_type": { + "reference": "stbir_pixel_layout" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "data_type", + "type": { + "reference": "stbir_datatype" + }, + "declared_type": { + "reference": "stbir_datatype" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "edge", + "type": { + "reference": "stbir_edge" + }, + "declared_type": { + "reference": "stbir_edge" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "filter", + "type": { + "reference": "stbir_filter" + }, + "declared_type": { + "reference": "stbir_filter" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8044, + "column": 1, + "source_line": "static void * stbir_quick_resize_helper( const void *input_pixels , int input_w , int input_h, int input_stride_in_bytes," + }, + "start": { + "filename": "stb/stb_image_resize2.h", + "line": 8044, + "column": 1, + "source_line": "static void * stbir_quick_resize_helper( const void *input_pixels , int input_w , int input_h, int input_stride_in_bytes," + }, + "end": { + "filename": "stb/stb_image_resize2.h", + "line": 8116, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + } + }, + "structs": { + "STBIR_RESIZE": { + "reference": "struct STBIR_RESIZE" + }, + "STBIR_PROFILE_INFO": { + "reference": "struct STBIR_PROFILE_INFO" + }, + "stbir__scale_info": { + "reference": "struct stbir__scale_info" + }, + "stbir__info": { + "reference": "struct stbir__info" + }, + "STBIR__V_FIRST_INFO": { + "reference": "struct STBIR__V_FIRST_INFO" + } + }, + "unions": { + "stbir__FP16": { + "reference": "union stbir__FP16" + }, + "stbir__simdi_u32": { + "reference": "union stbir__simdi_u32" + } + }, + "enums": {}, + "typedefs": { + "stbir_uint8": { + "reference": "stbir_uint8" + }, + "stbir_uint16": { + "reference": "stbir_uint16" + }, + "stbir_uint32": { + "reference": "stbir_uint32" + }, + "stbir_uint64": { + "reference": "stbir_uint64" + }, + "stbir_pixel_layout": { + "reference": "stbir_pixel_layout" + }, + "stbir_edge": { + "reference": "stbir_edge" + }, + "stbir_filter": { + "reference": "stbir_filter" + }, + "stbir_datatype": { + "reference": "stbir_datatype" + }, + "stbir_input_callback": { + "reference": "stbir_input_callback" + }, + "stbir_output_callback": { + "reference": "stbir_output_callback" + }, + "stbir__kernel_callback": { + "reference": "stbir__kernel_callback" + }, + "stbir__support_callback": { + "reference": "stbir__support_callback" + }, + "stbir__info": { + "reference": "stbir__info" + }, + "STBIR_RESIZE": { + "reference": "STBIR_RESIZE" + }, + "STBIR_PROFILE_INFO": { + "reference": "STBIR_PROFILE_INFO" + }, + "stbir_internal_pixel_layout": { + "reference": "stbir_internal_pixel_layout" + }, + "stbir__contributors": { + "reference": "stbir__contributors" + }, + "stbir__filter_extent_info": { + "reference": "stbir__filter_extent_info" + }, + "stbir__span": { + "reference": "stbir__span" + }, + "stbir__scale_info": { + "reference": "stbir__scale_info" + }, + "stbir__sampler": { + "reference": "stbir__sampler" + }, + "stbir__extents": { + "reference": "stbir__extents" + }, + "stbir__per_split_info": { + "reference": "stbir__per_split_info" + }, + "stbir__decode_pixels_func": { + "reference": "stbir__decode_pixels_func" + }, + "stbir__alpha_weight_func": { + "reference": "stbir__alpha_weight_func" + }, + "stbir__horizontal_gather_channels_func": { + "reference": "stbir__horizontal_gather_channels_func" + }, + "stbir__alpha_unweight_func": { + "reference": "stbir__alpha_unweight_func" + }, + "stbir__encode_pixels_func": { + "reference": "stbir__encode_pixels_func" + }, + "stbir__FP32": { + "reference": "stbir__FP32" + }, + "stbir__FP16": { + "reference": "stbir__FP16" + }, + "stbir__simdi_u32": { + "reference": "stbir__simdi_u32" + }, + "stbir__edge_wrap_func": { + "reference": "stbir__edge_wrap_func" + }, + "STBIR_VERTICAL_GATHERFUNC": { + "reference": "STBIR_VERTICAL_GATHERFUNC" + }, + "STBIR_VERTICAL_SCATTERFUNC": { + "reference": "STBIR_VERTICAL_SCATTERFUNC" + }, + "stbir__handle_scanline_for_scatter_func": { + "reference": "stbir__handle_scanline_for_scatter_func" + }, + "STBIR__V_FIRST_INFO": { + "reference": "STBIR__V_FIRST_INFO" + } + }, + "variables": {}, + "macros": { + "STBIR_INCLUDE_STB_IMAGE_RESIZE2_H": { + "name": "STBIR_INCLUDE_STB_IMAGE_RESIZE2_H", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 389, + "column": 1, + "source_line": "#define STBIR_INCLUDE_STB_IMAGE_RESIZE2_H" + } + }, + "STBIRDEF": { + "name": "STBIRDEF", + "value": "extern", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 412, + "column": 1, + "source_line": "#define STBIRDEF extern" + } + }, + "STBIR_ASSERT": { + "name": "STBIR_ASSERT", + "value": "assert(x)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 787, + "column": 1, + "source_line": "#define STBIR_ASSERT(x) assert(x)" + } + }, + "STBIR_MALLOC": { + "name": "STBIR_MALLOC", + "value": "((void)(user_data), malloc(size))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 792, + "column": 1, + "source_line": "#define STBIR_MALLOC(size,user_data) ((void)(user_data), malloc(size))" + } + }, + "STBIR_FREE": { + "name": "STBIR_FREE", + "value": "((void)(user_data), free(ptr))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 793, + "column": 1, + "source_line": "#define STBIR_FREE(ptr,user_data) ((void)(user_data), free(ptr))" + } + }, + "stbir__inline": { + "name": "stbir__inline", + "value": "__inline__", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 803, + "column": 1, + "source_line": "#define stbir__inline __inline__" + } + }, + "STBIR__SEPARATE_ALLOCATIONS": { + "name": "STBIR__SEPARATE_ALLOCATIONS", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 819, + "column": 5, + "source_line": " #define STBIR__SEPARATE_ALLOCATIONS" + } + }, + "STBIR__UNUSED": { + "name": "STBIR__UNUSED", + "value": "(void)sizeof(v)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 840, + "column": 1, + "source_line": "#define STBIR__UNUSED(v) (void)sizeof(v)" + } + }, + "STBIR__ARRAY_SIZE": { + "name": "STBIR__ARRAY_SIZE", + "value": "(sizeof((a))/sizeof((a)[0]))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 843, + "column": 1, + "source_line": "#define STBIR__ARRAY_SIZE(a) (sizeof((a))/sizeof((a)[0]))" + } + }, + "STBIR_DEFAULT_FILTER_UPSAMPLE": { + "name": "STBIR_DEFAULT_FILTER_UPSAMPLE", + "value": "STBIR_FILTER_CATMULLROM", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 847, + "column": 1, + "source_line": "#define STBIR_DEFAULT_FILTER_UPSAMPLE STBIR_FILTER_CATMULLROM" + } + }, + "STBIR_DEFAULT_FILTER_DOWNSAMPLE": { + "name": "STBIR_DEFAULT_FILTER_DOWNSAMPLE", + "value": "STBIR_FILTER_MITCHELL", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 851, + "column": 1, + "source_line": "#define STBIR_DEFAULT_FILTER_DOWNSAMPLE STBIR_FILTER_MITCHELL" + } + }, + "STBIR__HEADER_FILENAME": { + "name": "STBIR__HEADER_FILENAME", + "value": "\"stb_image_resize2.h\"", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 856, + "column": 1, + "source_line": "#define STBIR__HEADER_FILENAME \"stb_image_resize2.h\"" + } + }, + "STBIR_BGR": { + "name": "STBIR_BGR", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8226, + "column": 1, + "source_line": "#undef STBIR_BGR" + } + }, + "STBIR_1CHANNEL": { + "name": "STBIR_1CHANNEL", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8227, + "column": 1, + "source_line": "#undef STBIR_1CHANNEL" + } + }, + "STBIR_2CHANNEL": { + "name": "STBIR_2CHANNEL", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8228, + "column": 1, + "source_line": "#undef STBIR_2CHANNEL" + } + }, + "STBIR_RGB": { + "name": "STBIR_RGB", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8229, + "column": 1, + "source_line": "#undef STBIR_RGB" + } + }, + "STBIR_RGBA": { + "name": "STBIR_RGBA", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8230, + "column": 1, + "source_line": "#undef STBIR_RGBA" + } + }, + "STBIR_4CHANNEL": { + "name": "STBIR_4CHANNEL", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8231, + "column": 1, + "source_line": "#undef STBIR_4CHANNEL" + } + }, + "STBIR_BGRA": { + "name": "STBIR_BGRA", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8232, + "column": 1, + "source_line": "#undef STBIR_BGRA" + } + }, + "STBIR_ARGB": { + "name": "STBIR_ARGB", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8233, + "column": 1, + "source_line": "#undef STBIR_ARGB" + } + }, + "STBIR_ABGR": { + "name": "STBIR_ABGR", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8234, + "column": 1, + "source_line": "#undef STBIR_ABGR" + } + }, + "STBIR_RA": { + "name": "STBIR_RA", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8235, + "column": 1, + "source_line": "#undef STBIR_RA" + } + }, + "STBIR_AR": { + "name": "STBIR_AR", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8236, + "column": 1, + "source_line": "#undef STBIR_AR" + } + }, + "STBIR_RGBA_PM": { + "name": "STBIR_RGBA_PM", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8237, + "column": 1, + "source_line": "#undef STBIR_RGBA_PM" + } + }, + "STBIR_BGRA_PM": { + "name": "STBIR_BGRA_PM", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8238, + "column": 1, + "source_line": "#undef STBIR_BGRA_PM" + } + }, + "STBIR_ARGB_PM": { + "name": "STBIR_ARGB_PM", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8239, + "column": 1, + "source_line": "#undef STBIR_ARGB_PM" + } + }, + "STBIR_ABGR_PM": { + "name": "STBIR_ABGR_PM", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8240, + "column": 1, + "source_line": "#undef STBIR_ABGR_PM" + } + }, + "STBIR_RA_PM": { + "name": "STBIR_RA_PM", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8241, + "column": 1, + "source_line": "#undef STBIR_RA_PM" + } + }, + "STBIR_AR_PM": { + "name": "STBIR_AR_PM", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8242, + "column": 1, + "source_line": "#undef STBIR_AR_PM" + } + }, + "stbir__max_uint8_as_float": { + "name": "stbir__max_uint8_as_float", + "value": "255.0f", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1064, + "column": 1, + "source_line": "#define stbir__max_uint8_as_float 255.0f" + } + }, + "stbir__max_uint16_as_float": { + "name": "stbir__max_uint16_as_float", + "value": "65535.0f", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1065, + "column": 1, + "source_line": "#define stbir__max_uint16_as_float 65535.0f" + } + }, + "stbir__max_uint8_as_float_inverted": { + "name": "stbir__max_uint8_as_float_inverted", + "value": "3.9215689e-03f", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1066, + "column": 1, + "source_line": "#define stbir__max_uint8_as_float_inverted 3.9215689e-03f // (1.0f/255.0f)" + } + }, + "stbir__max_uint16_as_float_inverted": { + "name": "stbir__max_uint16_as_float_inverted", + "value": "1.5259022e-05f", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1067, + "column": 1, + "source_line": "#define stbir__max_uint16_as_float_inverted 1.5259022e-05f // (1.0f/65535.0f)" + } + }, + "stbir__small_float": { + "name": "stbir__small_float", + "value": "((float)1 / (1 << 20) / (1 << 20) / (1 << 20) / (1 << 20) / (1 << 20) / (1 << 20))", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1068, + "column": 1, + "source_line": "#define stbir__small_float ((float)1 / (1 << 20) / (1 << 20) / (1 << 20) / (1 << 20) / (1 << 20) / (1 << 20))" + } + }, + "STBIR_CLAMP": { + "name": "STBIR_CLAMP", + "value": "for(;;) { if ( (x) < (xmin) ) (x) = (xmin); if ( (x) > (xmax) ) (x) = (xmax); break; }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1071, + "column": 1, + "source_line": "#define STBIR_CLAMP(x, xmin, xmax) for(;;) { \\" + } + }, + "STBIR_FORCE_GATHER_FILTER_SCANLINES_AMOUNT": { + "name": "STBIR_FORCE_GATHER_FILTER_SCANLINES_AMOUNT", + "value": "32", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1165, + "column": 1, + "source_line": "#define STBIR_FORCE_GATHER_FILTER_SCANLINES_AMOUNT 32 // when downsampling and <= 32 scanlines of buffering, use gather. gather used down to 1/8th scaling for 25% win." + } + }, + "STBIR_FORCE_MINIMUM_SCANLINES_FOR_SPLITS": { + "name": "STBIR_FORCE_MINIMUM_SCANLINES_FOR_SPLITS", + "value": "4", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1169, + "column": 1, + "source_line": "#define STBIR_FORCE_MINIMUM_SCANLINES_FOR_SPLITS 4 // when threading, what is the minimum number of scanlines for a split?" + } + }, + "STBIR_INPUT_CALLBACK_PADDING": { + "name": "STBIR_INPUT_CALLBACK_PADDING", + "value": "3", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1172, + "column": 1, + "source_line": "#define STBIR_INPUT_CALLBACK_PADDING 3" + } + }, + "STBIR_SSE": { + "name": "STBIR_SSE", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1177, + "column": 1, + "source_line": "#define STBIR_SSE" + } + }, + "STBIR_NO_SIMD": { + "name": "STBIR_NO_SIMD", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1184, + "column": 3, + "source_line": " #define STBIR_NO_SIMD" + } + }, + "STBIR_SSE2": { + "name": "STBIR_SSE2", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1276, + "column": 1, + "source_line": "#undef STBIR_SSE2" + } + }, + "STBIR_AVX": { + "name": "STBIR_AVX", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1280, + "column": 1, + "source_line": "#undef STBIR_AVX" + } + }, + "STBIR_AVX2": { + "name": "STBIR_AVX2", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1288, + "column": 1, + "source_line": "#undef STBIR_AVX2" + } + }, + "STBIR_FP16C": { + "name": "STBIR_FP16C", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1292, + "column": 1, + "source_line": "#undef STBIR_FP16C" + } + }, + "STBIR_NEON": { + "name": "STBIR_NEON", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1284, + "column": 1, + "source_line": "#undef STBIR_NEON" + } + }, + "STBIR_USE_FMA": { + "name": "STBIR_USE_FMA", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1225, + "column": 1, + "source_line": "#undef STBIR_USE_FMA // no FMA for 32-bit arm on MSVC" + } + }, + "STBIR_WASM": { + "name": "STBIR_WASM", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1296, + "column": 1, + "source_line": "#undef STBIR_WASM" + } + }, + "STBIR_STREAMOUT_PTR": { + "name": "STBIR_STREAMOUT_PTR", + "value": "star", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1262, + "column": 3, + "source_line": " #define STBIR_STREAMOUT_PTR( star ) star" + } + }, + "STBIR_NO_UNROLL": { + "name": "STBIR_NO_UNROLL", + "value": null, + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1263, + "column": 3, + "source_line": " #define STBIR_NO_UNROLL( ptr )" + } + }, + "STBIR_NO_UNROLL_LOOP_START": { + "name": "STBIR_NO_UNROLL_LOOP_START", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1264, + "column": 3, + "source_line": " #define STBIR_NO_UNROLL_LOOP_START" + } + }, + "STBIR_NO_UNROLL_LOOP_START_INF_FOR": { + "name": "STBIR_NO_UNROLL_LOOP_START_INF_FOR", + "value": "STBIR_NO_UNROLL_LOOP_START", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1268, + "column": 1, + "source_line": "#define STBIR_NO_UNROLL_LOOP_START_INF_FOR STBIR_NO_UNROLL_LOOP_START" + } + }, + "STBIR_SIMD": { + "name": "STBIR_SIMD", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2144, + "column": 3, + "source_line": " #define STBIR_SIMD" + } + }, + "stbir__simdf": { + "name": "stbir__simdf", + "value": "v128_t", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1978, + "column": 3, + "source_line": " #define stbir__simdf v128_t" + } + }, + "stbir__simdi": { + "name": "stbir__simdi", + "value": "v128_t", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1979, + "column": 3, + "source_line": " #define stbir__simdi v128_t" + } + }, + "stbir_simdi_castf": { + "name": "stbir_simdi_castf", + "value": "(reg)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1981, + "column": 3, + "source_line": " #define stbir_simdi_castf( reg ) (reg)" + } + }, + "stbir_simdf_casti": { + "name": "stbir_simdf_casti", + "value": "(reg)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1982, + "column": 3, + "source_line": " #define stbir_simdf_casti( reg ) (reg)" + } + }, + "stbir__simdf_load": { + "name": "stbir__simdf_load", + "value": "(reg) = wasm_v128_load( (void const*)(ptr) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1984, + "column": 3, + "source_line": " #define stbir__simdf_load( reg, ptr ) (reg) = wasm_v128_load( (void const*)(ptr) )" + } + }, + "stbir__simdi_load": { + "name": "stbir__simdi_load", + "value": "(reg) = wasm_v128_load( (void const*)(ptr) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1985, + "column": 3, + "source_line": " #define stbir__simdi_load( reg, ptr ) (reg) = wasm_v128_load( (void const*)(ptr) )" + } + }, + "stbir__simdf_load1": { + "name": "stbir__simdf_load1", + "value": "(out) = wasm_v128_load32_splat( (void const*)(ptr) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1986, + "column": 3, + "source_line": " #define stbir__simdf_load1( out, ptr ) (out) = wasm_v128_load32_splat( (void const*)(ptr) ) // top values can be random (not denormal or nan for perf)" + } + }, + "stbir__simdi_load1": { + "name": "stbir__simdi_load1", + "value": "(out) = wasm_v128_load32_splat( (void const*)(ptr) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1987, + "column": 3, + "source_line": " #define stbir__simdi_load1( out, ptr ) (out) = wasm_v128_load32_splat( (void const*)(ptr) )" + } + }, + "stbir__simdf_load1z": { + "name": "stbir__simdf_load1z", + "value": "(out) = wasm_v128_load32_zero( (void const*)(ptr) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1988, + "column": 3, + "source_line": " #define stbir__simdf_load1z( out, ptr ) (out) = wasm_v128_load32_zero( (void const*)(ptr) ) // top values must be zero" + } + }, + "stbir__simdf_frep4": { + "name": "stbir__simdf_frep4", + "value": "wasm_f32x4_splat( fvar )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1989, + "column": 3, + "source_line": " #define stbir__simdf_frep4( fvar ) wasm_f32x4_splat( fvar )" + } + }, + "stbir__simdf_load1frep4": { + "name": "stbir__simdf_load1frep4", + "value": "(out) = wasm_f32x4_splat( fvar )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1990, + "column": 3, + "source_line": " #define stbir__simdf_load1frep4( out, fvar ) (out) = wasm_f32x4_splat( fvar )" + } + }, + "stbir__simdf_load2": { + "name": "stbir__simdf_load2", + "value": "(out) = wasm_v128_load64_splat( (void const*)(ptr) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1991, + "column": 3, + "source_line": " #define stbir__simdf_load2( out, ptr ) (out) = wasm_v128_load64_splat( (void const*)(ptr) ) // top values can be random (not denormal or nan for perf)" + } + }, + "stbir__simdf_load2z": { + "name": "stbir__simdf_load2z", + "value": "(out) = wasm_v128_load64_zero( (void const*)(ptr) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1992, + "column": 3, + "source_line": " #define stbir__simdf_load2z( out, ptr ) (out) = wasm_v128_load64_zero( (void const*)(ptr) ) // top values must be zero" + } + }, + "stbir__simdf_load2hmerge": { + "name": "stbir__simdf_load2hmerge", + "value": "(out) = wasm_v128_load64_lane( (void const*)(ptr), reg, 1 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1993, + "column": 3, + "source_line": " #define stbir__simdf_load2hmerge( out, reg, ptr ) (out) = wasm_v128_load64_lane( (void const*)(ptr), reg, 1 )" + } + }, + "stbir__simdf_zeroP": { + "name": "stbir__simdf_zeroP", + "value": "wasm_f32x4_const_splat(0)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1995, + "column": 3, + "source_line": " #define stbir__simdf_zeroP() wasm_f32x4_const_splat(0)" + } + }, + "stbir__simdf_zero": { + "name": "stbir__simdf_zero", + "value": "(reg) = wasm_f32x4_const_splat(0)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1996, + "column": 3, + "source_line": " #define stbir__simdf_zero( reg ) (reg) = wasm_f32x4_const_splat(0)" + } + }, + "stbir__simdf_store": { + "name": "stbir__simdf_store", + "value": "wasm_v128_store( (void*)(ptr), reg )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1998, + "column": 3, + "source_line": " #define stbir__simdf_store( ptr, reg ) wasm_v128_store( (void*)(ptr), reg )" + } + }, + "stbir__simdf_store1": { + "name": "stbir__simdf_store1", + "value": "wasm_v128_store32_lane( (void*)(ptr), reg, 0 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1999, + "column": 3, + "source_line": " #define stbir__simdf_store1( ptr, reg ) wasm_v128_store32_lane( (void*)(ptr), reg, 0 )" + } + }, + "stbir__simdf_store2": { + "name": "stbir__simdf_store2", + "value": "wasm_v128_store64_lane( (void*)(ptr), reg, 0 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2000, + "column": 3, + "source_line": " #define stbir__simdf_store2( ptr, reg ) wasm_v128_store64_lane( (void*)(ptr), reg, 0 )" + } + }, + "stbir__simdf_store2h": { + "name": "stbir__simdf_store2h", + "value": "wasm_v128_store64_lane( (void*)(ptr), reg, 1 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2001, + "column": 3, + "source_line": " #define stbir__simdf_store2h( ptr, reg ) wasm_v128_store64_lane( (void*)(ptr), reg, 1 )" + } + }, + "stbir__simdi_store": { + "name": "stbir__simdi_store", + "value": "wasm_v128_store( (void*)(ptr), reg )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2003, + "column": 3, + "source_line": " #define stbir__simdi_store( ptr, reg ) wasm_v128_store( (void*)(ptr), reg )" + } + }, + "stbir__simdi_store1": { + "name": "stbir__simdi_store1", + "value": "wasm_v128_store32_lane( (void*)(ptr), reg, 0 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2004, + "column": 3, + "source_line": " #define stbir__simdi_store1( ptr, reg ) wasm_v128_store32_lane( (void*)(ptr), reg, 0 )" + } + }, + "stbir__simdi_store2": { + "name": "stbir__simdi_store2", + "value": "wasm_v128_store64_lane( (void*)(ptr), reg, 0 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2005, + "column": 3, + "source_line": " #define stbir__simdi_store2( ptr, reg ) wasm_v128_store64_lane( (void*)(ptr), reg, 0 )" + } + }, + "stbir__prefetch": { + "name": "stbir__prefetch", + "value": null, + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2007, + "column": 3, + "source_line": " #define stbir__prefetch( ptr )" + } + }, + "stbir__simdi_expand_u8_to_u32": { + "name": "stbir__simdi_expand_u8_to_u32", + "value": "{ v128_t l = wasm_u16x8_extend_low_u8x16 ( ireg ); v128_t h = wasm_u16x8_extend_high_u8x16( ireg ); out0 = wasm_u32x4_extend_low_u16x8 ( l ); out1 = wasm_u32x4_extend_high_u16x8( l ); out2 = wasm_u32x4_extend_low_u16x8 ( h ); out3 = wasm_u32x4_extend_high_u16x8( h ); }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2009, + "column": 3, + "source_line": " #define stbir__simdi_expand_u8_to_u32(out0,out1,out2,out3,ireg) \\" + } + }, + "stbir__simdi_expand_u8_to_1u32": { + "name": "stbir__simdi_expand_u8_to_1u32", + "value": "{ v128_t tmp = wasm_u16x8_extend_low_u8x16(ireg); out = wasm_u32x4_extend_low_u16x8(tmp); }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2019, + "column": 3, + "source_line": " #define stbir__simdi_expand_u8_to_1u32(out,ireg) \\" + } + }, + "stbir__simdi_expand_u16_to_u32": { + "name": "stbir__simdi_expand_u16_to_u32", + "value": "{ out0 = wasm_u32x4_extend_low_u16x8 ( ireg ); out1 = wasm_u32x4_extend_high_u16x8( ireg ); }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2025, + "column": 3, + "source_line": " #define stbir__simdi_expand_u16_to_u32(out0,out1,ireg) \\" + } + }, + "stbir__simdf_convert_float_to_i32": { + "name": "stbir__simdf_convert_float_to_i32", + "value": "(i) = wasm_i32x4_trunc_sat_f32x4(f)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2031, + "column": 3, + "source_line": " #define stbir__simdf_convert_float_to_i32( i, f ) (i) = wasm_i32x4_trunc_sat_f32x4(f)" + } + }, + "stbir__simdf_convert_float_to_int": { + "name": "stbir__simdf_convert_float_to_int", + "value": "wasm_i32x4_extract_lane(wasm_i32x4_trunc_sat_f32x4(f), 0)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2032, + "column": 3, + "source_line": " #define stbir__simdf_convert_float_to_int( f ) wasm_i32x4_extract_lane(wasm_i32x4_trunc_sat_f32x4(f), 0)" + } + }, + "stbir__simdf_convert_float_to_uint8": { + "name": "stbir__simdf_convert_float_to_uint8", + "value": "((unsigned char)wasm_i32x4_extract_lane(wasm_i32x4_trunc_sat_f32x4(wasm_f32x4_max(wasm_f32x4_min(f,STBIR_max_uint8_as_float),wasm_f32x4_const_splat(0))), 0))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2034, + "column": 3, + "source_line": " #define stbir__simdf_convert_float_to_uint8( f ) ((unsigned char)wasm_i32x4_extract_lane(wasm_i32x4_trunc_sat_f32x4(wasm_f32x4_max(wasm_f32x4_min(f,STBIR_max_uint8_as_float),wasm_f32x4_const_splat(0))), 0))" + } + }, + "stbir__simdf_convert_float_to_short": { + "name": "stbir__simdf_convert_float_to_short", + "value": "((unsigned short)wasm_i32x4_extract_lane(wasm_i32x4_trunc_sat_f32x4(wasm_f32x4_max(wasm_f32x4_min(f,STBIR_max_uint16_as_float),wasm_f32x4_const_splat(0))), 0))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2035, + "column": 3, + "source_line": " #define stbir__simdf_convert_float_to_short( f ) ((unsigned short)wasm_i32x4_extract_lane(wasm_i32x4_trunc_sat_f32x4(wasm_f32x4_max(wasm_f32x4_min(f,STBIR_max_uint16_as_float),wasm_f32x4_const_splat(0))), 0))" + } + }, + "stbir__simdi_to_int": { + "name": "stbir__simdi_to_int", + "value": "wasm_i32x4_extract_lane(i, 0)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2033, + "column": 3, + "source_line": " #define stbir__simdi_to_int( i ) wasm_i32x4_extract_lane(i, 0)" + } + }, + "stbir__simdi_convert_i32_to_float": { + "name": "stbir__simdi_convert_i32_to_float", + "value": "(out) = wasm_f32x4_convert_i32x4(ireg)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2036, + "column": 3, + "source_line": " #define stbir__simdi_convert_i32_to_float(out, ireg) (out) = wasm_f32x4_convert_i32x4(ireg)" + } + }, + "stbir__simdf_add": { + "name": "stbir__simdf_add", + "value": "(out) = wasm_f32x4_add( reg0, reg1 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2037, + "column": 3, + "source_line": " #define stbir__simdf_add( out, reg0, reg1 ) (out) = wasm_f32x4_add( reg0, reg1 )" + } + }, + "stbir__simdf_mult": { + "name": "stbir__simdf_mult", + "value": "(out) = wasm_f32x4_mul( reg0, reg1 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2038, + "column": 3, + "source_line": " #define stbir__simdf_mult( out, reg0, reg1 ) (out) = wasm_f32x4_mul( reg0, reg1 )" + } + }, + "stbir__simdf_mult_mem": { + "name": "stbir__simdf_mult_mem", + "value": "(out) = wasm_f32x4_mul( reg, wasm_v128_load( (void const*)(ptr) ) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2039, + "column": 3, + "source_line": " #define stbir__simdf_mult_mem( out, reg, ptr ) (out) = wasm_f32x4_mul( reg, wasm_v128_load( (void const*)(ptr) ) )" + } + }, + "stbir__simdf_mult1_mem": { + "name": "stbir__simdf_mult1_mem", + "value": "(out) = wasm_f32x4_mul( reg, wasm_v128_load32_splat( (void const*)(ptr) ) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2040, + "column": 3, + "source_line": " #define stbir__simdf_mult1_mem( out, reg, ptr ) (out) = wasm_f32x4_mul( reg, wasm_v128_load32_splat( (void const*)(ptr) ) )" + } + }, + "stbir__simdf_add_mem": { + "name": "stbir__simdf_add_mem", + "value": "(out) = wasm_f32x4_add( reg, wasm_v128_load( (void const*)(ptr) ) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2041, + "column": 3, + "source_line": " #define stbir__simdf_add_mem( out, reg, ptr ) (out) = wasm_f32x4_add( reg, wasm_v128_load( (void const*)(ptr) ) )" + } + }, + "stbir__simdf_add1_mem": { + "name": "stbir__simdf_add1_mem", + "value": "(out) = wasm_f32x4_add( reg, wasm_v128_load32_splat( (void const*)(ptr) ) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2042, + "column": 3, + "source_line": " #define stbir__simdf_add1_mem( out, reg, ptr ) (out) = wasm_f32x4_add( reg, wasm_v128_load32_splat( (void const*)(ptr) ) )" + } + }, + "stbir__simdf_madd": { + "name": "stbir__simdf_madd", + "value": "(out) = wasm_f32x4_add( add, wasm_f32x4_mul( mul1, mul2 ) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2044, + "column": 3, + "source_line": " #define stbir__simdf_madd( out, add, mul1, mul2 ) (out) = wasm_f32x4_add( add, wasm_f32x4_mul( mul1, mul2 ) )" + } + }, + "stbir__simdf_madd1": { + "name": "stbir__simdf_madd1", + "value": "(out) = wasm_f32x4_add( add, wasm_f32x4_mul( mul1, mul2 ) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2045, + "column": 3, + "source_line": " #define stbir__simdf_madd1( out, add, mul1, mul2 ) (out) = wasm_f32x4_add( add, wasm_f32x4_mul( mul1, mul2 ) )" + } + }, + "stbir__simdf_madd_mem": { + "name": "stbir__simdf_madd_mem", + "value": "(out) = wasm_f32x4_add( add, wasm_f32x4_mul( mul, wasm_v128_load( (void const*)(ptr) ) ) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2046, + "column": 3, + "source_line": " #define stbir__simdf_madd_mem( out, add, mul, ptr ) (out) = wasm_f32x4_add( add, wasm_f32x4_mul( mul, wasm_v128_load( (void const*)(ptr) ) ) )" + } + }, + "stbir__simdf_madd1_mem": { + "name": "stbir__simdf_madd1_mem", + "value": "(out) = wasm_f32x4_add( add, wasm_f32x4_mul( mul, wasm_v128_load32_splat( (void const*)(ptr) ) ) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2047, + "column": 3, + "source_line": " #define stbir__simdf_madd1_mem( out, add, mul, ptr ) (out) = wasm_f32x4_add( add, wasm_f32x4_mul( mul, wasm_v128_load32_splat( (void const*)(ptr) ) ) )" + } + }, + "stbir__simdf_add1": { + "name": "stbir__simdf_add1", + "value": "(out) = wasm_f32x4_add( reg0, reg1 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2049, + "column": 3, + "source_line": " #define stbir__simdf_add1( out, reg0, reg1 ) (out) = wasm_f32x4_add( reg0, reg1 )" + } + }, + "stbir__simdf_mult1": { + "name": "stbir__simdf_mult1", + "value": "(out) = wasm_f32x4_mul( reg0, reg1 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2050, + "column": 3, + "source_line": " #define stbir__simdf_mult1( out, reg0, reg1 ) (out) = wasm_f32x4_mul( reg0, reg1 )" + } + }, + "stbir__simdf_and": { + "name": "stbir__simdf_and", + "value": "(out) = wasm_v128_and( reg0, reg1 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2052, + "column": 3, + "source_line": " #define stbir__simdf_and( out, reg0, reg1 ) (out) = wasm_v128_and( reg0, reg1 )" + } + }, + "stbir__simdf_or": { + "name": "stbir__simdf_or", + "value": "(out) = wasm_v128_or( reg0, reg1 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2053, + "column": 3, + "source_line": " #define stbir__simdf_or( out, reg0, reg1 ) (out) = wasm_v128_or( reg0, reg1 )" + } + }, + "stbir__simdf_min": { + "name": "stbir__simdf_min", + "value": "(out) = wasm_f32x4_min( reg0, reg1 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2055, + "column": 3, + "source_line": " #define stbir__simdf_min( out, reg0, reg1 ) (out) = wasm_f32x4_min( reg0, reg1 )" + } + }, + "stbir__simdf_max": { + "name": "stbir__simdf_max", + "value": "(out) = wasm_f32x4_max( reg0, reg1 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2056, + "column": 3, + "source_line": " #define stbir__simdf_max( out, reg0, reg1 ) (out) = wasm_f32x4_max( reg0, reg1 )" + } + }, + "stbir__simdf_min1": { + "name": "stbir__simdf_min1", + "value": "(out) = wasm_f32x4_min( reg0, reg1 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2057, + "column": 3, + "source_line": " #define stbir__simdf_min1( out, reg0, reg1 ) (out) = wasm_f32x4_min( reg0, reg1 )" + } + }, + "stbir__simdf_max1": { + "name": "stbir__simdf_max1", + "value": "(out) = wasm_f32x4_max( reg0, reg1 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2058, + "column": 3, + "source_line": " #define stbir__simdf_max1( out, reg0, reg1 ) (out) = wasm_f32x4_max( reg0, reg1 )" + } + }, + "stbir__simdf_0123ABCDto3ABx": { + "name": "stbir__simdf_0123ABCDto3ABx", + "value": "(out) = wasm_i32x4_shuffle( reg0, reg1, 3, 4, 5, -1 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2060, + "column": 3, + "source_line": " #define stbir__simdf_0123ABCDto3ABx( out, reg0, reg1 ) (out) = wasm_i32x4_shuffle( reg0, reg1, 3, 4, 5, -1 )" + } + }, + "stbir__simdf_0123ABCDto23Ax": { + "name": "stbir__simdf_0123ABCDto23Ax", + "value": "(out) = wasm_i32x4_shuffle( reg0, reg1, 2, 3, 4, -1 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2061, + "column": 3, + "source_line": " #define stbir__simdf_0123ABCDto23Ax( out, reg0, reg1 ) (out) = wasm_i32x4_shuffle( reg0, reg1, 2, 3, 4, -1 )" + } + }, + "stbir__simdf_aaa1": { + "name": "stbir__simdf_aaa1", + "value": "(out) = wasm_i32x4_shuffle(alp, ones, 3, 3, 3, 4)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2063, + "column": 3, + "source_line": " #define stbir__simdf_aaa1(out,alp,ones) (out) = wasm_i32x4_shuffle(alp, ones, 3, 3, 3, 4)" + } + }, + "stbir__simdf_1aaa": { + "name": "stbir__simdf_1aaa", + "value": "(out) = wasm_i32x4_shuffle(alp, ones, 4, 0, 0, 0)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2064, + "column": 3, + "source_line": " #define stbir__simdf_1aaa(out,alp,ones) (out) = wasm_i32x4_shuffle(alp, ones, 4, 0, 0, 0)" + } + }, + "stbir__simdf_a1a1": { + "name": "stbir__simdf_a1a1", + "value": "(out) = wasm_i32x4_shuffle(alp, ones, 1, 4, 3, 4)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2065, + "column": 3, + "source_line": " #define stbir__simdf_a1a1(out,alp,ones) (out) = wasm_i32x4_shuffle(alp, ones, 1, 4, 3, 4)" + } + }, + "stbir__simdf_1a1a": { + "name": "stbir__simdf_1a1a", + "value": "(out) = wasm_i32x4_shuffle(alp, ones, 4, 0, 4, 2)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2066, + "column": 3, + "source_line": " #define stbir__simdf_1a1a(out,alp,ones) (out) = wasm_i32x4_shuffle(alp, ones, 4, 0, 4, 2)" + } + }, + "stbir__simdf_swiz": { + "name": "stbir__simdf_swiz", + "value": "wasm_i32x4_shuffle(reg, reg, one, two, three, four)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2068, + "column": 3, + "source_line": " #define stbir__simdf_swiz( reg, one, two, three, four ) wasm_i32x4_shuffle(reg, reg, one, two, three, four)" + } + }, + "stbir__simdi_and": { + "name": "stbir__simdi_and", + "value": "(out) = wasm_v128_and( reg0, reg1 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2070, + "column": 3, + "source_line": " #define stbir__simdi_and( out, reg0, reg1 ) (out) = wasm_v128_and( reg0, reg1 )" + } + }, + "stbir__simdi_or": { + "name": "stbir__simdi_or", + "value": "(out) = wasm_v128_or( reg0, reg1 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2071, + "column": 3, + "source_line": " #define stbir__simdi_or( out, reg0, reg1 ) (out) = wasm_v128_or( reg0, reg1 )" + } + }, + "stbir__simdi_16madd": { + "name": "stbir__simdi_16madd", + "value": "(out) = wasm_i32x4_dot_i16x8( reg0, reg1 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2072, + "column": 3, + "source_line": " #define stbir__simdi_16madd( out, reg0, reg1 ) (out) = wasm_i32x4_dot_i16x8( reg0, reg1 )" + } + }, + "stbir__simdf_pack_to_8bytes": { + "name": "stbir__simdf_pack_to_8bytes", + "value": "{ v128_t af = wasm_f32x4_max( wasm_f32x4_min(aa, STBIR_max_uint8_as_float), wasm_f32x4_const_splat(0) ); v128_t bf = wasm_f32x4_max( wasm_f32x4_min(bb, STBIR_max_uint8_as_float), wasm_f32x4_const_splat(0) ); v128_t ai = wasm_i32x4_trunc_sat_f32x4( af ); v128_t bi = wasm_i32x4_trunc_sat_f32x4( bf ); v128_t out16 = wasm_i16x8_narrow_i32x4( ai, bi ); out = wasm_u8x16_narrow_i16x8( out16, out16 ); }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2074, + "column": 3, + "source_line": " #define stbir__simdf_pack_to_8bytes(out,aa,bb) \\" + } + }, + "stbir__simdf_load4_transposed": { + "name": "stbir__simdf_load4_transposed", + "value": "{ v128_t t0 = wasm_v128_load( ptr ); v128_t t1 = wasm_v128_load( ptr+4 ); v128_t t2 = wasm_v128_load( ptr+8 ); v128_t t3 = wasm_v128_load( ptr+12 ); v128_t s0 = wasm_i32x4_shuffle(t0, t1, 0, 4, 2, 6); v128_t s1 = wasm_i32x4_shuffle(t0, t1, 1, 5, 3, 7); v128_t s2 = wasm_i32x4_shuffle(t2, t3, 0, 4, 2, 6); v128_t s3 = wasm_i32x4_shuffle(t2, t3, 1, 5, 3, 7); o0 = wasm_i32x4_shuffle(s0, s2, 0, 1, 4, 5); o1 = wasm_i32x4_shuffle(s1, s3, 0, 1, 4, 5); o2 = wasm_i32x4_shuffle(s0, s2, 2, 3, 6, 7); o3 = wasm_i32x4_shuffle(s1, s3, 2, 3, 6, 7); }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2102, + "column": 3, + "source_line": " #define stbir__simdf_load4_transposed( o0, o1, o2, o3, ptr ) \\" + } + }, + "stbir__interleave_pack_and_store_16_u8": { + "name": "stbir__interleave_pack_and_store_16_u8", + "value": "{ v128_t tmp0 = wasm_i16x8_narrow_i32x4(r0, r1); v128_t tmp1 = wasm_i16x8_narrow_i32x4(r2, r3); v128_t tmp = wasm_u8x16_narrow_i16x8(tmp0, tmp1); tmp = wasm_i8x16_shuffle(tmp, tmp, 0, 4, 8, 12, 1, 5, 9, 13, 2, 6, 10, 14, 3, 7, 11, 15); wasm_v128_store( (void*)(ptr), tmp); }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2093, + "column": 3, + "source_line": " #define stbir__interleave_pack_and_store_16_u8( ptr, r0, r1, r2, r3 ) \\" + } + }, + "stbir__simdi_32shr": { + "name": "stbir__simdi_32shr", + "value": "out = wasm_u32x4_shr( reg, imm )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2118, + "column": 3, + "source_line": " #define stbir__simdi_32shr( out, reg, imm ) out = wasm_u32x4_shr( reg, imm )" + } + }, + "STBIR__CONST_32_TO_8": { + "name": "STBIR__CONST_32_TO_8", + "value": "(char)(unsigned char)((v)&255),(char)(unsigned char)(((v)>>8)&255),(char)(unsigned char)(((v)>>16)&255),(char)(unsigned char)(((v)>>24)&255)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1463, + "column": 5, + "source_line": " #define STBIR__CONST_32_TO_8( v ) (char)(unsigned char)((v)&255),(char)(unsigned char)(((v)>>8)&255),(char)(unsigned char)(((v)>>16)&255),(char)(unsigned char)(((v)>>24)&255)" + } + }, + "STBIR__CONST_4_32i": { + "name": "STBIR__CONST_4_32i", + "value": "(long long)((((stbir_uint64)(stbir_uint32)(v))<<32)|((stbir_uint64)(stbir_uint32)(v))),(long long)((((stbir_uint64)(stbir_uint32)(v))<<32)|((stbir_uint64)(stbir_uint32)(v)))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1468, + "column": 5, + "source_line": " #define STBIR__CONST_4_32i( v ) (long long)((((stbir_uint64)(stbir_uint32)(v))<<32)|((stbir_uint64)(stbir_uint32)(v))),(long long)((((stbir_uint64)(stbir_uint32)(v))<<32)|((stbir_uint64)(stbir_uint32)(v)))" + } + }, + "STBIR__CONST_4d_32i": { + "name": "STBIR__CONST_4d_32i", + "value": "(long long)((((stbir_uint64)(stbir_uint32)(v1))<<32)|((stbir_uint64)(stbir_uint32)(v0))),(long long)((((stbir_uint64)(stbir_uint32)(v3))<<32)|((stbir_uint64)(stbir_uint32)(v2)))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1469, + "column": 5, + "source_line": " #define STBIR__CONST_4d_32i( v0, v1, v2, v3 ) (long long)((((stbir_uint64)(stbir_uint32)(v1))<<32)|((stbir_uint64)(stbir_uint32)(v0))),(long long)((((stbir_uint64)(stbir_uint32)(v3))<<32)|((stbir_uint64)(stbir_uint32)(v2)))" + } + }, + "STBIR__SIMDF_CONST": { + "name": "STBIR__SIMDF_CONST", + "value": "stbir__simdf var = (v128_t)(stbir__f32x4){ x, x, x, x }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2121, + "column": 3, + "source_line": " #define STBIR__SIMDF_CONST(var, x) stbir__simdf var = (v128_t)(stbir__f32x4){ x, x, x, x }" + } + }, + "STBIR__SIMDI_CONST": { + "name": "STBIR__SIMDI_CONST", + "value": "stbir__simdi var = { x, x, x, x }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2122, + "column": 3, + "source_line": " #define STBIR__SIMDI_CONST(var, x) stbir__simdi var = { x, x, x, x }" + } + }, + "STBIR__CONSTF": { + "name": "STBIR__CONSTF", + "value": "(var)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2123, + "column": 3, + "source_line": " #define STBIR__CONSTF(var) (var)" + } + }, + "STBIR__CONSTI": { + "name": "STBIR__CONSTI", + "value": "(var)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2124, + "column": 3, + "source_line": " #define STBIR__CONSTI(var) (var)" + } + }, + "stbir__simdf_pack_to_8words": { + "name": "stbir__simdf_pack_to_8words", + "value": "{ v128_t af = wasm_f32x4_max( wasm_f32x4_min(aa, STBIR_max_uint16_as_float), wasm_f32x4_const_splat(0)); v128_t bf = wasm_f32x4_max( wasm_f32x4_min(bb, STBIR_max_uint16_as_float), wasm_f32x4_const_splat(0)); v128_t ai = wasm_i32x4_trunc_sat_f32x4( af ); v128_t bi = wasm_i32x4_trunc_sat_f32x4( bf ); out = wasm_u16x8_narrow_i32x4( ai, bi ); }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2084, + "column": 3, + "source_line": " #define stbir__simdf_pack_to_8words(out,aa,bb) \\" + } + }, + "STBIR_SIMD8": { + "name": "STBIR_SIMD8", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1502, + "column": 5, + "source_line": " #define STBIR_SIMD8" + } + }, + "stbir__simdf8": { + "name": "stbir__simdf8", + "value": "__m256", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1503, + "column": 5, + "source_line": " #define stbir__simdf8 __m256" + } + }, + "stbir__simdi8": { + "name": "stbir__simdi8", + "value": "__m256i", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1504, + "column": 5, + "source_line": " #define stbir__simdi8 __m256i" + } + }, + "stbir__simdf8_load": { + "name": "stbir__simdf8_load", + "value": "(out) = _mm256_loadu_ps( (float const *)(ptr) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1505, + "column": 5, + "source_line": " #define stbir__simdf8_load( out, ptr ) (out) = _mm256_loadu_ps( (float const *)(ptr) )" + } + }, + "stbir__simdi8_load": { + "name": "stbir__simdi8_load", + "value": "(out) = _mm256_loadu_si256( (__m256i const *)(ptr) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1506, + "column": 5, + "source_line": " #define stbir__simdi8_load( out, ptr ) (out) = _mm256_loadu_si256( (__m256i const *)(ptr) )" + } + }, + "stbir__simdf8_mult": { + "name": "stbir__simdf8_mult", + "value": "(out) = _mm256_mul_ps( (a), (b) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1507, + "column": 5, + "source_line": " #define stbir__simdf8_mult( out, a, b ) (out) = _mm256_mul_ps( (a), (b) )" + } + }, + "stbir__simdf8_store": { + "name": "stbir__simdf8_store", + "value": "_mm256_storeu_ps( (float*)(ptr), out )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1508, + "column": 5, + "source_line": " #define stbir__simdf8_store( ptr, out ) _mm256_storeu_ps( (float*)(ptr), out )" + } + }, + "stbir__simdi8_store": { + "name": "stbir__simdi8_store", + "value": "_mm256_storeu_si256( (__m256i*)(ptr), reg )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1509, + "column": 5, + "source_line": " #define stbir__simdi8_store( ptr, reg ) _mm256_storeu_si256( (__m256i*)(ptr), reg )" + } + }, + "stbir__simdf8_frep8": { + "name": "stbir__simdf8_frep8", + "value": "_mm256_set1_ps( fval )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1510, + "column": 5, + "source_line": " #define stbir__simdf8_frep8( fval ) _mm256_set1_ps( fval )" + } + }, + "stbir__simdf8_min": { + "name": "stbir__simdf8_min", + "value": "(out) = _mm256_min_ps( reg0, reg1 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1512, + "column": 5, + "source_line": " #define stbir__simdf8_min( out, reg0, reg1 ) (out) = _mm256_min_ps( reg0, reg1 )" + } + }, + "stbir__simdf8_max": { + "name": "stbir__simdf8_max", + "value": "(out) = _mm256_max_ps( reg0, reg1 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1513, + "column": 5, + "source_line": " #define stbir__simdf8_max( out, reg0, reg1 ) (out) = _mm256_max_ps( reg0, reg1 )" + } + }, + "stbir__simdf8_add4halves": { + "name": "stbir__simdf8_add4halves", + "value": "(out) = _mm_add_ps( bot4, _mm256_extractf128_ps( top8, 1 ) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1515, + "column": 5, + "source_line": " #define stbir__simdf8_add4halves( out, bot4, top8 ) (out) = _mm_add_ps( bot4, _mm256_extractf128_ps( top8, 1 ) )" + } + }, + "stbir__simdf8_mult_mem": { + "name": "stbir__simdf8_mult_mem", + "value": "(out) = _mm256_mul_ps( reg, _mm256_loadu_ps( (float const*)(ptr) ) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1516, + "column": 5, + "source_line": " #define stbir__simdf8_mult_mem( out, reg, ptr ) (out) = _mm256_mul_ps( reg, _mm256_loadu_ps( (float const*)(ptr) ) )" + } + }, + "stbir__simdf8_add_mem": { + "name": "stbir__simdf8_add_mem", + "value": "(out) = _mm256_add_ps( reg, _mm256_loadu_ps( (float const*)(ptr) ) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1517, + "column": 5, + "source_line": " #define stbir__simdf8_add_mem( out, reg, ptr ) (out) = _mm256_add_ps( reg, _mm256_loadu_ps( (float const*)(ptr) ) )" + } + }, + "stbir__simdf8_add": { + "name": "stbir__simdf8_add", + "value": "(out) = _mm256_add_ps( a, b )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1518, + "column": 5, + "source_line": " #define stbir__simdf8_add( out, a, b ) (out) = _mm256_add_ps( a, b )" + } + }, + "stbir__simdf8_load1b": { + "name": "stbir__simdf8_load1b", + "value": "(out) = _mm256_broadcast_ss( ptr )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1519, + "column": 5, + "source_line": " #define stbir__simdf8_load1b( out, ptr ) (out) = _mm256_broadcast_ss( ptr )" + } + }, + "stbir__simdf_load1rep4": { + "name": "stbir__simdf_load1rep4", + "value": "(out) = _mm_broadcast_ss( ptr )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1520, + "column": 5, + "source_line": " #define stbir__simdf_load1rep4( out, ptr ) (out) = _mm_broadcast_ss( ptr ) // avx load instruction" + } + }, + "stbir__simdi8_convert_i32_to_float": { + "name": "stbir__simdi8_convert_i32_to_float", + "value": "(out) = _mm256_cvtepi32_ps( ireg )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1522, + "column": 5, + "source_line": " #define stbir__simdi8_convert_i32_to_float(out, ireg) (out) = _mm256_cvtepi32_ps( ireg )" + } + }, + "stbir__simdf8_convert_float_to_i32": { + "name": "stbir__simdf8_convert_float_to_i32", + "value": "(i) = _mm256_cvttps_epi32(f)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1523, + "column": 5, + "source_line": " #define stbir__simdf8_convert_float_to_i32( i, f ) (i) = _mm256_cvttps_epi32(f)" + } + }, + "stbir__simdf8_bot4s": { + "name": "stbir__simdf8_bot4s", + "value": "(out) = _mm256_permute2f128_ps(a,b, (0<<0)+(2<<4) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1525, + "column": 5, + "source_line": " #define stbir__simdf8_bot4s( out, a, b ) (out) = _mm256_permute2f128_ps(a,b, (0<<0)+(2<<4) )" + } + }, + "stbir__simdf8_top4s": { + "name": "stbir__simdf8_top4s", + "value": "(out) = _mm256_permute2f128_ps(a,b, (1<<0)+(3<<4) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1526, + "column": 5, + "source_line": " #define stbir__simdf8_top4s( out, a, b ) (out) = _mm256_permute2f128_ps(a,b, (1<<0)+(3<<4) )" + } + }, + "stbir__simdf8_gettop4": { + "name": "stbir__simdf8_gettop4", + "value": "_mm256_extractf128_ps(reg,1)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1528, + "column": 5, + "source_line": " #define stbir__simdf8_gettop4( reg ) _mm256_extractf128_ps(reg,1)" + } + }, + "stbir__simdi8_expand_u8_to_u32": { + "name": "stbir__simdi8_expand_u8_to_u32", + "value": "{ stbir__simdi a,zero = _mm_setzero_si128(); a = _mm_unpacklo_epi8( ireg, zero ); out0 = _mm256_setr_m128i( _mm_unpacklo_epi16( a, zero ), _mm_unpackhi_epi16( a, zero ) ); a = _mm_unpackhi_epi8( ireg, zero ); out1 = _mm256_setr_m128i( _mm_unpacklo_epi16( a, zero ), _mm_unpackhi_epi16( a, zero ) ); }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1572, + "column": 5, + "source_line": " #define stbir__simdi8_expand_u8_to_u32(out0,out1,ireg) \\" + } + }, + "stbir__simdf8_pack_to_16bytes": { + "name": "stbir__simdf8_pack_to_16bytes", + "value": "{ stbir__simdi t; stbir__simdf8 af,bf; stbir__simdi8 a,b; af = _mm256_min_ps( aa, STBIR_max_uint8_as_floatX ); bf = _mm256_min_ps( bb, STBIR_max_uint8_as_floatX ); af = _mm256_max_ps( af, _mm256_setzero_ps() ); bf = _mm256_max_ps( bf, _mm256_setzero_ps() ); a = _mm256_cvttps_epi32( af ); b = _mm256_cvttps_epi32( bf ); out = _mm_packs_epi32( _mm256_castsi256_si128(a), _mm256_extractf128_si256( a, 1 ) ); out = _mm_packus_epi16( out, out ); t = _mm_packs_epi32( _mm256_castsi256_si128(b), _mm256_extractf128_si256( b, 1 ) ); t = _mm_packus_epi16( t, t ); out = _mm_castps_si128( _mm_shuffle_ps( _mm_castsi128_ps(out), _mm_castsi128_ps(t), (0<<0)+(1<<2)+(0<<4)+(1<<6) ) ); }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1581, + "column": 5, + "source_line": " #define stbir__simdf8_pack_to_16bytes(out,aa,bb) \\" + } + }, + "stbir__simdi8_expand_u16_to_u32": { + "name": "stbir__simdi8_expand_u16_to_u32", + "value": "{ stbir__simdi a,b,zero = _mm_setzero_si128(); a = _mm_unpacklo_epi16( ireg, zero ); b = _mm_unpackhi_epi16( ireg, zero ); out = _mm256_insertf128_si256( _mm256_castsi128_si256( a ), b, 1 ); }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1599, + "column": 5, + "source_line": " #define stbir__simdi8_expand_u16_to_u32(out,ireg) \\" + } + }, + "stbir__simdf8_pack_to_16words": { + "name": "stbir__simdf8_pack_to_16words", + "value": "{ stbir__simdi t0,t1; stbir__simdf8 af,bf; stbir__simdi8 a,b; af = _mm256_min_ps( aa, STBIR_max_uint16_as_floatX ); bf = _mm256_min_ps( bb, STBIR_max_uint16_as_floatX ); af = _mm256_max_ps( af, _mm256_setzero_ps() ); bf = _mm256_max_ps( bf, _mm256_setzero_ps() ); a = _mm256_cvttps_epi32( af ); b = _mm256_cvttps_epi32( bf ); t0 = _mm_packus_epi32( _mm256_castsi256_si128(a), _mm256_extractf128_si256( a, 1 ) ); t1 = _mm_packus_epi32( _mm256_castsi256_si128(b), _mm256_extractf128_si256( b, 1 ) ); out = _mm256_setr_m128i( t0, t1 ); }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1607, + "column": 5, + "source_line": " #define stbir__simdf8_pack_to_16words(out,aa,bb) \\" + } + }, + "stbir__simdf8_0123to00001111": { + "name": "stbir__simdf8_0123to00001111", + "value": "(out) = _mm256_permutevar_ps ( in, stbir_00001111 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1626, + "column": 5, + "source_line": " #define stbir__simdf8_0123to00001111( out, in ) (out) = _mm256_permutevar_ps ( in, stbir_00001111 )" + } + }, + "stbir__simdf8_0123to22223333": { + "name": "stbir__simdf8_0123to22223333", + "value": "(out) = _mm256_permutevar_ps ( in, stbir_22223333 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1629, + "column": 5, + "source_line": " #define stbir__simdf8_0123to22223333( out, in ) (out) = _mm256_permutevar_ps ( in, stbir_22223333 )" + } + }, + "stbir__simdf8_0123to2222": { + "name": "stbir__simdf8_0123to2222", + "value": "(out) = stbir__simdf_swiz(_mm256_castps256_ps128(in), 2,2,2,2 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1631, + "column": 5, + "source_line": " #define stbir__simdf8_0123to2222( out, in ) (out) = stbir__simdf_swiz(_mm256_castps256_ps128(in), 2,2,2,2 )" + } + }, + "stbir__simdf8_load4b": { + "name": "stbir__simdf8_load4b", + "value": "(out) = _mm256_broadcast_ps( (__m128 const *)(ptr) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1633, + "column": 5, + "source_line": " #define stbir__simdf8_load4b( out, ptr ) (out) = _mm256_broadcast_ps( (__m128 const *)(ptr) )" + } + }, + "stbir__simdf8_0123to00112233": { + "name": "stbir__simdf8_0123to00112233", + "value": "(out) = _mm256_permutevar_ps ( in, stbir_00112233 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1636, + "column": 5, + "source_line": " #define stbir__simdf8_0123to00112233( out, in ) (out) = _mm256_permutevar_ps ( in, stbir_00112233 )" + } + }, + "stbir__simdf8_add4": { + "name": "stbir__simdf8_add4", + "value": "(out) = _mm256_add_ps( a8, _mm256_castps128_ps256( b ) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1637, + "column": 5, + "source_line": " #define stbir__simdf8_add4( out, a8, b ) (out) = _mm256_add_ps( a8, _mm256_castps128_ps256( b ) )" + } + }, + "stbir__simdf8_load6z": { + "name": "stbir__simdf8_load6z", + "value": "(out) = _mm256_maskload_ps( ptr, stbir_load6 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1640, + "column": 5, + "source_line": " #define stbir__simdf8_load6z( out, ptr ) (out) = _mm256_maskload_ps( ptr, stbir_load6 )" + } + }, + "stbir__simdf8_0123to00000000": { + "name": "stbir__simdf8_0123to00000000", + "value": "(out) = _mm256_shuffle_ps ( in, in, (0<<0)+(0<<2)+(0<<4)+(0<<6) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1642, + "column": 5, + "source_line": " #define stbir__simdf8_0123to00000000( out, in ) (out) = _mm256_shuffle_ps ( in, in, (0<<0)+(0<<2)+(0<<4)+(0<<6) )" + } + }, + "stbir__simdf8_0123to11111111": { + "name": "stbir__simdf8_0123to11111111", + "value": "(out) = _mm256_shuffle_ps ( in, in, (1<<0)+(1<<2)+(1<<4)+(1<<6) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1643, + "column": 5, + "source_line": " #define stbir__simdf8_0123to11111111( out, in ) (out) = _mm256_shuffle_ps ( in, in, (1<<0)+(1<<2)+(1<<4)+(1<<6) )" + } + }, + "stbir__simdf8_0123to22222222": { + "name": "stbir__simdf8_0123to22222222", + "value": "(out) = _mm256_shuffle_ps ( in, in, (2<<0)+(2<<2)+(2<<4)+(2<<6) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1644, + "column": 5, + "source_line": " #define stbir__simdf8_0123to22222222( out, in ) (out) = _mm256_shuffle_ps ( in, in, (2<<0)+(2<<2)+(2<<4)+(2<<6) )" + } + }, + "stbir__simdf8_0123to33333333": { + "name": "stbir__simdf8_0123to33333333", + "value": "(out) = _mm256_shuffle_ps ( in, in, (3<<0)+(3<<2)+(3<<4)+(3<<6) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1645, + "column": 5, + "source_line": " #define stbir__simdf8_0123to33333333( out, in ) (out) = _mm256_shuffle_ps ( in, in, (3<<0)+(3<<2)+(3<<4)+(3<<6) )" + } + }, + "stbir__simdf8_0123to21032103": { + "name": "stbir__simdf8_0123to21032103", + "value": "(out) = _mm256_shuffle_ps ( in, in, (2<<0)+(1<<2)+(0<<4)+(3<<6) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1646, + "column": 5, + "source_line": " #define stbir__simdf8_0123to21032103( out, in ) (out) = _mm256_shuffle_ps ( in, in, (2<<0)+(1<<2)+(0<<4)+(3<<6) )" + } + }, + "stbir__simdf8_0123to32103210": { + "name": "stbir__simdf8_0123to32103210", + "value": "(out) = _mm256_shuffle_ps ( in, in, (3<<0)+(2<<2)+(1<<4)+(0<<6) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1647, + "column": 5, + "source_line": " #define stbir__simdf8_0123to32103210( out, in ) (out) = _mm256_shuffle_ps ( in, in, (3<<0)+(2<<2)+(1<<4)+(0<<6) )" + } + }, + "stbir__simdf8_0123to12301230": { + "name": "stbir__simdf8_0123to12301230", + "value": "(out) = _mm256_shuffle_ps ( in, in, (1<<0)+(2<<2)+(3<<4)+(0<<6) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1648, + "column": 5, + "source_line": " #define stbir__simdf8_0123to12301230( out, in ) (out) = _mm256_shuffle_ps ( in, in, (1<<0)+(2<<2)+(3<<4)+(0<<6) )" + } + }, + "stbir__simdf8_0123to10321032": { + "name": "stbir__simdf8_0123to10321032", + "value": "(out) = _mm256_shuffle_ps ( in, in, (1<<0)+(0<<2)+(3<<4)+(2<<6) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1649, + "column": 5, + "source_line": " #define stbir__simdf8_0123to10321032( out, in ) (out) = _mm256_shuffle_ps ( in, in, (1<<0)+(0<<2)+(3<<4)+(2<<6) )" + } + }, + "stbir__simdf8_0123to30123012": { + "name": "stbir__simdf8_0123to30123012", + "value": "(out) = _mm256_shuffle_ps ( in, in, (3<<0)+(0<<2)+(1<<4)+(2<<6) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1650, + "column": 5, + "source_line": " #define stbir__simdf8_0123to30123012( out, in ) (out) = _mm256_shuffle_ps ( in, in, (3<<0)+(0<<2)+(1<<4)+(2<<6) )" + } + }, + "stbir__simdf8_0123to11331133": { + "name": "stbir__simdf8_0123to11331133", + "value": "(out) = _mm256_shuffle_ps ( in, in, (1<<0)+(1<<2)+(3<<4)+(3<<6) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1652, + "column": 5, + "source_line": " #define stbir__simdf8_0123to11331133( out, in ) (out) = _mm256_shuffle_ps ( in, in, (1<<0)+(1<<2)+(3<<4)+(3<<6) )" + } + }, + "stbir__simdf8_0123to00220022": { + "name": "stbir__simdf8_0123to00220022", + "value": "(out) = _mm256_shuffle_ps ( in, in, (0<<0)+(0<<2)+(2<<4)+(2<<6) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1653, + "column": 5, + "source_line": " #define stbir__simdf8_0123to00220022( out, in ) (out) = _mm256_shuffle_ps ( in, in, (0<<0)+(0<<2)+(2<<4)+(2<<6) )" + } + }, + "stbir__simdf8_aaa1": { + "name": "stbir__simdf8_aaa1", + "value": "(out) = _mm256_blend_ps( alp, ones, (1<<0)+(1<<1)+(1<<2)+(0<<3)+(1<<4)+(1<<5)+(1<<6)+(0<<7)); (out)=_mm256_shuffle_ps( out,out, (3<<0) + (3<<2) + (3<<4) + (0<<6) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1655, + "column": 5, + "source_line": " #define stbir__simdf8_aaa1( out, alp, ones ) (out) = _mm256_blend_ps( alp, ones, (1<<0)+(1<<1)+(1<<2)+(0<<3)+(1<<4)+(1<<5)+(1<<6)+(0<<7)); (out)=_mm256_shuffle_ps( out,out, (3<<0) + (3<<2) + (3<<4) + (0<<6) )" + } + }, + "stbir__simdf8_1aaa": { + "name": "stbir__simdf8_1aaa", + "value": "(out) = _mm256_blend_ps( alp, ones, (0<<0)+(1<<1)+(1<<2)+(1<<3)+(0<<4)+(1<<5)+(1<<6)+(1<<7)); (out)=_mm256_shuffle_ps( out,out, (1<<0) + (0<<2) + (0<<4) + (0<<6) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1656, + "column": 5, + "source_line": " #define stbir__simdf8_1aaa( out, alp, ones ) (out) = _mm256_blend_ps( alp, ones, (0<<0)+(1<<1)+(1<<2)+(1<<3)+(0<<4)+(1<<5)+(1<<6)+(1<<7)); (out)=_mm256_shuffle_ps( out,out, (1<<0) + (0<<2) + (0<<4) + (0<<6) )" + } + }, + "stbir__simdf8_a1a1": { + "name": "stbir__simdf8_a1a1", + "value": "(out) = _mm256_blend_ps( alp, ones, (1<<0)+(0<<1)+(1<<2)+(0<<3)+(1<<4)+(0<<5)+(1<<6)+(0<<7)); (out)=_mm256_shuffle_ps( out,out, (1<<0) + (0<<2) + (3<<4) + (2<<6) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1657, + "column": 5, + "source_line": " #define stbir__simdf8_a1a1( out, alp, ones) (out) = _mm256_blend_ps( alp, ones, (1<<0)+(0<<1)+(1<<2)+(0<<3)+(1<<4)+(0<<5)+(1<<6)+(0<<7)); (out)=_mm256_shuffle_ps( out,out, (1<<0) + (0<<2) + (3<<4) + (2<<6) )" + } + }, + "stbir__simdf8_1a1a": { + "name": "stbir__simdf8_1a1a", + "value": "(out) = _mm256_blend_ps( alp, ones, (0<<0)+(1<<1)+(0<<2)+(1<<3)+(0<<4)+(1<<5)+(0<<6)+(1<<7)); (out)=_mm256_shuffle_ps( out,out, (1<<0) + (0<<2) + (3<<4) + (2<<6) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1658, + "column": 5, + "source_line": " #define stbir__simdf8_1a1a( out, alp, ones) (out) = _mm256_blend_ps( alp, ones, (0<<0)+(1<<1)+(0<<2)+(1<<3)+(0<<4)+(1<<5)+(0<<6)+(1<<7)); (out)=_mm256_shuffle_ps( out,out, (1<<0) + (0<<2) + (3<<4) + (2<<6) )" + } + }, + "stbir__simdf8_zero": { + "name": "stbir__simdf8_zero", + "value": "(reg) = _mm256_setzero_ps()", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1660, + "column": 5, + "source_line": " #define stbir__simdf8_zero( reg ) (reg) = _mm256_setzero_ps()" + } + }, + "stbir__simdf8_madd": { + "name": "stbir__simdf8_madd", + "value": "(out) = _mm256_add_ps( add, _mm256_mul_ps( mul1, mul2 ) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1667, + "column": 5, + "source_line": " #define stbir__simdf8_madd( out, add, mul1, mul2 ) (out) = _mm256_add_ps( add, _mm256_mul_ps( mul1, mul2 ) )" + } + }, + "stbir__simdf8_madd_mem": { + "name": "stbir__simdf8_madd_mem", + "value": "(out) = _mm256_add_ps( add, _mm256_mul_ps( mul, _mm256_loadu_ps( (float const*)(ptr) ) ) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1668, + "column": 5, + "source_line": " #define stbir__simdf8_madd_mem( out, add, mul, ptr ) (out) = _mm256_add_ps( add, _mm256_mul_ps( mul, _mm256_loadu_ps( (float const*)(ptr) ) ) )" + } + }, + "stbir__simdf8_madd_mem4": { + "name": "stbir__simdf8_madd_mem4", + "value": "(out) = _mm256_add_ps( add, _mm256_setr_m128( _mm_mul_ps( mul, _mm_loadu_ps( (float const*)(ptr) ) ), _mm_setzero_ps() ) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1669, + "column": 5, + "source_line": " #define stbir__simdf8_madd_mem4( out, add, mul, ptr ) (out) = _mm256_add_ps( add, _mm256_setr_m128( _mm_mul_ps( mul, _mm_loadu_ps( (float const*)(ptr) ) ), _mm_setzero_ps() ) )" + } + }, + "stbir__if_simdf8_cast_to_simdf4": { + "name": "stbir__if_simdf8_cast_to_simdf4", + "value": "( val )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2210, + "column": 3, + "source_line": " #define stbir__if_simdf8_cast_to_simdf4( val ) ( val )" + } + }, + "STBIR_FLOORF": { + "name": "STBIR_FLOORF", + "value": "floorf(x)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2825, + "column": 1, + "source_line": "#define STBIR_FLOORF(x) floorf(x)" + } + }, + "STBIR_CEILF": { + "name": "STBIR_CEILF", + "value": "ceilf(x)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2824, + "column": 1, + "source_line": "#define STBIR_CEILF(x) ceilf(x)" + } + }, + "stbir_make16": { + "name": "stbir_make16", + "value": "(uint8x16_t){4*a+0,4*a+1,4*a+2,4*a+3,4*b+0,4*b+1,4*b+2,4*b+3,4*c+0,4*c+1,4*c+2,4*c+3,4*d+0,4*d+1,4*d+2,4*d+3}", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1827, + "column": 7, + "source_line": " #define stbir_make16(a,b,c,d) (uint8x16_t){4*a+0,4*a+1,4*a+2,4*a+3,4*b+0,4*b+1,4*b+2,4*b+3,4*c+0,4*c+1,4*c+2,4*c+3,4*d+0,4*d+1,4*d+2,4*d+3}" + } + }, + "stbir_make16x2": { + "name": "stbir_make16x2", + "value": "(uint8x16x2_t){{vreinterpretq_u8_f32(a),vreinterpretq_u8_f32(b)}}", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1828, + "column": 7, + "source_line": " #define stbir_make16x2(a,b) (uint8x16x2_t){{vreinterpretq_u8_f32(a),vreinterpretq_u8_f32(b)}}" + } + }, + "stbir__simdf_swiz2": { + "name": "stbir__simdf_swiz2", + "value": "vreinterpretq_f32_u8( vqtbl2q_u8( stbir_make16x2(rega,regb), stbir_make16(one, two, three, four) ) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1832, + "column": 5, + "source_line": " #define stbir__simdf_swiz2( rega, regb, one, two, three, four ) vreinterpretq_f32_u8( vqtbl2q_u8( stbir_make16x2(rega,regb), stbir_make16(one, two, three, four) ) )" + } + }, + "stbir_make8": { + "name": "stbir_make8", + "value": "(uint8x8_t){4*a+0,4*a+1,4*a+2,4*a+3,4*b+0,4*b+1,4*b+2,4*b+3}", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1859, + "column": 7, + "source_line": " #define stbir_make8(a,b) (uint8x8_t){4*a+0,4*a+1,4*a+2,4*a+3,4*b+0,4*b+1,4*b+2,4*b+3}" + } + }, + "stbir_make8x2": { + "name": "stbir_make8x2", + "value": "(uint8x8x2_t){ { vget_low_u8(vreinterpretq_u8_f32(reg)), vget_high_u8(vreinterpretq_u8_f32(reg)) } }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1858, + "column": 7, + "source_line": " #define stbir_make8x2(reg) (uint8x8x2_t){ { vget_low_u8(vreinterpretq_u8_f32(reg)), vget_high_u8(vreinterpretq_u8_f32(reg)) } }" + } + }, + "stbir__simdfX": { + "name": "stbir__simdfX", + "value": "stbir__simdf", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2185, + "column": 3, + "source_line": " #define stbir__simdfX stbir__simdf" + } + }, + "stbir__simdiX": { + "name": "stbir__simdiX", + "value": "stbir__simdi", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2186, + "column": 3, + "source_line": " #define stbir__simdiX stbir__simdi" + } + }, + "stbir__simdfX_load": { + "name": "stbir__simdfX_load", + "value": "stbir__simdf_load", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2187, + "column": 3, + "source_line": " #define stbir__simdfX_load stbir__simdf_load" + } + }, + "stbir__simdiX_load": { + "name": "stbir__simdiX_load", + "value": "stbir__simdi_load", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2188, + "column": 3, + "source_line": " #define stbir__simdiX_load stbir__simdi_load" + } + }, + "stbir__simdfX_mult": { + "name": "stbir__simdfX_mult", + "value": "stbir__simdf_mult", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2189, + "column": 3, + "source_line": " #define stbir__simdfX_mult stbir__simdf_mult" + } + }, + "stbir__simdfX_add_mem": { + "name": "stbir__simdfX_add_mem", + "value": "stbir__simdf_add_mem", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2190, + "column": 3, + "source_line": " #define stbir__simdfX_add_mem stbir__simdf_add_mem" + } + }, + "stbir__simdfX_madd_mem": { + "name": "stbir__simdfX_madd_mem", + "value": "stbir__simdf_madd_mem", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2191, + "column": 3, + "source_line": " #define stbir__simdfX_madd_mem stbir__simdf_madd_mem" + } + }, + "stbir__simdfX_store": { + "name": "stbir__simdfX_store", + "value": "stbir__simdf_store", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2192, + "column": 3, + "source_line": " #define stbir__simdfX_store stbir__simdf_store" + } + }, + "stbir__simdiX_store": { + "name": "stbir__simdiX_store", + "value": "stbir__simdi_store", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2193, + "column": 3, + "source_line": " #define stbir__simdiX_store stbir__simdi_store" + } + }, + "stbir__simdf_frepX": { + "name": "stbir__simdf_frepX", + "value": "stbir__simdf_frep4", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2194, + "column": 3, + "source_line": " #define stbir__simdf_frepX stbir__simdf_frep4" + } + }, + "stbir__simdfX_madd": { + "name": "stbir__simdfX_madd", + "value": "stbir__simdf_madd", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2195, + "column": 3, + "source_line": " #define stbir__simdfX_madd stbir__simdf_madd" + } + }, + "stbir__simdfX_min": { + "name": "stbir__simdfX_min", + "value": "stbir__simdf_min", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2196, + "column": 3, + "source_line": " #define stbir__simdfX_min stbir__simdf_min" + } + }, + "stbir__simdfX_max": { + "name": "stbir__simdfX_max", + "value": "stbir__simdf_max", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2197, + "column": 3, + "source_line": " #define stbir__simdfX_max stbir__simdf_max" + } + }, + "stbir__simdfX_aaa1": { + "name": "stbir__simdfX_aaa1", + "value": "stbir__simdf_aaa1", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2198, + "column": 3, + "source_line": " #define stbir__simdfX_aaa1 stbir__simdf_aaa1" + } + }, + "stbir__simdfX_1aaa": { + "name": "stbir__simdfX_1aaa", + "value": "stbir__simdf_1aaa", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2199, + "column": 3, + "source_line": " #define stbir__simdfX_1aaa stbir__simdf_1aaa" + } + }, + "stbir__simdfX_a1a1": { + "name": "stbir__simdfX_a1a1", + "value": "stbir__simdf_a1a1", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2200, + "column": 3, + "source_line": " #define stbir__simdfX_a1a1 stbir__simdf_a1a1" + } + }, + "stbir__simdfX_1a1a": { + "name": "stbir__simdfX_1a1a", + "value": "stbir__simdf_1a1a", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2201, + "column": 3, + "source_line": " #define stbir__simdfX_1a1a stbir__simdf_1a1a" + } + }, + "stbir__simdfX_convert_float_to_i32": { + "name": "stbir__simdfX_convert_float_to_i32", + "value": "stbir__simdf_convert_float_to_i32", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2202, + "column": 3, + "source_line": " #define stbir__simdfX_convert_float_to_i32 stbir__simdf_convert_float_to_i32" + } + }, + "stbir__simdfX_pack_to_words": { + "name": "stbir__simdfX_pack_to_words", + "value": "stbir__simdf_pack_to_8words", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2203, + "column": 3, + "source_line": " #define stbir__simdfX_pack_to_words stbir__simdf_pack_to_8words" + } + }, + "stbir__simdfX_zero": { + "name": "stbir__simdfX_zero", + "value": "stbir__simdf_zero", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2204, + "column": 3, + "source_line": " #define stbir__simdfX_zero stbir__simdf_zero" + } + }, + "STBIR_onesX": { + "name": "STBIR_onesX", + "value": "STBIR__CONSTF(STBIR_ones)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2205, + "column": 3, + "source_line": " #define STBIR_onesX STBIR__CONSTF(STBIR_ones)" + } + }, + "STBIR_max_uint8_as_floatX": { + "name": "STBIR_max_uint8_as_floatX", + "value": "STBIR__CONSTF(STBIR_max_uint8_as_float)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2207, + "column": 3, + "source_line": " #define STBIR_max_uint8_as_floatX STBIR__CONSTF(STBIR_max_uint8_as_float)" + } + }, + "STBIR_max_uint16_as_floatX": { + "name": "STBIR_max_uint16_as_floatX", + "value": "STBIR__CONSTF(STBIR_max_uint16_as_float)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2208, + "column": 3, + "source_line": " #define STBIR_max_uint16_as_floatX STBIR__CONSTF(STBIR_max_uint16_as_float)" + } + }, + "STBIR_simd_point5X": { + "name": "STBIR_simd_point5X", + "value": "STBIR__CONSTF(STBIR_simd_point5)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2206, + "column": 3, + "source_line": " #define STBIR_simd_point5X STBIR__CONSTF(STBIR_simd_point5)" + } + }, + "stbir__simdfX_float_count": { + "name": "stbir__simdfX_float_count", + "value": "4", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2209, + "column": 3, + "source_line": " #define stbir__simdfX_float_count 4" + } + }, + "stbir__simdfX_0123to1230": { + "name": "stbir__simdfX_0123to1230", + "value": "stbir__simdf_0123to1230", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2211, + "column": 3, + "source_line": " #define stbir__simdfX_0123to1230 stbir__simdf_0123to1230" + } + }, + "stbir__simdfX_0123to2103": { + "name": "stbir__simdfX_0123to2103", + "value": "stbir__simdf_0123to2103", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2212, + "column": 3, + "source_line": " #define stbir__simdfX_0123to2103 stbir__simdf_0123to2103" + } + }, + "stbir__simdf_0123to3333": { + "name": "stbir__simdf_0123to3333", + "value": "(out) = stbir__simdf_swiz( reg, 3,3,3,3 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2536, + "column": 1, + "source_line": "#define stbir__simdf_0123to3333( out, reg ) (out) = stbir__simdf_swiz( reg, 3,3,3,3 )" + } + }, + "stbir__simdf_0123to2222": { + "name": "stbir__simdf_0123to2222", + "value": "(out) = stbir__simdf_swiz( reg, 2,2,2,2 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2537, + "column": 1, + "source_line": "#define stbir__simdf_0123to2222( out, reg ) (out) = stbir__simdf_swiz( reg, 2,2,2,2 )" + } + }, + "stbir__simdf_0123to1111": { + "name": "stbir__simdf_0123to1111", + "value": "(out) = stbir__simdf_swiz( reg, 1,1,1,1 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2538, + "column": 1, + "source_line": "#define stbir__simdf_0123to1111( out, reg ) (out) = stbir__simdf_swiz( reg, 1,1,1,1 )" + } + }, + "stbir__simdf_0123to0000": { + "name": "stbir__simdf_0123to0000", + "value": "(out) = stbir__simdf_swiz( reg, 0,0,0,0 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2539, + "column": 1, + "source_line": "#define stbir__simdf_0123to0000( out, reg ) (out) = stbir__simdf_swiz( reg, 0,0,0,0 )" + } + }, + "stbir__simdf_0123to0003": { + "name": "stbir__simdf_0123to0003", + "value": "(out) = stbir__simdf_swiz( reg, 0,0,0,3 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2540, + "column": 1, + "source_line": "#define stbir__simdf_0123to0003( out, reg ) (out) = stbir__simdf_swiz( reg, 0,0,0,3 )" + } + }, + "stbir__simdf_0123to0001": { + "name": "stbir__simdf_0123to0001", + "value": "(out) = stbir__simdf_swiz( reg, 0,0,0,1 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2541, + "column": 1, + "source_line": "#define stbir__simdf_0123to0001( out, reg ) (out) = stbir__simdf_swiz( reg, 0,0,0,1 )" + } + }, + "stbir__simdf_0123to1122": { + "name": "stbir__simdf_0123to1122", + "value": "(out) = stbir__simdf_swiz( reg, 1,1,2,2 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2542, + "column": 1, + "source_line": "#define stbir__simdf_0123to1122( out, reg ) (out) = stbir__simdf_swiz( reg, 1,1,2,2 )" + } + }, + "stbir__simdf_0123to2333": { + "name": "stbir__simdf_0123to2333", + "value": "(out) = stbir__simdf_swiz( reg, 2,3,3,3 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2543, + "column": 1, + "source_line": "#define stbir__simdf_0123to2333( out, reg ) (out) = stbir__simdf_swiz( reg, 2,3,3,3 )" + } + }, + "stbir__simdf_0123to0023": { + "name": "stbir__simdf_0123to0023", + "value": "(out) = stbir__simdf_swiz( reg, 0,0,2,3 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2544, + "column": 1, + "source_line": "#define stbir__simdf_0123to0023( out, reg ) (out) = stbir__simdf_swiz( reg, 0,0,2,3 )" + } + }, + "stbir__simdf_0123to1230": { + "name": "stbir__simdf_0123to1230", + "value": "(out) = stbir__simdf_swiz( reg, 1,2,3,0 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2545, + "column": 1, + "source_line": "#define stbir__simdf_0123to1230( out, reg ) (out) = stbir__simdf_swiz( reg, 1,2,3,0 )" + } + }, + "stbir__simdf_0123to2103": { + "name": "stbir__simdf_0123to2103", + "value": "(out) = stbir__simdf_swiz( reg, 2,1,0,3 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2546, + "column": 1, + "source_line": "#define stbir__simdf_0123to2103( out, reg ) (out) = stbir__simdf_swiz( reg, 2,1,0,3 )" + } + }, + "stbir__simdf_0123to3210": { + "name": "stbir__simdf_0123to3210", + "value": "(out) = stbir__simdf_swiz( reg, 3,2,1,0 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2547, + "column": 1, + "source_line": "#define stbir__simdf_0123to3210( out, reg ) (out) = stbir__simdf_swiz( reg, 3,2,1,0 )" + } + }, + "stbir__simdf_0123to2301": { + "name": "stbir__simdf_0123to2301", + "value": "(out) = stbir__simdf_swiz( reg, 2,3,0,1 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2548, + "column": 1, + "source_line": "#define stbir__simdf_0123to2301( out, reg ) (out) = stbir__simdf_swiz( reg, 2,3,0,1 )" + } + }, + "stbir__simdf_0123to3012": { + "name": "stbir__simdf_0123to3012", + "value": "(out) = stbir__simdf_swiz( reg, 3,0,1,2 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2549, + "column": 1, + "source_line": "#define stbir__simdf_0123to3012( out, reg ) (out) = stbir__simdf_swiz( reg, 3,0,1,2 )" + } + }, + "stbir__simdf_0123to0011": { + "name": "stbir__simdf_0123to0011", + "value": "(out) = stbir__simdf_swiz( reg, 0,0,1,1 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2550, + "column": 1, + "source_line": "#define stbir__simdf_0123to0011( out, reg ) (out) = stbir__simdf_swiz( reg, 0,0,1,1 )" + } + }, + "stbir__simdf_0123to1100": { + "name": "stbir__simdf_0123to1100", + "value": "(out) = stbir__simdf_swiz( reg, 1,1,0,0 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2551, + "column": 1, + "source_line": "#define stbir__simdf_0123to1100( out, reg ) (out) = stbir__simdf_swiz( reg, 1,1,0,0 )" + } + }, + "stbir__simdf_0123to2233": { + "name": "stbir__simdf_0123to2233", + "value": "(out) = stbir__simdf_swiz( reg, 2,2,3,3 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2552, + "column": 1, + "source_line": "#define stbir__simdf_0123to2233( out, reg ) (out) = stbir__simdf_swiz( reg, 2,2,3,3 )" + } + }, + "stbir__simdf_0123to1133": { + "name": "stbir__simdf_0123to1133", + "value": "(out) = stbir__simdf_swiz( reg, 1,1,3,3 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2553, + "column": 1, + "source_line": "#define stbir__simdf_0123to1133( out, reg ) (out) = stbir__simdf_swiz( reg, 1,1,3,3 )" + } + }, + "stbir__simdf_0123to0022": { + "name": "stbir__simdf_0123to0022", + "value": "(out) = stbir__simdf_swiz( reg, 0,0,2,2 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2554, + "column": 1, + "source_line": "#define stbir__simdf_0123to0022( out, reg ) (out) = stbir__simdf_swiz( reg, 0,0,2,2 )" + } + }, + "stbir__simdf_0123to1032": { + "name": "stbir__simdf_0123to1032", + "value": "(out) = stbir__simdf_swiz( reg, 1,0,3,2 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2555, + "column": 1, + "source_line": "#define stbir__simdf_0123to1032( out, reg ) (out) = stbir__simdf_swiz( reg, 1,0,3,2 )" + } + }, + "STBIR_SIMD_STREAMOUT_PTR": { + "name": "STBIR_SIMD_STREAMOUT_PTR", + "value": "STBIR_STREAMOUT_PTR( star )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2719, + "column": 1, + "source_line": "#define STBIR_SIMD_STREAMOUT_PTR( star ) STBIR_STREAMOUT_PTR( star )" + } + }, + "STBIR_SIMD_NO_UNROLL": { + "name": "STBIR_SIMD_NO_UNROLL", + "value": null, + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2720, + "column": 1, + "source_line": "#define STBIR_SIMD_NO_UNROLL(ptr)" + } + }, + "STBIR_SIMD_NO_UNROLL_LOOP_START": { + "name": "STBIR_SIMD_NO_UNROLL_LOOP_START", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2721, + "column": 1, + "source_line": "#define STBIR_SIMD_NO_UNROLL_LOOP_START" + } + }, + "STBIR_SIMD_NO_UNROLL_LOOP_START_INF_FOR": { + "name": "STBIR_SIMD_NO_UNROLL_LOOP_START_INF_FOR", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2722, + "column": 1, + "source_line": "#define STBIR_SIMD_NO_UNROLL_LOOP_START_INF_FOR" + } + }, + "STBIR_MEMCPY": { + "name": "STBIR_MEMCPY", + "value": "memcpy( dest, src, len )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2832, + "column": 1, + "source_line": "#define STBIR_MEMCPY( dest, src, len ) memcpy( dest, src, len )" + } + }, + "STBIR_PROFILE_FUNC": { + "name": "STBIR_PROFILE_FUNC", + "value": "_ReadStatusReg(ARM64_CNTVCT)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2753, + "column": 3, + "source_line": " #define STBIR_PROFILE_FUNC() _ReadStatusReg(ARM64_CNTVCT)" + } + }, + "STBIR_ONLY_PROFILE_GET_SPLIT_INFO": { + "name": "STBIR_ONLY_PROFILE_GET_SPLIT_INFO", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2800, + "column": 1, + "source_line": "#define STBIR_ONLY_PROFILE_GET_SPLIT_INFO" + } + }, + "STBIR_ONLY_PROFILE_SET_SPLIT_INFO": { + "name": "STBIR_ONLY_PROFILE_SET_SPLIT_INFO", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2801, + "column": 1, + "source_line": "#define STBIR_ONLY_PROFILE_SET_SPLIT_INFO" + } + }, + "STBIR_ONLY_PROFILE_BUILD_GET_INFO": { + "name": "STBIR_ONLY_PROFILE_BUILD_GET_INFO", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2803, + "column": 1, + "source_line": "#define STBIR_ONLY_PROFILE_BUILD_GET_INFO" + } + }, + "STBIR_ONLY_PROFILE_BUILD_SET_INFO": { + "name": "STBIR_ONLY_PROFILE_BUILD_SET_INFO", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2804, + "column": 1, + "source_line": "#define STBIR_ONLY_PROFILE_BUILD_SET_INFO" + } + }, + "STBIR_PROFILE_START_ll": { + "name": "STBIR_PROFILE_START_ll", + "value": "{ stbir_uint64 wh##thiszonetime = STBIR_PROFILE_FUNC(); stbir_uint64 * wh##save_parent_excluded_ptr = info->current_zone_excluded_ptr; stbir_uint64 wh##current_zone_excluded = 0; info->current_zone_excluded_ptr = &wh##current_zone_excluded;", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2781, + "column": 1, + "source_line": "#define STBIR_PROFILE_START_ll( info, wh ) { stbir_uint64 wh##thiszonetime = STBIR_PROFILE_FUNC(); stbir_uint64 * wh##save_parent_excluded_ptr = info->current_zone_excluded_ptr; stbir_uint64 wh##current_zone_excluded = 0; info->current_zone_excluded_ptr = &wh##current_zone_excluded;" + } + }, + "STBIR_PROFILE_END_ll": { + "name": "STBIR_PROFILE_END_ll", + "value": "wh##thiszonetime = STBIR_PROFILE_FUNC() - wh##thiszonetime; info->profile.named.wh += wh##thiszonetime - wh##current_zone_excluded; *wh##save_parent_excluded_ptr += wh##thiszonetime; info->current_zone_excluded_ptr = wh##save_parent_excluded_ptr; }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2782, + "column": 1, + "source_line": "#define STBIR_PROFILE_END_ll( info, wh ) wh##thiszonetime = STBIR_PROFILE_FUNC() - wh##thiszonetime; info->profile.named.wh += wh##thiszonetime - wh##current_zone_excluded; *wh##save_parent_excluded_ptr += wh##thiszonetime; info->current_zone_excluded_ptr = wh##save_parent_excluded_ptr; }" + } + }, + "STBIR_PROFILE_FIRST_START_ll": { + "name": "STBIR_PROFILE_FIRST_START_ll", + "value": "{ int i; info->current_zone_excluded_ptr = &info->profile.named.total; for(i=0;iprofile.array);i++) info->profile.array[i]=0; } STBIR_PROFILE_START_ll( info, wh );", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2783, + "column": 1, + "source_line": "#define STBIR_PROFILE_FIRST_START_ll( info, wh ) { int i; info->current_zone_excluded_ptr = &info->profile.named.total; for(i=0;iprofile.array);i++) info->profile.array[i]=0; } STBIR_PROFILE_START_ll( info, wh );" + } + }, + "STBIR_PROFILE_CLEAR_EXTRAS_ll": { + "name": "STBIR_PROFILE_CLEAR_EXTRAS_ll", + "value": "{ int extra; for(extra=1;extra<(num);extra++) { int i; for(i=0;iprofile.array);i++) (info)[extra].profile.array[i]=0; } }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2784, + "column": 1, + "source_line": "#define STBIR_PROFILE_CLEAR_EXTRAS_ll( info, num ) { int extra; for(extra=1;extra<(num);extra++) { int i; for(i=0;iprofile.array);i++) (info)[extra].profile.array[i]=0; } }" + } + }, + "STBIR_PROFILE_START": { + "name": "STBIR_PROFILE_START", + "value": null, + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2806, + "column": 1, + "source_line": "#define STBIR_PROFILE_START( wh )" + } + }, + "STBIR_PROFILE_END": { + "name": "STBIR_PROFILE_END", + "value": null, + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2807, + "column": 1, + "source_line": "#define STBIR_PROFILE_END( wh )" + } + }, + "STBIR_PROFILE_FIRST_START": { + "name": "STBIR_PROFILE_FIRST_START", + "value": null, + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2808, + "column": 1, + "source_line": "#define STBIR_PROFILE_FIRST_START( wh )" + } + }, + "STBIR_PROFILE_CLEAR_EXTRAS": { + "name": "STBIR_PROFILE_CLEAR_EXTRAS", + "value": null, + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2809, + "column": 1, + "source_line": "#define STBIR_PROFILE_CLEAR_EXTRAS( )" + } + }, + "STBIR_PROFILE_BUILD_START": { + "name": "STBIR_PROFILE_BUILD_START", + "value": null, + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2811, + "column": 1, + "source_line": "#define STBIR_PROFILE_BUILD_START( wh )" + } + }, + "STBIR_PROFILE_BUILD_END": { + "name": "STBIR_PROFILE_BUILD_END", + "value": null, + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2812, + "column": 1, + "source_line": "#define STBIR_PROFILE_BUILD_END( wh )" + } + }, + "STBIR_PROFILE_BUILD_FIRST_START": { + "name": "STBIR_PROFILE_BUILD_FIRST_START", + "value": null, + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2813, + "column": 1, + "source_line": "#define STBIR_PROFILE_BUILD_FIRST_START( wh )" + } + }, + "STBIR_PROFILE_BUILD_CLEAR": { + "name": "STBIR_PROFILE_BUILD_CLEAR", + "value": null, + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2814, + "column": 1, + "source_line": "#define STBIR_PROFILE_BUILD_CLEAR( info )" + } + }, + "STBIR__MERGE_RUNS_PIXEL_THRESHOLD": { + "name": "STBIR__MERGE_RUNS_PIXEL_THRESHOLD", + "value": "16", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 3118, + "column": 1, + "source_line": "#define STBIR__MERGE_RUNS_PIXEL_THRESHOLD 16" + } + }, + "STBIR_RENORM_TYPE": { + "name": "STBIR_RENORM_TYPE", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 3694, + "column": 1, + "source_line": "#undef STBIR_RENORM_TYPE " + } + }, + "STBIR_MOVE_1": { + "name": "STBIR_MOVE_1", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 3926, + "column": 3, + "source_line": " #undef STBIR_MOVE_1" + } + }, + "STBIR_MOVE_2": { + "name": "STBIR_MOVE_2", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 3927, + "column": 3, + "source_line": " #undef STBIR_MOVE_2" + } + }, + "STBIR_MOVE_4": { + "name": "STBIR_MOVE_4", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 3928, + "column": 3, + "source_line": " #undef STBIR_MOVE_4" + } + }, + "stbir__coder_min_num": { + "name": "stbir__coder_min_num", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9887, + "column": 1, + "source_line": "#undef stbir__coder_min_num" + } + }, + "STB_IMAGE_RESIZE_DO_CODERS": { + "name": "STB_IMAGE_RESIZE_DO_CODERS", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9891, + "column": 1, + "source_line": "#undef STB_IMAGE_RESIZE_DO_CODERS" + } + }, + "stbir__decode_suffix": { + "name": "stbir__decode_suffix", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9872, + "column": 1, + "source_line": "#undef stbir__decode_suffix" + } + }, + "stbir__decode_swizzle": { + "name": "stbir__decode_swizzle", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9888, + "column": 1, + "source_line": "#undef stbir__decode_swizzle" + } + }, + "stbir__decode_order0": { + "name": "stbir__decode_order0", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9875, + "column": 1, + "source_line": "#undef stbir__decode_order0" + } + }, + "stbir__decode_order1": { + "name": "stbir__decode_order1", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9876, + "column": 1, + "source_line": "#undef stbir__decode_order1" + } + }, + "stbir__decode_order2": { + "name": "stbir__decode_order2", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9877, + "column": 1, + "source_line": "#undef stbir__decode_order2" + } + }, + "stbir__decode_order3": { + "name": "stbir__decode_order3", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9878, + "column": 1, + "source_line": "#undef stbir__decode_order3" + } + }, + "stbir__encode_order0": { + "name": "stbir__encode_order0", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9879, + "column": 1, + "source_line": "#undef stbir__encode_order0" + } + }, + "stbir__encode_order1": { + "name": "stbir__encode_order1", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9880, + "column": 1, + "source_line": "#undef stbir__encode_order1" + } + }, + "stbir__encode_order2": { + "name": "stbir__encode_order2", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9881, + "column": 1, + "source_line": "#undef stbir__encode_order2" + } + }, + "stbir__encode_order3": { + "name": "stbir__encode_order3", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9882, + "column": 1, + "source_line": "#undef stbir__encode_order3" + } + }, + "stbir__1_coeff_only": { + "name": "stbir__1_coeff_only", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10619, + "column": 1, + "source_line": "#undef stbir__1_coeff_only" + } + }, + "stbir__2_coeff_only": { + "name": "stbir__2_coeff_only", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10621, + "column": 1, + "source_line": "#undef stbir__2_coeff_only" + } + }, + "stbir__3_coeff_only": { + "name": "stbir__3_coeff_only", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10623, + "column": 1, + "source_line": "#undef stbir__3_coeff_only" + } + }, + "stbir__store_output_tiny": { + "name": "stbir__store_output_tiny", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10629, + "column": 1, + "source_line": "#undef stbir__store_output_tiny" + } + }, + "stbir__4_coeff_start": { + "name": "stbir__4_coeff_start", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10626, + "column": 1, + "source_line": "#undef stbir__4_coeff_start" + } + }, + "stbir__4_coeff_continue_from_4": { + "name": "stbir__4_coeff_continue_from_4", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10627, + "column": 1, + "source_line": "#undef stbir__4_coeff_continue_from_4" + } + }, + "stbir__1_coeff_remnant": { + "name": "stbir__1_coeff_remnant", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10620, + "column": 1, + "source_line": "#undef stbir__1_coeff_remnant" + } + }, + "stbir__2_coeff_remnant": { + "name": "stbir__2_coeff_remnant", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10622, + "column": 1, + "source_line": "#undef stbir__2_coeff_remnant" + } + }, + "stbir__3_coeff_setup": { + "name": "stbir__3_coeff_setup", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10625, + "column": 1, + "source_line": "#undef stbir__3_coeff_setup" + } + }, + "stbir__3_coeff_remnant": { + "name": "stbir__3_coeff_remnant", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10624, + "column": 1, + "source_line": "#undef stbir__3_coeff_remnant" + } + }, + "stbir__store_output": { + "name": "stbir__store_output", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10628, + "column": 1, + "source_line": "#undef stbir__store_output" + } + }, + "STBIR__horizontal_channels": { + "name": "STBIR__horizontal_channels", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10617, + "column": 1, + "source_line": "#undef STBIR__horizontal_channels" + } + }, + "STB_IMAGE_RESIZE_DO_HORIZONTALS": { + "name": "STB_IMAGE_RESIZE_DO_HORIZONTALS", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10618, + "column": 1, + "source_line": "#undef STB_IMAGE_RESIZE_DO_HORIZONTALS" + } + }, + "STBIR__vertical_channels": { + "name": "STBIR__vertical_channels", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10271, + "column": 1, + "source_line": "#undef STBIR__vertical_channels" + } + }, + "STB_IMAGE_RESIZE_DO_VERTICALS": { + "name": "STB_IMAGE_RESIZE_DO_VERTICALS", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10270, + "column": 1, + "source_line": "#undef STB_IMAGE_RESIZE_DO_VERTICALS" + } + }, + "STB_IMAGE_RESIZE_VERTICAL_CONTINUE": { + "name": "STB_IMAGE_RESIZE_VERTICAL_CONTINUE", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10277, + "column": 1, + "source_line": "#undef STB_IMAGE_RESIZE_VERTICAL_CONTINUE" + } + }, + "STBIR__FLOAT_EMPTY_MARKER": { + "name": "STBIR__FLOAT_EMPTY_MARKER", + "value": "3.0e+38F", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6371, + "column": 1, + "source_line": "#define STBIR__FLOAT_EMPTY_MARKER 3.0e+38F" + } + }, + "STBIR__FLOAT_BUFFER_IS_EMPTY": { + "name": "STBIR__FLOAT_BUFFER_IS_EMPTY", + "value": "((ptr)[0]==STBIR__FLOAT_EMPTY_MARKER)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6372, + "column": 1, + "source_line": "#define STBIR__FLOAT_BUFFER_IS_EMPTY(ptr) ((ptr)[0]==STBIR__FLOAT_EMPTY_MARKER)" + } + }, + "STBIR__FREE_AND_CLEAR": { + "name": "STBIR__FREE_AND_CLEAR", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6865, + "column": 3, + "source_line": " #undef STBIR__FREE_AND_CLEAR" + } + }, + "STBIR_RESIZE_CLASSIFICATIONS": { + "name": "STBIR_RESIZE_CLASSIFICATIONS", + "value": "8", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6894, + "column": 1, + "source_line": "#define STBIR_RESIZE_CLASSIFICATIONS 8" + } + }, + "STBIR__V_FIRST_INFO_POINTER": { + "name": "STBIR__V_FIRST_INFO_POINTER", + "value": "0", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 6960, + "column": 1, + "source_line": "#define STBIR__V_FIRST_INFO_POINTER 0" + } + }, + "STBIR__NEXT_PTR": { + "name": "STBIR__NEXT_PTR", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 7364, + "column": 5, + "source_line": " #undef STBIR__NEXT_PTR" + } + }, + "STBIR_RETURN_ERROR_AND_ASSERT": { + "name": "STBIR_RETURN_ERROR_AND_ASSERT", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 7894, + "column": 3, + "source_line": " #undef STBIR_RETURN_ERROR_AND_ASSERT" + } + }, + "STBIR_strs_join2": { + "name": "STBIR_strs_join2", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10634, + "column": 1, + "source_line": "#undef STBIR_strs_join2" + } + }, + "STBIR_strs_join1": { + "name": "STBIR_strs_join1", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10635, + "column": 1, + "source_line": "#undef STBIR_strs_join1" + } + }, + "STBIR_strs_join24": { + "name": "STBIR_strs_join24", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10273, + "column": 1, + "source_line": "#undef STBIR_strs_join24" + } + }, + "STBIR_strs_join14": { + "name": "STBIR_strs_join14", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10274, + "column": 1, + "source_line": "#undef STBIR_strs_join14" + } + }, + "STBIR__CODER_NAME": { + "name": "STBIR__CODER_NAME", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9886, + "column": 1, + "source_line": "#undef STBIR__CODER_NAME" + } + }, + "stbir__decode_simdf8_flip": { + "name": "stbir__decode_simdf8_flip", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9873, + "column": 1, + "source_line": "#undef stbir__decode_simdf8_flip" + } + }, + "stbir__decode_simdf4_flip": { + "name": "stbir__decode_simdf4_flip", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9874, + "column": 1, + "source_line": "#undef stbir__decode_simdf4_flip" + } + }, + "stbir__encode_simdf8_unflip": { + "name": "stbir__encode_simdf8_unflip", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9883, + "column": 1, + "source_line": "#undef stbir__encode_simdf8_unflip" + } + }, + "stbir__encode_simdf4_unflip": { + "name": "stbir__encode_simdf4_unflip", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9884, + "column": 1, + "source_line": "#undef stbir__encode_simdf4_unflip" + } + }, + "stbir__encode_simdfX_unflip": { + "name": "stbir__encode_simdfX_unflip", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9885, + "column": 1, + "source_line": "#undef stbir__encode_simdfX_unflip" + } + }, + "stbir__min_max_shift20": { + "name": "stbir__min_max_shift20", + "value": "stbir__simdf_max( f, f, stbir_simdf_casti(STBIR__CONSTI( STBIR_almost_zero )) ); stbir__simdf_min( f, f, stbir_simdf_casti(STBIR__CONSTI( STBIR_almost_one )) ); stbir__simdi_32shr( i, stbir_simdi_castf( f ), 20 );", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8747, + "column": 1, + "source_line": "#define stbir__min_max_shift20( i, f ) \\" + } + }, + "stbir__scale_and_convert": { + "name": "stbir__scale_and_convert", + "value": "stbir__simdf_madd( f, STBIR__CONSTF( STBIR_simd_point5 ), STBIR__CONSTF( STBIR_max_uint8_as_float ), f ); stbir__simdf_max( f, f, stbir__simdf_zeroP() ); stbir__simdf_min( f, f, STBIR__CONSTF( STBIR_max_uint8_as_float ) ); stbir__simdf_convert_float_to_i32( i, f );", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8752, + "column": 1, + "source_line": "#define stbir__scale_and_convert( i, f ) \\" + } + }, + "stbir__linear_to_srgb_finish": { + "name": "stbir__linear_to_srgb_finish", + "value": "{ stbir__simdi temp; stbir__simdi_32shr( temp, stbir_simdi_castf( f ), 12 ) ; stbir__simdi_and( temp, temp, STBIR__CONSTI(STBIR_mantissa_mask) ); stbir__simdi_or( temp, temp, STBIR__CONSTI(STBIR_topscale) ); stbir__simdi_16madd( i, i, temp ); stbir__simdi_32shr( i, i, 16 ); }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8758, + "column": 1, + "source_line": "#define stbir__linear_to_srgb_finish( i, f ) \\" + } + }, + "stbir__simdi_table_lookup2": { + "name": "stbir__simdi_table_lookup2", + "value": "{ stbir__simdi_u32 temp0,temp1; temp0.m128i_i128 = v0; temp1.m128i_i128 = v1; temp0.m128i_u32[0] = table[temp0.m128i_i32[0]]; temp0.m128i_u32[1] = table[temp0.m128i_i32[1]]; temp0.m128i_u32[2] = table[temp0.m128i_i32[2]]; temp0.m128i_u32[3] = table[temp0.m128i_i32[3]]; temp1.m128i_u32[0] = table[temp1.m128i_i32[0]]; temp1.m128i_u32[1] = table[temp1.m128i_i32[1]]; temp1.m128i_u32[2] = table[temp1.m128i_i32[2]]; temp1.m128i_u32[3] = table[temp1.m128i_i32[3]]; v0 = temp0.m128i_i128; v1 = temp1.m128i_i128; }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8768, + "column": 1, + "source_line": "#define stbir__simdi_table_lookup2( v0,v1, table ) \\" + } + }, + "stbir__simdi_table_lookup3": { + "name": "stbir__simdi_table_lookup3", + "value": "{ stbir__simdi_u32 temp0,temp1,temp2; temp0.m128i_i128 = v0; temp1.m128i_i128 = v1; temp2.m128i_i128 = v2; temp0.m128i_u32[0] = table[temp0.m128i_i32[0]]; temp0.m128i_u32[1] = table[temp0.m128i_i32[1]]; temp0.m128i_u32[2] = table[temp0.m128i_i32[2]]; temp0.m128i_u32[3] = table[temp0.m128i_i32[3]]; temp1.m128i_u32[0] = table[temp1.m128i_i32[0]]; temp1.m128i_u32[1] = table[temp1.m128i_i32[1]]; temp1.m128i_u32[2] = table[temp1.m128i_i32[2]]; temp1.m128i_u32[3] = table[temp1.m128i_i32[3]]; temp2.m128i_u32[0] = table[temp2.m128i_i32[0]]; temp2.m128i_u32[1] = table[temp2.m128i_i32[1]]; temp2.m128i_u32[2] = table[temp2.m128i_i32[2]]; temp2.m128i_u32[3] = table[temp2.m128i_i32[3]]; v0 = temp0.m128i_i128; v1 = temp1.m128i_i128; v2 = temp2.m128i_i128; }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8779, + "column": 1, + "source_line": "#define stbir__simdi_table_lookup3( v0,v1,v2, table ) \\" + } + }, + "stbir__simdi_table_lookup4": { + "name": "stbir__simdi_table_lookup4", + "value": "{ stbir__simdi_u32 temp0,temp1,temp2,temp3; temp0.m128i_i128 = v0; temp1.m128i_i128 = v1; temp2.m128i_i128 = v2; temp3.m128i_i128 = v3; temp0.m128i_u32[0] = table[temp0.m128i_i32[0]]; temp0.m128i_u32[1] = table[temp0.m128i_i32[1]]; temp0.m128i_u32[2] = table[temp0.m128i_i32[2]]; temp0.m128i_u32[3] = table[temp0.m128i_i32[3]]; temp1.m128i_u32[0] = table[temp1.m128i_i32[0]]; temp1.m128i_u32[1] = table[temp1.m128i_i32[1]]; temp1.m128i_u32[2] = table[temp1.m128i_i32[2]]; temp1.m128i_u32[3] = table[temp1.m128i_i32[3]]; temp2.m128i_u32[0] = table[temp2.m128i_i32[0]]; temp2.m128i_u32[1] = table[temp2.m128i_i32[1]]; temp2.m128i_u32[2] = table[temp2.m128i_i32[2]]; temp2.m128i_u32[3] = table[temp2.m128i_i32[3]]; temp3.m128i_u32[0] = table[temp3.m128i_i32[0]]; temp3.m128i_u32[1] = table[temp3.m128i_i32[1]]; temp3.m128i_u32[2] = table[temp3.m128i_i32[2]]; temp3.m128i_u32[3] = table[temp3.m128i_i32[3]]; v0 = temp0.m128i_i128; v1 = temp1.m128i_i128; v2 = temp2.m128i_i128; v3 = temp3.m128i_i128; }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 8793, + "column": 1, + "source_line": "#define stbir__simdi_table_lookup4( v0,v1,v2,v3, table ) \\" + } + }, + "stbir_scalar_hi_clamp": { + "name": "stbir_scalar_hi_clamp", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9889, + "column": 1, + "source_line": "#undef stbir_scalar_hi_clamp" + } + }, + "stbir_scalar_lo_clamp": { + "name": "stbir_scalar_lo_clamp", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 9890, + "column": 1, + "source_line": "#undef stbir_scalar_lo_clamp" + } + }, + "STBIR_chans": { + "name": "STBIR_chans", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10630, + "column": 1, + "source_line": "#undef STBIR_chans" + } + }, + "stbIF0": { + "name": "stbIF0", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10262, + "column": 1, + "source_line": "#undef stbIF0" + } + }, + "stbIF1": { + "name": "stbIF1", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10263, + "column": 1, + "source_line": "#undef stbIF1" + } + }, + "stbIF2": { + "name": "stbIF2", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10264, + "column": 1, + "source_line": "#undef stbIF2" + } + }, + "stbIF3": { + "name": "stbIF3", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10265, + "column": 1, + "source_line": "#undef stbIF3" + } + }, + "stbIF4": { + "name": "stbIF4", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10266, + "column": 1, + "source_line": "#undef stbIF4" + } + }, + "stbIF5": { + "name": "stbIF5", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10267, + "column": 1, + "source_line": "#undef stbIF5" + } + }, + "stbIF6": { + "name": "stbIF6", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10268, + "column": 1, + "source_line": "#undef stbIF6" + } + }, + "stbIF7": { + "name": "stbIF7", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 10269, + "column": 1, + "source_line": "#undef stbIF7" + } + } + }, + "includes": { + "stb/stb_image_resize2.h:stddef.h": { + "target": "stddef.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 391, + "column": 1, + "source_line": "#include " + } + }, + "stb/stb_image_resize2.h:stdint.h": { + "target": "stdint.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 398, + "column": 1, + "source_line": "#include " + } + }, + "stb/stb_image_resize2.h:assert.h": { + "target": "assert.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 786, + "column": 1, + "source_line": "#include " + } + }, + "stb/stb_image_resize2.h:stdlib.h": { + "target": "stdlib.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 791, + "column": 1, + "source_line": "#include " + } + }, + "stb/stb_image_resize2.h:emmintrin.h": { + "target": "emmintrin.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1306, + "column": 3, + "source_line": " #include " + } + }, + "stb/stb_image_resize2.h:immintrin.h": { + "target": "immintrin.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2299, + "column": 3, + "source_line": " #include " + } + }, + "stb/stb_image_resize2.h:smmintrin.h": { + "target": "smmintrin.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1478, + "column": 5, + "source_line": " #include " + } + }, + "stb/stb_image_resize2.h:arm_neon.h": { + "target": "arm_neon.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1711, + "column": 3, + "source_line": " #include " + } + }, + "stb/stb_image_resize2.h:wasm_simd128.h": { + "target": "wasm_simd128.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 1976, + "column": 3, + "source_line": " #include " + } + }, + "stb/stb_image_resize2.h:math.h": { + "target": "math.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2819, + "column": 1, + "source_line": "#include " + } + }, + "stb/stb_image_resize2.h:string.h": { + "target": "string.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 2831, + "column": 1, + "source_line": "#include " + } + } + }, + "functions_by_file": { + "stb/stb_image_resize2.h": [ + "stbir_simd_memcpy", + "stbir_overlapping_memcpy", + "stbir__filter_trapezoid", + "stbir__support_trapezoid", + "stbir__filter_triangle", + "stbir__filter_point", + "stbir__filter_cubic", + "stbir__filter_catmullrom", + "stbir__filter_mitchell", + "stbir__support_zeropoint5", + "stbir__support_one", + "stbir__support_two", + "stbir__get_filter_pixel_width", + "stbir__get_coefficient_width", + "stbir__get_contributors", + "stbir__edge_zero_full", + "stbir__edge_clamp_full", + "stbir__edge_reflect_full", + "stbir__edge_wrap_full", + "stbir__get_extents", + "stbir__calculate_in_pixel_range", + "stbir__calculate_coefficients_for_gather_upsample", + "stbir__insert_coeff", + "stbir__calculate_out_pixel_range", + "stbir__calculate_coefficients_for_gather_downsample", + "stbir__cleanup_gathered_coefficients", + "stbir__pack_coefficients", + "stbir__fancy_alpha_weight_4ch", + "stbir__fancy_alpha_weight_2ch", + "stbir__fancy_alpha_unweight_4ch", + "stbir__fancy_alpha_unweight_2ch", + "stbir__simple_alpha_weight_4ch", + "stbir__simple_alpha_weight_2ch", + "stbir__simple_alpha_unweight_4ch", + "stbir__simple_alpha_unweight_2ch", + "stbir__simple_flip_3ch", + "stbir__get_ring_buffer_entry", + "stbir__get_ring_buffer_scanline", + "stbir__resample_vertical_gather", + "stbir__decode_and_resample_for_vertical_gather_loop", + "stbir__vertical_gather_loop", + "stbir__encode_first_scanline_from_scatter", + "stbir__horizontal_resample_and_encode_first_scanline_from_scatter", + "stbir__resample_vertical_scatter", + "stbir__vertical_scatter_loop", + "stbir__set_sampler", + "stbir__get_conservative_extents", + "stbir__get_split_info", + "stbir__free_internal_mem", + "stbir__get_max_split", + "stbir__should_do_vertical_first", + "stbir__perform_resize", + "stbir__update_info_from_resize", + "stbir__clip", + "stbir__double_to_rational", + "stbir__calculate_region_transform", + "stbir__init_and_set_layout", + "stbir__perform_build", + "stbir_quick_resize_helper" + ] + }, + "enum_constants": { + "STBIR_1CHANNEL": { + "name": "STBIR_1CHANNEL", + "value": "1", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 435, + "column": 1, + "source_line": "typedef enum" + } + }, + "STBIR_2CHANNEL": { + "name": "STBIR_2CHANNEL", + "value": "2", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 435, + "column": 1, + "source_line": "typedef enum" + } + }, + "STBIR_RGB": { + "name": "STBIR_RGB", + "value": "3", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 435, + "column": 1, + "source_line": "typedef enum" + } + }, + "STBIR_BGR": { + "name": "STBIR_BGR", + "value": "0", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 435, + "column": 1, + "source_line": "typedef enum" + } + }, + "STBIR_4CHANNEL": { + "name": "STBIR_4CHANNEL", + "value": "5", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 435, + "column": 1, + "source_line": "typedef enum" + } + }, + "STBIR_RGBA": { + "name": "STBIR_RGBA", + "value": "4", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 435, + "column": 1, + "source_line": "typedef enum" + } + }, + "STBIR_BGRA": { + "name": "STBIR_BGRA", + "value": "6", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 435, + "column": 1, + "source_line": "typedef enum" + } + }, + "STBIR_ARGB": { + "name": "STBIR_ARGB", + "value": "7", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 435, + "column": 1, + "source_line": "typedef enum" + } + }, + "STBIR_ABGR": { + "name": "STBIR_ABGR", + "value": "8", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 435, + "column": 1, + "source_line": "typedef enum" + } + }, + "STBIR_RA": { + "name": "STBIR_RA", + "value": "9", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 435, + "column": 1, + "source_line": "typedef enum" + } + }, + "STBIR_AR": { + "name": "STBIR_AR", + "value": "10", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 435, + "column": 1, + "source_line": "typedef enum" + } + }, + "STBIR_RGBA_PM": { + "name": "STBIR_RGBA_PM", + "value": "11", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 435, + "column": 1, + "source_line": "typedef enum" + } + }, + "STBIR_BGRA_PM": { + "name": "STBIR_BGRA_PM", + "value": "12", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 435, + "column": 1, + "source_line": "typedef enum" + } + }, + "STBIR_ARGB_PM": { + "name": "STBIR_ARGB_PM", + "value": "13", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 435, + "column": 1, + "source_line": "typedef enum" + } + }, + "STBIR_ABGR_PM": { + "name": "STBIR_ABGR_PM", + "value": "14", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 435, + "column": 1, + "source_line": "typedef enum" + } + }, + "STBIR_RA_PM": { + "name": "STBIR_RA_PM", + "value": "15", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 435, + "column": 1, + "source_line": "typedef enum" + } + }, + "STBIR_AR_PM": { + "name": "STBIR_AR_PM", + "value": "16", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 435, + "column": 1, + "source_line": "typedef enum" + } + }, + "STBIR_RGBA_NO_AW": { + "name": "STBIR_RGBA_NO_AW", + "value": "11", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 435, + "column": 1, + "source_line": "typedef enum" + } + }, + "STBIR_BGRA_NO_AW": { + "name": "STBIR_BGRA_NO_AW", + "value": "12", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 435, + "column": 1, + "source_line": "typedef enum" + } + }, + "STBIR_ARGB_NO_AW": { + "name": "STBIR_ARGB_NO_AW", + "value": "13", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 435, + "column": 1, + "source_line": "typedef enum" + } + }, + "STBIR_ABGR_NO_AW": { + "name": "STBIR_ABGR_NO_AW", + "value": "14", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 435, + "column": 1, + "source_line": "typedef enum" + } + }, + "STBIR_RA_NO_AW": { + "name": "STBIR_RA_NO_AW", + "value": "15", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 435, + "column": 1, + "source_line": "typedef enum" + } + }, + "STBIR_AR_NO_AW": { + "name": "STBIR_AR_NO_AW", + "value": "16", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 435, + "column": 1, + "source_line": "typedef enum" + } + }, + "STBIR_EDGE_CLAMP": { + "name": "STBIR_EDGE_CLAMP", + "value": "0", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 495, + "column": 1, + "source_line": "typedef enum" + } + }, + "STBIR_EDGE_REFLECT": { + "name": "STBIR_EDGE_REFLECT", + "value": "1", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 495, + "column": 1, + "source_line": "typedef enum" + } + }, + "STBIR_EDGE_WRAP": { + "name": "STBIR_EDGE_WRAP", + "value": "2", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 495, + "column": 1, + "source_line": "typedef enum" + } + }, + "STBIR_EDGE_ZERO": { + "name": "STBIR_EDGE_ZERO", + "value": "3", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 495, + "column": 1, + "source_line": "typedef enum" + } + }, + "STBIR_FILTER_DEFAULT": { + "name": "STBIR_FILTER_DEFAULT", + "value": "0", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 503, + "column": 1, + "source_line": "typedef enum" + } + }, + "STBIR_FILTER_BOX": { + "name": "STBIR_FILTER_BOX", + "value": "1", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 503, + "column": 1, + "source_line": "typedef enum" + } + }, + "STBIR_FILTER_TRIANGLE": { + "name": "STBIR_FILTER_TRIANGLE", + "value": "2", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 503, + "column": 1, + "source_line": "typedef enum" + } + }, + "STBIR_FILTER_CUBICBSPLINE": { + "name": "STBIR_FILTER_CUBICBSPLINE", + "value": "3", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 503, + "column": 1, + "source_line": "typedef enum" + } + }, + "STBIR_FILTER_CATMULLROM": { + "name": "STBIR_FILTER_CATMULLROM", + "value": "4", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 503, + "column": 1, + "source_line": "typedef enum" + } + }, + "STBIR_FILTER_MITCHELL": { + "name": "STBIR_FILTER_MITCHELL", + "value": "5", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 503, + "column": 1, + "source_line": "typedef enum" + } + }, + "STBIR_FILTER_POINT_SAMPLE": { + "name": "STBIR_FILTER_POINT_SAMPLE", + "value": "6", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 503, + "column": 1, + "source_line": "typedef enum" + } + }, + "STBIR_FILTER_OTHER": { + "name": "STBIR_FILTER_OTHER", + "value": "7", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 503, + "column": 1, + "source_line": "typedef enum" + } + }, + "STBIR_TYPE_UINT8": { + "name": "STBIR_TYPE_UINT8", + "value": "0", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 515, + "column": 1, + "source_line": "typedef enum" + } + }, + "STBIR_TYPE_UINT8_SRGB": { + "name": "STBIR_TYPE_UINT8_SRGB", + "value": "1", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 515, + "column": 1, + "source_line": "typedef enum" + } + }, + "STBIR_TYPE_UINT8_SRGB_ALPHA": { + "name": "STBIR_TYPE_UINT8_SRGB_ALPHA", + "value": "2", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 515, + "column": 1, + "source_line": "typedef enum" + } + }, + "STBIR_TYPE_UINT16": { + "name": "STBIR_TYPE_UINT16", + "value": "3", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 515, + "column": 1, + "source_line": "typedef enum" + } + }, + "STBIR_TYPE_FLOAT": { + "name": "STBIR_TYPE_FLOAT", + "value": "4", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 515, + "column": 1, + "source_line": "typedef enum" + } + }, + "STBIR_TYPE_HALF_FLOAT": { + "name": "STBIR_TYPE_HALF_FLOAT", + "value": "5", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 515, + "column": 1, + "source_line": "typedef enum" + } + }, + "STBIRI_1CHANNEL": { + "name": "STBIRI_1CHANNEL", + "value": "0", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 861, + "column": 1, + "source_line": "typedef enum" + } + }, + "STBIRI_2CHANNEL": { + "name": "STBIRI_2CHANNEL", + "value": "1", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 861, + "column": 1, + "source_line": "typedef enum" + } + }, + "STBIRI_RGB": { + "name": "STBIRI_RGB", + "value": "2", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 861, + "column": 1, + "source_line": "typedef enum" + } + }, + "STBIRI_BGR": { + "name": "STBIRI_BGR", + "value": "3", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 861, + "column": 1, + "source_line": "typedef enum" + } + }, + "STBIRI_4CHANNEL": { + "name": "STBIRI_4CHANNEL", + "value": "4", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 861, + "column": 1, + "source_line": "typedef enum" + } + }, + "STBIRI_RGBA": { + "name": "STBIRI_RGBA", + "value": "5", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 861, + "column": 1, + "source_line": "typedef enum" + } + }, + "STBIRI_BGRA": { + "name": "STBIRI_BGRA", + "value": "6", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 861, + "column": 1, + "source_line": "typedef enum" + } + }, + "STBIRI_ARGB": { + "name": "STBIRI_ARGB", + "value": "7", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 861, + "column": 1, + "source_line": "typedef enum" + } + }, + "STBIRI_ABGR": { + "name": "STBIRI_ABGR", + "value": "8", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 861, + "column": 1, + "source_line": "typedef enum" + } + }, + "STBIRI_RA": { + "name": "STBIRI_RA", + "value": "9", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 861, + "column": 1, + "source_line": "typedef enum" + } + }, + "STBIRI_AR": { + "name": "STBIRI_AR", + "value": "10", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 861, + "column": 1, + "source_line": "typedef enum" + } + }, + "STBIRI_RGBA_PM": { + "name": "STBIRI_RGBA_PM", + "value": "11", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 861, + "column": 1, + "source_line": "typedef enum" + } + }, + "STBIRI_BGRA_PM": { + "name": "STBIRI_BGRA_PM", + "value": "12", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 861, + "column": 1, + "source_line": "typedef enum" + } + }, + "STBIRI_ARGB_PM": { + "name": "STBIRI_ARGB_PM", + "value": "13", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 861, + "column": 1, + "source_line": "typedef enum" + } + }, + "STBIRI_ABGR_PM": { + "name": "STBIRI_ABGR_PM", + "value": "14", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 861, + "column": 1, + "source_line": "typedef enum" + } + }, + "STBIRI_RA_PM": { + "name": "STBIRI_RA_PM", + "value": "15", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 861, + "column": 1, + "source_line": "typedef enum" + } + }, + "STBIRI_AR_PM": { + "name": "STBIRI_AR_PM", + "value": "16", + "source_location": { + "filename": "stb/stb_image_resize2.h", + "line": 861, + "column": 1, + "source_line": "typedef enum" + } + } + }, + "include_graph": { + "stb/stb_image_resize2.h": [] + }, + "system_includes": { + "stb/stb_image_resize2.h": [ + "arm_neon.h", + "assert.h", + "emmintrin.h", + "immintrin.h", + "math.h", + "smmintrin.h", + "stddef.h", + "stdint.h", + "stdlib.h", + "string.h", + "wasm_simd128.h" + ] + }, + "unresolved_includes": { + "stb/stb_image_resize2.h": [] + }, + "header_source_pairs": { + "stb/stb_image_resize2.h": [] + }, + "diagnostics": [ + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_ASSERT' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 787, + "column": 1, + "source_line": "#define STBIR_ASSERT(x) assert(x)" + }, + "unit_kind": "macro", + "unit_name": "STBIR_ASSERT" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_MALLOC' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 792, + "column": 1, + "source_line": "#define STBIR_MALLOC(size,user_data) ((void)(user_data), malloc(size))" + }, + "unit_kind": "macro", + "unit_name": "STBIR_MALLOC" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_FREE' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 793, + "column": 1, + "source_line": "#define STBIR_FREE(ptr,user_data) ((void)(user_data), free(ptr))" + }, + "unit_kind": "macro", + "unit_name": "STBIR_FREE" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR__UNUSED' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 838, + "column": 1, + "source_line": "#define STBIR__UNUSED(v) (void)(v)" + }, + "unit_kind": "macro", + "unit_name": "STBIR__UNUSED" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR__UNUSED' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 840, + "column": 1, + "source_line": "#define STBIR__UNUSED(v) (void)sizeof(v)" + }, + "unit_kind": "macro", + "unit_name": "STBIR__UNUSED" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR__ARRAY_SIZE' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 843, + "column": 1, + "source_line": "#define STBIR__ARRAY_SIZE(a) (sizeof((a))/sizeof((a)[0]))" + }, + "unit_kind": "macro", + "unit_name": "STBIR__ARRAY_SIZE" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_CLAMP' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1071, + "column": 1, + "source_line": "#define STBIR_CLAMP(x, xmin, xmax) for(;;) { \\" + }, + "unit_kind": "macro", + "unit_name": "STBIR_CLAMP" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_STREAMOUT_PTR' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1237, + "column": 3, + "source_line": " #define STBIR_STREAMOUT_PTR( star ) star __restrict" + }, + "unit_kind": "macro", + "unit_name": "STBIR_STREAMOUT_PTR" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_NO_UNROLL' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1238, + "column": 3, + "source_line": " #define STBIR_NO_UNROLL( ptr ) __assume(ptr) // this oddly keeps msvc from unrolling a loop" + }, + "unit_kind": "macro", + "unit_name": "STBIR_NO_UNROLL" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_STREAMOUT_PTR' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1245, + "column": 3, + "source_line": " #define STBIR_STREAMOUT_PTR( star ) star __restrict__" + }, + "unit_kind": "macro", + "unit_name": "STBIR_STREAMOUT_PTR" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_NO_UNROLL' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1246, + "column": 3, + "source_line": " #define STBIR_NO_UNROLL( ptr ) __asm__ (\"\"::\"r\"(ptr)) " + }, + "unit_kind": "macro", + "unit_name": "STBIR_NO_UNROLL" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_STREAMOUT_PTR' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1253, + "column": 3, + "source_line": " #define STBIR_STREAMOUT_PTR( star ) star __restrict__" + }, + "unit_kind": "macro", + "unit_name": "STBIR_STREAMOUT_PTR" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_NO_UNROLL' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1254, + "column": 3, + "source_line": " #define STBIR_NO_UNROLL( ptr ) __asm__ (\"\"::\"r\"(ptr))" + }, + "unit_kind": "macro", + "unit_name": "STBIR_NO_UNROLL" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_STREAMOUT_PTR' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1262, + "column": 3, + "source_line": " #define STBIR_STREAMOUT_PTR( star ) star" + }, + "unit_kind": "macro", + "unit_name": "STBIR_STREAMOUT_PTR" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_NO_UNROLL' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1263, + "column": 3, + "source_line": " #define STBIR_NO_UNROLL( ptr )" + }, + "unit_kind": "macro", + "unit_name": "STBIR_NO_UNROLL" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir_simdi_castf' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1311, + "column": 3, + "source_line": " #define stbir_simdi_castf( reg ) _mm_castps_si128(reg)" + }, + "unit_kind": "macro", + "unit_name": "stbir_simdi_castf" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir_simdf_casti' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1312, + "column": 3, + "source_line": " #define stbir_simdf_casti( reg ) _mm_castsi128_ps(reg)" + }, + "unit_kind": "macro", + "unit_name": "stbir_simdf_casti" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_load' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1314, + "column": 3, + "source_line": " #define stbir__simdf_load( reg, ptr ) (reg) = _mm_loadu_ps( (float const*)(ptr) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_load" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_load' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1315, + "column": 3, + "source_line": " #define stbir__simdi_load( reg, ptr ) (reg) = _mm_loadu_si128 ( (stbir__simdi const*)(ptr) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_load" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_load1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1316, + "column": 3, + "source_line": " #define stbir__simdf_load1( out, ptr ) (out) = _mm_load_ss( (float const*)(ptr) ) // top values can be random (not denormal or nan for perf)" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_load1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_load1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1317, + "column": 3, + "source_line": " #define stbir__simdi_load1( out, ptr ) (out) = _mm_castps_si128( _mm_load_ss( (float const*)(ptr) ))" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_load1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_load1z' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1318, + "column": 3, + "source_line": " #define stbir__simdf_load1z( out, ptr ) (out) = _mm_load_ss( (float const*)(ptr) ) // top values must be zero" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_load1z" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_frep4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1319, + "column": 3, + "source_line": " #define stbir__simdf_frep4( fvar ) _mm_set_ps1( fvar )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_frep4" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_load1frep4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1320, + "column": 3, + "source_line": " #define stbir__simdf_load1frep4( out, fvar ) (out) = _mm_set_ps1( fvar )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_load1frep4" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_load2' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1321, + "column": 3, + "source_line": " #define stbir__simdf_load2( out, ptr ) (out) = _mm_castsi128_ps( _mm_loadl_epi64( (__m128i*)(ptr)) ) // top values can be random (not denormal or nan for perf)" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_load2" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_load2z' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1322, + "column": 3, + "source_line": " #define stbir__simdf_load2z( out, ptr ) (out) = _mm_castsi128_ps( _mm_loadl_epi64( (__m128i*)(ptr)) ) // top values must be zero" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_load2z" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_load2hmerge' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1323, + "column": 3, + "source_line": " #define stbir__simdf_load2hmerge( out, reg, ptr ) (out) = _mm_castpd_ps(_mm_loadh_pd( _mm_castps_pd(reg), (double*)(ptr) ))" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_load2hmerge" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_zeroP' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1325, + "column": 3, + "source_line": " #define stbir__simdf_zeroP() _mm_setzero_ps()" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_zeroP" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_zero' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1326, + "column": 3, + "source_line": " #define stbir__simdf_zero( reg ) (reg) = _mm_setzero_ps()" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_zero" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_store' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1328, + "column": 3, + "source_line": " #define stbir__simdf_store( ptr, reg ) _mm_storeu_ps( (float*)(ptr), reg )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_store" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_store1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1329, + "column": 3, + "source_line": " #define stbir__simdf_store1( ptr, reg ) _mm_store_ss( (float*)(ptr), reg )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_store1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_store2' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1330, + "column": 3, + "source_line": " #define stbir__simdf_store2( ptr, reg ) _mm_storel_epi64( (__m128i*)(ptr), _mm_castps_si128(reg) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_store2" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_store2h' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1331, + "column": 3, + "source_line": " #define stbir__simdf_store2h( ptr, reg ) _mm_storeh_pd( (double*)(ptr), _mm_castps_pd(reg) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_store2h" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_store' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1333, + "column": 3, + "source_line": " #define stbir__simdi_store( ptr, reg ) _mm_storeu_si128( (__m128i*)(ptr), reg )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_store" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_store1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1334, + "column": 3, + "source_line": " #define stbir__simdi_store1( ptr, reg ) _mm_store_ss( (float*)(ptr), _mm_castsi128_ps(reg) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_store1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_store2' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1335, + "column": 3, + "source_line": " #define stbir__simdi_store2( ptr, reg ) _mm_storel_epi64( (__m128i*)(ptr), (reg) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_store2" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__prefetch' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1337, + "column": 3, + "source_line": " #define stbir__prefetch( ptr ) _mm_prefetch((char*)(ptr), _MM_HINT_T0 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__prefetch" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_expand_u8_to_u32' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1339, + "column": 3, + "source_line": " #define stbir__simdi_expand_u8_to_u32(out0,out1,out2,out3,ireg) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_expand_u8_to_u32" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_expand_u8_to_1u32' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1350, + "column": 1, + "source_line": "#define stbir__simdi_expand_u8_to_1u32(out,ireg) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_expand_u8_to_1u32" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_expand_u16_to_u32' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1357, + "column": 3, + "source_line": " #define stbir__simdi_expand_u16_to_u32(out0,out1,ireg) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_expand_u16_to_u32" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_convert_float_to_i32' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1364, + "column": 3, + "source_line": " #define stbir__simdf_convert_float_to_i32( i, f ) (i) = _mm_cvttps_epi32(f)" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_convert_float_to_i32" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_convert_float_to_int' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1365, + "column": 3, + "source_line": " #define stbir__simdf_convert_float_to_int( f ) _mm_cvtt_ss2si(f)" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_convert_float_to_int" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_convert_float_to_uint8' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1366, + "column": 3, + "source_line": " #define stbir__simdf_convert_float_to_uint8( f ) ((unsigned char)_mm_cvtsi128_si32(_mm_cvttps_epi32(_mm_max_ps(_mm_min_ps(f,STBIR__CONSTF(STBIR_max_uint8_as_float)),_mm_setzero_ps()))))" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_convert_float_to_uint8" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_convert_float_to_short' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1367, + "column": 3, + "source_line": " #define stbir__simdf_convert_float_to_short( f ) ((unsigned short)_mm_cvtsi128_si32(_mm_cvttps_epi32(_mm_max_ps(_mm_min_ps(f,STBIR__CONSTF(STBIR_max_uint16_as_float)),_mm_setzero_ps()))))" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_convert_float_to_short" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_to_int' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1369, + "column": 3, + "source_line": " #define stbir__simdi_to_int( i ) _mm_cvtsi128_si32(i)" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_to_int" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_convert_i32_to_float' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1370, + "column": 3, + "source_line": " #define stbir__simdi_convert_i32_to_float(out, ireg) (out) = _mm_cvtepi32_ps( ireg )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_convert_i32_to_float" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_add' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1371, + "column": 3, + "source_line": " #define stbir__simdf_add( out, reg0, reg1 ) (out) = _mm_add_ps( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_add" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_mult' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1372, + "column": 3, + "source_line": " #define stbir__simdf_mult( out, reg0, reg1 ) (out) = _mm_mul_ps( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_mult" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_mult_mem' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1373, + "column": 3, + "source_line": " #define stbir__simdf_mult_mem( out, reg, ptr ) (out) = _mm_mul_ps( reg, _mm_loadu_ps( (float const*)(ptr) ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_mult_mem" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_mult1_mem' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1374, + "column": 3, + "source_line": " #define stbir__simdf_mult1_mem( out, reg, ptr ) (out) = _mm_mul_ss( reg, _mm_load_ss( (float const*)(ptr) ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_mult1_mem" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_add_mem' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1375, + "column": 3, + "source_line": " #define stbir__simdf_add_mem( out, reg, ptr ) (out) = _mm_add_ps( reg, _mm_loadu_ps( (float const*)(ptr) ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_add_mem" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_add1_mem' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1376, + "column": 3, + "source_line": " #define stbir__simdf_add1_mem( out, reg, ptr ) (out) = _mm_add_ss( reg, _mm_load_ss( (float const*)(ptr) ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_add1_mem" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_madd' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1380, + "column": 3, + "source_line": " #define stbir__simdf_madd( out, add, mul1, mul2 ) (out) = _mm_fmadd_ps( mul1, mul2, add )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_madd" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_madd1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1381, + "column": 3, + "source_line": " #define stbir__simdf_madd1( out, add, mul1, mul2 ) (out) = _mm_fmadd_ss( mul1, mul2, add )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_madd1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_madd_mem' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1382, + "column": 3, + "source_line": " #define stbir__simdf_madd_mem( out, add, mul, ptr ) (out) = _mm_fmadd_ps( mul, _mm_loadu_ps( (float const*)(ptr) ), add )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_madd_mem" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_madd1_mem' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1383, + "column": 3, + "source_line": " #define stbir__simdf_madd1_mem( out, add, mul, ptr ) (out) = _mm_fmadd_ss( mul, _mm_load_ss( (float const*)(ptr) ), add )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_madd1_mem" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_madd' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1385, + "column": 3, + "source_line": " #define stbir__simdf_madd( out, add, mul1, mul2 ) (out) = _mm_add_ps( add, _mm_mul_ps( mul1, mul2 ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_madd" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_madd1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1386, + "column": 3, + "source_line": " #define stbir__simdf_madd1( out, add, mul1, mul2 ) (out) = _mm_add_ss( add, _mm_mul_ss( mul1, mul2 ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_madd1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_madd_mem' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1387, + "column": 3, + "source_line": " #define stbir__simdf_madd_mem( out, add, mul, ptr ) (out) = _mm_add_ps( add, _mm_mul_ps( mul, _mm_loadu_ps( (float const*)(ptr) ) ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_madd_mem" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_madd1_mem' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1388, + "column": 3, + "source_line": " #define stbir__simdf_madd1_mem( out, add, mul, ptr ) (out) = _mm_add_ss( add, _mm_mul_ss( mul, _mm_load_ss( (float const*)(ptr) ) ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_madd1_mem" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_add1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1391, + "column": 3, + "source_line": " #define stbir__simdf_add1( out, reg0, reg1 ) (out) = _mm_add_ss( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_add1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_mult1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1392, + "column": 3, + "source_line": " #define stbir__simdf_mult1( out, reg0, reg1 ) (out) = _mm_mul_ss( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_mult1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_and' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1394, + "column": 3, + "source_line": " #define stbir__simdf_and( out, reg0, reg1 ) (out) = _mm_and_ps( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_and" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_or' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1395, + "column": 3, + "source_line": " #define stbir__simdf_or( out, reg0, reg1 ) (out) = _mm_or_ps( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_or" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_min' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1397, + "column": 3, + "source_line": " #define stbir__simdf_min( out, reg0, reg1 ) (out) = _mm_min_ps( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_min" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_max' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1398, + "column": 3, + "source_line": " #define stbir__simdf_max( out, reg0, reg1 ) (out) = _mm_max_ps( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_max" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_min1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1399, + "column": 3, + "source_line": " #define stbir__simdf_min1( out, reg0, reg1 ) (out) = _mm_min_ss( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_min1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_max1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1400, + "column": 3, + "source_line": " #define stbir__simdf_max1( out, reg0, reg1 ) (out) = _mm_max_ss( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_max1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_0123ABCDto3ABx' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1402, + "column": 3, + "source_line": " #define stbir__simdf_0123ABCDto3ABx( out, reg0, reg1 ) (out)=_mm_castsi128_ps( _mm_shuffle_epi32( _mm_castps_si128( _mm_shuffle_ps( reg1,reg0, (0<<0) + (1<<2) + (2<<4) + (3<<6) )), (3<<0) + (0<<2) + (1<<4) + (2<<6) ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_0123ABCDto3ABx" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_0123ABCDto23Ax' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1403, + "column": 3, + "source_line": " #define stbir__simdf_0123ABCDto23Ax( out, reg0, reg1 ) (out)=_mm_castsi128_ps( _mm_shuffle_epi32( _mm_castps_si128( _mm_shuffle_ps( reg1,reg0, (0<<0) + (1<<2) + (2<<4) + (3<<6) )), (2<<0) + (3<<2) + (0<<4) + (1<<6) ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_0123ABCDto23Ax" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_aaa1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1407, + "column": 3, + "source_line": " #define stbir__simdf_aaa1( out, alp, ones ) (out)=_mm_castsi128_ps( _mm_shuffle_epi32( _mm_castps_si128( _mm_movehl_ps( ones, alp ) ), (1<<0) + (1<<2) + (1<<4) + (2<<6) ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_aaa1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_1aaa' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1408, + "column": 3, + "source_line": " #define stbir__simdf_1aaa( out, alp, ones ) (out)=_mm_castsi128_ps( _mm_shuffle_epi32( _mm_castps_si128( _mm_movelh_ps( ones, alp ) ), (0<<0) + (2<<2) + (2<<4) + (2<<6) ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_1aaa" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_a1a1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1409, + "column": 3, + "source_line": " #define stbir__simdf_a1a1( out, alp, ones) (out) = _mm_or_ps( _mm_castsi128_ps( _mm_srli_epi64( _mm_castps_si128(alp), 32 ) ), STBIR_zeroones )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_a1a1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_1a1a' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1410, + "column": 3, + "source_line": " #define stbir__simdf_1a1a( out, alp, ones) (out) = _mm_or_ps( _mm_castsi128_ps( _mm_slli_epi64( _mm_castps_si128(alp), 32 ) ), STBIR_onezeros )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_1a1a" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_swiz' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1412, + "column": 3, + "source_line": " #define stbir__simdf_swiz( reg, one, two, three, four ) _mm_castsi128_ps( _mm_shuffle_epi32( _mm_castps_si128( reg ), (one<<0) + (two<<2) + (three<<4) + (four<<6) ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_swiz" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_and' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1414, + "column": 3, + "source_line": " #define stbir__simdi_and( out, reg0, reg1 ) (out) = _mm_and_si128( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_and" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_or' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1415, + "column": 3, + "source_line": " #define stbir__simdi_or( out, reg0, reg1 ) (out) = _mm_or_si128( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_or" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_16madd' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1416, + "column": 3, + "source_line": " #define stbir__simdi_16madd( out, reg0, reg1 ) (out) = _mm_madd_epi16( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_16madd" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_pack_to_8bytes' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1418, + "column": 3, + "source_line": " #define stbir__simdf_pack_to_8bytes(out,aa,bb) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_pack_to_8bytes" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_load4_transposed' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1432, + "column": 3, + "source_line": " #define stbir__simdf_load4_transposed( o0, o1, o2, o3, ptr ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_load4_transposed" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__interleave_pack_and_store_16_u8' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1449, + "column": 3, + "source_line": " #define stbir__interleave_pack_and_store_16_u8( ptr, r0, r1, r2, r3 ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__interleave_pack_and_store_16_u8" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_32shr' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1459, + "column": 3, + "source_line": " #define stbir__simdi_32shr( out, reg, imm ) out = _mm_srli_epi32( reg, imm )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_32shr" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR__CONST_32_TO_8' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1463, + "column": 5, + "source_line": " #define STBIR__CONST_32_TO_8( v ) (char)(unsigned char)((v)&255),(char)(unsigned char)(((v)>>8)&255),(char)(unsigned char)(((v)>>16)&255),(char)(unsigned char)(((v)>>24)&255)" + }, + "unit_kind": "macro", + "unit_name": "STBIR__CONST_32_TO_8" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR__CONST_4_32i' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1464, + "column": 5, + "source_line": " #define STBIR__CONST_4_32i( v ) STBIR__CONST_32_TO_8( v ), STBIR__CONST_32_TO_8( v ), STBIR__CONST_32_TO_8( v ), STBIR__CONST_32_TO_8( v )" + }, + "unit_kind": "macro", + "unit_name": "STBIR__CONST_4_32i" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR__CONST_4d_32i' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1465, + "column": 5, + "source_line": " #define STBIR__CONST_4d_32i( v0, v1, v2, v3 ) STBIR__CONST_32_TO_8( v0 ), STBIR__CONST_32_TO_8( v1 ), STBIR__CONST_32_TO_8( v2 ), STBIR__CONST_32_TO_8( v3 )" + }, + "unit_kind": "macro", + "unit_name": "STBIR__CONST_4d_32i" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR__CONST_4_32i' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1468, + "column": 5, + "source_line": " #define STBIR__CONST_4_32i( v ) (long long)((((stbir_uint64)(stbir_uint32)(v))<<32)|((stbir_uint64)(stbir_uint32)(v))),(long long)((((stbir_uint64)(stbir_uint32)(v))<<32)|((stbir_uint64)(stbir_uint32)(v)))" + }, + "unit_kind": "macro", + "unit_name": "STBIR__CONST_4_32i" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR__CONST_4d_32i' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1469, + "column": 5, + "source_line": " #define STBIR__CONST_4d_32i( v0, v1, v2, v3 ) (long long)((((stbir_uint64)(stbir_uint32)(v1))<<32)|((stbir_uint64)(stbir_uint32)(v0))),(long long)((((stbir_uint64)(stbir_uint32)(v3))<<32)|((stbir_uint64)(stbir_uint32)(v2)))" + }, + "unit_kind": "macro", + "unit_name": "STBIR__CONST_4d_32i" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR__SIMDF_CONST' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1472, + "column": 3, + "source_line": " #define STBIR__SIMDF_CONST(var, x) stbir__simdf var = { x, x, x, x }" + }, + "unit_kind": "macro", + "unit_name": "STBIR__SIMDF_CONST" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR__SIMDI_CONST' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1473, + "column": 3, + "source_line": " #define STBIR__SIMDI_CONST(var, x) stbir__simdi var = { STBIR__CONST_4_32i(x) }" + }, + "unit_kind": "macro", + "unit_name": "STBIR__SIMDI_CONST" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR__CONSTF' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1474, + "column": 3, + "source_line": " #define STBIR__CONSTF(var) (var)" + }, + "unit_kind": "macro", + "unit_name": "STBIR__CONSTF" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR__CONSTI' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1475, + "column": 3, + "source_line": " #define STBIR__CONSTI(var) (var)" + }, + "unit_kind": "macro", + "unit_name": "STBIR__CONSTI" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_pack_to_8words' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1479, + "column": 5, + "source_line": " #define stbir__simdf_pack_to_8words(out,reg0,reg1) out = _mm_packus_epi32(_mm_cvttps_epi32(_mm_max_ps(_mm_min_ps(reg0,STBIR__CONSTF(STBIR_max_uint16_as_float)),_mm_setzero_ps())), _mm_cvttps_epi32(_mm_max_ps(_mm_min_ps(reg1,STBIR__CONSTF(STBIR_max_uint16_as_float)),_mm_setzero_ps())))" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_pack_to_8words" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_pack_to_8words' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1484, + "column": 5, + "source_line": " #define stbir__simdf_pack_to_8words(out,reg0,reg1) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_pack_to_8words" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_load' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1505, + "column": 5, + "source_line": " #define stbir__simdf8_load( out, ptr ) (out) = _mm256_loadu_ps( (float const *)(ptr) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_load" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi8_load' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1506, + "column": 5, + "source_line": " #define stbir__simdi8_load( out, ptr ) (out) = _mm256_loadu_si256( (__m256i const *)(ptr) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi8_load" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_mult' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1507, + "column": 5, + "source_line": " #define stbir__simdf8_mult( out, a, b ) (out) = _mm256_mul_ps( (a), (b) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_mult" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_store' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1508, + "column": 5, + "source_line": " #define stbir__simdf8_store( ptr, out ) _mm256_storeu_ps( (float*)(ptr), out )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_store" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi8_store' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1509, + "column": 5, + "source_line": " #define stbir__simdi8_store( ptr, reg ) _mm256_storeu_si256( (__m256i*)(ptr), reg )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi8_store" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_frep8' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1510, + "column": 5, + "source_line": " #define stbir__simdf8_frep8( fval ) _mm256_set1_ps( fval )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_frep8" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_min' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1512, + "column": 5, + "source_line": " #define stbir__simdf8_min( out, reg0, reg1 ) (out) = _mm256_min_ps( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_min" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_max' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1513, + "column": 5, + "source_line": " #define stbir__simdf8_max( out, reg0, reg1 ) (out) = _mm256_max_ps( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_max" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_add4halves' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1515, + "column": 5, + "source_line": " #define stbir__simdf8_add4halves( out, bot4, top8 ) (out) = _mm_add_ps( bot4, _mm256_extractf128_ps( top8, 1 ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_add4halves" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_mult_mem' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1516, + "column": 5, + "source_line": " #define stbir__simdf8_mult_mem( out, reg, ptr ) (out) = _mm256_mul_ps( reg, _mm256_loadu_ps( (float const*)(ptr) ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_mult_mem" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_add_mem' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1517, + "column": 5, + "source_line": " #define stbir__simdf8_add_mem( out, reg, ptr ) (out) = _mm256_add_ps( reg, _mm256_loadu_ps( (float const*)(ptr) ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_add_mem" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_add' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1518, + "column": 5, + "source_line": " #define stbir__simdf8_add( out, a, b ) (out) = _mm256_add_ps( a, b )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_add" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_load1b' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1519, + "column": 5, + "source_line": " #define stbir__simdf8_load1b( out, ptr ) (out) = _mm256_broadcast_ss( ptr )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_load1b" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_load1rep4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1520, + "column": 5, + "source_line": " #define stbir__simdf_load1rep4( out, ptr ) (out) = _mm_broadcast_ss( ptr ) // avx load instruction" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_load1rep4" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi8_convert_i32_to_float' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1522, + "column": 5, + "source_line": " #define stbir__simdi8_convert_i32_to_float(out, ireg) (out) = _mm256_cvtepi32_ps( ireg )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi8_convert_i32_to_float" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_convert_float_to_i32' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1523, + "column": 5, + "source_line": " #define stbir__simdf8_convert_float_to_i32( i, f ) (i) = _mm256_cvttps_epi32(f)" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_convert_float_to_i32" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_bot4s' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1525, + "column": 5, + "source_line": " #define stbir__simdf8_bot4s( out, a, b ) (out) = _mm256_permute2f128_ps(a,b, (0<<0)+(2<<4) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_bot4s" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_top4s' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1526, + "column": 5, + "source_line": " #define stbir__simdf8_top4s( out, a, b ) (out) = _mm256_permute2f128_ps(a,b, (1<<0)+(3<<4) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_top4s" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_gettop4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1528, + "column": 5, + "source_line": " #define stbir__simdf8_gettop4( reg ) _mm256_extractf128_ps(reg,1)" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_gettop4" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi8_expand_u8_to_u32' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1532, + "column": 5, + "source_line": " #define stbir__simdi8_expand_u8_to_u32(out0,out1,ireg) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi8_expand_u8_to_u32" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_pack_to_16bytes' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1540, + "column": 5, + "source_line": " #define stbir__simdf8_pack_to_16bytes(out,aa,bb) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_pack_to_16bytes" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi8_expand_u16_to_u32' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1555, + "column": 5, + "source_line": " #define stbir__simdi8_expand_u16_to_u32(out,ireg) out = _mm256_unpacklo_epi16( _mm256_permute4x64_epi64(_mm256_castsi128_si256(ireg),(0<<0)+(2<<2)+(1<<4)+(3<<6)), _mm256_setzero_si256() );" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi8_expand_u16_to_u32" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_pack_to_16words' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1557, + "column": 5, + "source_line": " #define stbir__simdf8_pack_to_16words(out,aa,bb) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_pack_to_16words" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi8_expand_u8_to_u32' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1572, + "column": 5, + "source_line": " #define stbir__simdi8_expand_u8_to_u32(out0,out1,ireg) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi8_expand_u8_to_u32" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_pack_to_16bytes' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1581, + "column": 5, + "source_line": " #define stbir__simdf8_pack_to_16bytes(out,aa,bb) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_pack_to_16bytes" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi8_expand_u16_to_u32' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1599, + "column": 5, + "source_line": " #define stbir__simdi8_expand_u16_to_u32(out,ireg) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi8_expand_u16_to_u32" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_pack_to_16words' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1607, + "column": 5, + "source_line": " #define stbir__simdf8_pack_to_16words(out,aa,bb) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_pack_to_16words" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_0123to00001111' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1626, + "column": 5, + "source_line": " #define stbir__simdf8_0123to00001111( out, in ) (out) = _mm256_permutevar_ps ( in, stbir_00001111 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_0123to00001111" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_0123to22223333' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1629, + "column": 5, + "source_line": " #define stbir__simdf8_0123to22223333( out, in ) (out) = _mm256_permutevar_ps ( in, stbir_22223333 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_0123to22223333" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_0123to2222' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1631, + "column": 5, + "source_line": " #define stbir__simdf8_0123to2222( out, in ) (out) = stbir__simdf_swiz(_mm256_castps256_ps128(in), 2,2,2,2 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_0123to2222" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_load4b' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1633, + "column": 5, + "source_line": " #define stbir__simdf8_load4b( out, ptr ) (out) = _mm256_broadcast_ps( (__m128 const *)(ptr) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_load4b" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_0123to00112233' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1636, + "column": 5, + "source_line": " #define stbir__simdf8_0123to00112233( out, in ) (out) = _mm256_permutevar_ps ( in, stbir_00112233 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_0123to00112233" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_add4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1637, + "column": 5, + "source_line": " #define stbir__simdf8_add4( out, a8, b ) (out) = _mm256_add_ps( a8, _mm256_castps128_ps256( b ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_add4" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_load6z' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1640, + "column": 5, + "source_line": " #define stbir__simdf8_load6z( out, ptr ) (out) = _mm256_maskload_ps( ptr, stbir_load6 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_load6z" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_0123to00000000' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1642, + "column": 5, + "source_line": " #define stbir__simdf8_0123to00000000( out, in ) (out) = _mm256_shuffle_ps ( in, in, (0<<0)+(0<<2)+(0<<4)+(0<<6) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_0123to00000000" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_0123to11111111' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1643, + "column": 5, + "source_line": " #define stbir__simdf8_0123to11111111( out, in ) (out) = _mm256_shuffle_ps ( in, in, (1<<0)+(1<<2)+(1<<4)+(1<<6) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_0123to11111111" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_0123to22222222' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1644, + "column": 5, + "source_line": " #define stbir__simdf8_0123to22222222( out, in ) (out) = _mm256_shuffle_ps ( in, in, (2<<0)+(2<<2)+(2<<4)+(2<<6) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_0123to22222222" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_0123to33333333' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1645, + "column": 5, + "source_line": " #define stbir__simdf8_0123to33333333( out, in ) (out) = _mm256_shuffle_ps ( in, in, (3<<0)+(3<<2)+(3<<4)+(3<<6) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_0123to33333333" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_0123to21032103' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1646, + "column": 5, + "source_line": " #define stbir__simdf8_0123to21032103( out, in ) (out) = _mm256_shuffle_ps ( in, in, (2<<0)+(1<<2)+(0<<4)+(3<<6) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_0123to21032103" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_0123to32103210' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1647, + "column": 5, + "source_line": " #define stbir__simdf8_0123to32103210( out, in ) (out) = _mm256_shuffle_ps ( in, in, (3<<0)+(2<<2)+(1<<4)+(0<<6) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_0123to32103210" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_0123to12301230' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1648, + "column": 5, + "source_line": " #define stbir__simdf8_0123to12301230( out, in ) (out) = _mm256_shuffle_ps ( in, in, (1<<0)+(2<<2)+(3<<4)+(0<<6) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_0123to12301230" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_0123to10321032' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1649, + "column": 5, + "source_line": " #define stbir__simdf8_0123to10321032( out, in ) (out) = _mm256_shuffle_ps ( in, in, (1<<0)+(0<<2)+(3<<4)+(2<<6) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_0123to10321032" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_0123to30123012' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1650, + "column": 5, + "source_line": " #define stbir__simdf8_0123to30123012( out, in ) (out) = _mm256_shuffle_ps ( in, in, (3<<0)+(0<<2)+(1<<4)+(2<<6) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_0123to30123012" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_0123to11331133' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1652, + "column": 5, + "source_line": " #define stbir__simdf8_0123to11331133( out, in ) (out) = _mm256_shuffle_ps ( in, in, (1<<0)+(1<<2)+(3<<4)+(3<<6) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_0123to11331133" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_0123to00220022' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1653, + "column": 5, + "source_line": " #define stbir__simdf8_0123to00220022( out, in ) (out) = _mm256_shuffle_ps ( in, in, (0<<0)+(0<<2)+(2<<4)+(2<<6) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_0123to00220022" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_aaa1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1655, + "column": 5, + "source_line": " #define stbir__simdf8_aaa1( out, alp, ones ) (out) = _mm256_blend_ps( alp, ones, (1<<0)+(1<<1)+(1<<2)+(0<<3)+(1<<4)+(1<<5)+(1<<6)+(0<<7)); (out)=_mm256_shuffle_ps( out,out, (3<<0) + (3<<2) + (3<<4) + (0<<6) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_aaa1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_1aaa' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1656, + "column": 5, + "source_line": " #define stbir__simdf8_1aaa( out, alp, ones ) (out) = _mm256_blend_ps( alp, ones, (0<<0)+(1<<1)+(1<<2)+(1<<3)+(0<<4)+(1<<5)+(1<<6)+(1<<7)); (out)=_mm256_shuffle_ps( out,out, (1<<0) + (0<<2) + (0<<4) + (0<<6) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_1aaa" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_a1a1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1657, + "column": 5, + "source_line": " #define stbir__simdf8_a1a1( out, alp, ones) (out) = _mm256_blend_ps( alp, ones, (1<<0)+(0<<1)+(1<<2)+(0<<3)+(1<<4)+(0<<5)+(1<<6)+(0<<7)); (out)=_mm256_shuffle_ps( out,out, (1<<0) + (0<<2) + (3<<4) + (2<<6) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_a1a1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_1a1a' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1658, + "column": 5, + "source_line": " #define stbir__simdf8_1a1a( out, alp, ones) (out) = _mm256_blend_ps( alp, ones, (0<<0)+(1<<1)+(0<<2)+(1<<3)+(0<<4)+(1<<5)+(0<<6)+(1<<7)); (out)=_mm256_shuffle_ps( out,out, (1<<0) + (0<<2) + (3<<4) + (2<<6) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_1a1a" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_zero' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1660, + "column": 5, + "source_line": " #define stbir__simdf8_zero( reg ) (reg) = _mm256_setzero_ps()" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_zero" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_madd' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1663, + "column": 5, + "source_line": " #define stbir__simdf8_madd( out, add, mul1, mul2 ) (out) = _mm256_fmadd_ps( mul1, mul2, add )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_madd" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_madd_mem' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1664, + "column": 5, + "source_line": " #define stbir__simdf8_madd_mem( out, add, mul, ptr ) (out) = _mm256_fmadd_ps( mul, _mm256_loadu_ps( (float const*)(ptr) ), add )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_madd_mem" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_madd' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1667, + "column": 5, + "source_line": " #define stbir__simdf8_madd( out, add, mul1, mul2 ) (out) = _mm256_add_ps( add, _mm256_mul_ps( mul1, mul2 ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_madd" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_madd_mem' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1668, + "column": 5, + "source_line": " #define stbir__simdf8_madd_mem( out, add, mul, ptr ) (out) = _mm256_add_ps( add, _mm256_mul_ps( mul, _mm256_loadu_ps( (float const*)(ptr) ) ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_madd_mem" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf8_madd_mem4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1669, + "column": 5, + "source_line": " #define stbir__simdf8_madd_mem4( out, add, mul, ptr ) (out) = _mm256_add_ps( add, _mm256_setr_m128( _mm_mul_ps( mul, _mm_loadu_ps( (float const*)(ptr) ) ), _mm_setzero_ps() ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf8_madd_mem4" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__if_simdf8_cast_to_simdf4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1671, + "column": 5, + "source_line": " #define stbir__if_simdf8_cast_to_simdf4( val ) _mm256_castps256_ps128( val )" + }, + "unit_kind": "macro", + "unit_name": "stbir__if_simdf8_cast_to_simdf4" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir_simdi_castf' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1716, + "column": 3, + "source_line": " #define stbir_simdi_castf( reg ) vreinterpretq_u32_f32(reg)" + }, + "unit_kind": "macro", + "unit_name": "stbir_simdi_castf" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir_simdf_casti' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1717, + "column": 3, + "source_line": " #define stbir_simdf_casti( reg ) vreinterpretq_f32_u32(reg)" + }, + "unit_kind": "macro", + "unit_name": "stbir_simdf_casti" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_load' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1719, + "column": 3, + "source_line": " #define stbir__simdf_load( reg, ptr ) (reg) = vld1q_f32( (float const*)(ptr) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_load" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_load' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1720, + "column": 3, + "source_line": " #define stbir__simdi_load( reg, ptr ) (reg) = vld1q_u32( (uint32_t const*)(ptr) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_load" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_load1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1721, + "column": 3, + "source_line": " #define stbir__simdf_load1( out, ptr ) (out) = vld1q_dup_f32( (float const*)(ptr) ) // top values can be random (not denormal or nan for perf)" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_load1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_load1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1722, + "column": 3, + "source_line": " #define stbir__simdi_load1( out, ptr ) (out) = vld1q_dup_u32( (uint32_t const*)(ptr) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_load1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_load1z' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1723, + "column": 3, + "source_line": " #define stbir__simdf_load1z( out, ptr ) (out) = vld1q_lane_f32( (float const*)(ptr), vdupq_n_f32(0), 0 ) // top values must be zero" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_load1z" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_frep4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1724, + "column": 3, + "source_line": " #define stbir__simdf_frep4( fvar ) vdupq_n_f32( fvar )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_frep4" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_load1frep4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1725, + "column": 3, + "source_line": " #define stbir__simdf_load1frep4( out, fvar ) (out) = vdupq_n_f32( fvar )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_load1frep4" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_load2' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1726, + "column": 3, + "source_line": " #define stbir__simdf_load2( out, ptr ) (out) = vcombine_f32( vld1_f32( (float const*)(ptr) ), vcreate_f32(0) ) // top values can be random (not denormal or nan for perf)" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_load2" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_load2z' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1727, + "column": 3, + "source_line": " #define stbir__simdf_load2z( out, ptr ) (out) = vcombine_f32( vld1_f32( (float const*)(ptr) ), vcreate_f32(0) ) // top values must be zero" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_load2z" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_load2hmerge' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1728, + "column": 3, + "source_line": " #define stbir__simdf_load2hmerge( out, reg, ptr ) (out) = vcombine_f32( vget_low_f32(reg), vld1_f32( (float const*)(ptr) ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_load2hmerge" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_zeroP' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1730, + "column": 3, + "source_line": " #define stbir__simdf_zeroP() vdupq_n_f32(0)" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_zeroP" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_zero' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1731, + "column": 3, + "source_line": " #define stbir__simdf_zero( reg ) (reg) = vdupq_n_f32(0)" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_zero" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_store' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1733, + "column": 3, + "source_line": " #define stbir__simdf_store( ptr, reg ) vst1q_f32( (float*)(ptr), reg )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_store" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_store1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1734, + "column": 3, + "source_line": " #define stbir__simdf_store1( ptr, reg ) vst1q_lane_f32( (float*)(ptr), reg, 0)" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_store1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_store2' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1735, + "column": 3, + "source_line": " #define stbir__simdf_store2( ptr, reg ) vst1_f32( (float*)(ptr), vget_low_f32(reg) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_store2" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_store2h' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1736, + "column": 3, + "source_line": " #define stbir__simdf_store2h( ptr, reg ) vst1_f32( (float*)(ptr), vget_high_f32(reg) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_store2h" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_store' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1738, + "column": 3, + "source_line": " #define stbir__simdi_store( ptr, reg ) vst1q_u32( (uint32_t*)(ptr), reg )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_store" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_store1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1739, + "column": 3, + "source_line": " #define stbir__simdi_store1( ptr, reg ) vst1q_lane_u32( (uint32_t*)(ptr), reg, 0 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_store1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_store2' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1740, + "column": 3, + "source_line": " #define stbir__simdi_store2( ptr, reg ) vst1_u32( (uint32_t*)(ptr), vget_low_u32(reg) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_store2" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__prefetch' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1742, + "column": 3, + "source_line": " #define stbir__prefetch( ptr )" + }, + "unit_kind": "macro", + "unit_name": "stbir__prefetch" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_expand_u8_to_u32' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1744, + "column": 3, + "source_line": " #define stbir__simdi_expand_u8_to_u32(out0,out1,out2,out3,ireg) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_expand_u8_to_u32" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_expand_u8_to_1u32' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1754, + "column": 3, + "source_line": " #define stbir__simdi_expand_u8_to_1u32(out,ireg) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_expand_u8_to_1u32" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_expand_u16_to_u32' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1760, + "column": 3, + "source_line": " #define stbir__simdi_expand_u16_to_u32(out0,out1,ireg) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_expand_u16_to_u32" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_convert_float_to_i32' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1767, + "column": 3, + "source_line": " #define stbir__simdf_convert_float_to_i32( i, f ) (i) = vreinterpretq_u32_s32( vcvtq_s32_f32(f) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_convert_float_to_i32" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_convert_float_to_int' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1768, + "column": 3, + "source_line": " #define stbir__simdf_convert_float_to_int( f ) vgetq_lane_s32(vcvtq_s32_f32(f), 0)" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_convert_float_to_int" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_to_int' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1769, + "column": 3, + "source_line": " #define stbir__simdi_to_int( i ) (int)vgetq_lane_u32(i, 0)" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_to_int" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_convert_float_to_uint8' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1770, + "column": 3, + "source_line": " #define stbir__simdf_convert_float_to_uint8( f ) ((unsigned char)vgetq_lane_s32(vcvtq_s32_f32(vmaxq_f32(vminq_f32(f,STBIR__CONSTF(STBIR_max_uint8_as_float)),vdupq_n_f32(0))), 0))" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_convert_float_to_uint8" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_convert_float_to_short' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1771, + "column": 3, + "source_line": " #define stbir__simdf_convert_float_to_short( f ) ((unsigned short)vgetq_lane_s32(vcvtq_s32_f32(vmaxq_f32(vminq_f32(f,STBIR__CONSTF(STBIR_max_uint16_as_float)),vdupq_n_f32(0))), 0))" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_convert_float_to_short" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_convert_i32_to_float' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1772, + "column": 3, + "source_line": " #define stbir__simdi_convert_i32_to_float(out, ireg) (out) = vcvtq_f32_s32( vreinterpretq_s32_u32(ireg) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_convert_i32_to_float" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_add' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1773, + "column": 3, + "source_line": " #define stbir__simdf_add( out, reg0, reg1 ) (out) = vaddq_f32( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_add" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_mult' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1774, + "column": 3, + "source_line": " #define stbir__simdf_mult( out, reg0, reg1 ) (out) = vmulq_f32( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_mult" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_mult_mem' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1775, + "column": 3, + "source_line": " #define stbir__simdf_mult_mem( out, reg, ptr ) (out) = vmulq_f32( reg, vld1q_f32( (float const*)(ptr) ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_mult_mem" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_mult1_mem' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1776, + "column": 3, + "source_line": " #define stbir__simdf_mult1_mem( out, reg, ptr ) (out) = vmulq_f32( reg, vld1q_dup_f32( (float const*)(ptr) ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_mult1_mem" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_add_mem' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1777, + "column": 3, + "source_line": " #define stbir__simdf_add_mem( out, reg, ptr ) (out) = vaddq_f32( reg, vld1q_f32( (float const*)(ptr) ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_add_mem" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_add1_mem' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1778, + "column": 3, + "source_line": " #define stbir__simdf_add1_mem( out, reg, ptr ) (out) = vaddq_f32( reg, vld1q_dup_f32( (float const*)(ptr) ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_add1_mem" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_madd' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1781, + "column": 3, + "source_line": " #define stbir__simdf_madd( out, add, mul1, mul2 ) (out) = vfmaq_f32( add, mul1, mul2 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_madd" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_madd1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1782, + "column": 3, + "source_line": " #define stbir__simdf_madd1( out, add, mul1, mul2 ) (out) = vfmaq_f32( add, mul1, mul2 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_madd1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_madd_mem' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1783, + "column": 3, + "source_line": " #define stbir__simdf_madd_mem( out, add, mul, ptr ) (out) = vfmaq_f32( add, mul, vld1q_f32( (float const*)(ptr) ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_madd_mem" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_madd1_mem' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1784, + "column": 3, + "source_line": " #define stbir__simdf_madd1_mem( out, add, mul, ptr ) (out) = vfmaq_f32( add, mul, vld1q_dup_f32( (float const*)(ptr) ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_madd1_mem" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_madd' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1786, + "column": 3, + "source_line": " #define stbir__simdf_madd( out, add, mul1, mul2 ) (out) = vaddq_f32( add, vmulq_f32( mul1, mul2 ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_madd" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_madd1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1787, + "column": 3, + "source_line": " #define stbir__simdf_madd1( out, add, mul1, mul2 ) (out) = vaddq_f32( add, vmulq_f32( mul1, mul2 ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_madd1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_madd_mem' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1788, + "column": 3, + "source_line": " #define stbir__simdf_madd_mem( out, add, mul, ptr ) (out) = vaddq_f32( add, vmulq_f32( mul, vld1q_f32( (float const*)(ptr) ) ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_madd_mem" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_madd1_mem' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1789, + "column": 3, + "source_line": " #define stbir__simdf_madd1_mem( out, add, mul, ptr ) (out) = vaddq_f32( add, vmulq_f32( mul, vld1q_dup_f32( (float const*)(ptr) ) ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_madd1_mem" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_add1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1792, + "column": 3, + "source_line": " #define stbir__simdf_add1( out, reg0, reg1 ) (out) = vaddq_f32( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_add1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_mult1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1793, + "column": 3, + "source_line": " #define stbir__simdf_mult1( out, reg0, reg1 ) (out) = vmulq_f32( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_mult1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_and' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1795, + "column": 3, + "source_line": " #define stbir__simdf_and( out, reg0, reg1 ) (out) = vreinterpretq_f32_u32( vandq_u32( vreinterpretq_u32_f32(reg0), vreinterpretq_u32_f32(reg1) ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_and" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_or' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1796, + "column": 3, + "source_line": " #define stbir__simdf_or( out, reg0, reg1 ) (out) = vreinterpretq_f32_u32( vorrq_u32( vreinterpretq_u32_f32(reg0), vreinterpretq_u32_f32(reg1) ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_or" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_min' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1798, + "column": 3, + "source_line": " #define stbir__simdf_min( out, reg0, reg1 ) (out) = vminq_f32( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_min" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_max' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1799, + "column": 3, + "source_line": " #define stbir__simdf_max( out, reg0, reg1 ) (out) = vmaxq_f32( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_max" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_min1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1800, + "column": 3, + "source_line": " #define stbir__simdf_min1( out, reg0, reg1 ) (out) = vminq_f32( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_min1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_max1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1801, + "column": 3, + "source_line": " #define stbir__simdf_max1( out, reg0, reg1 ) (out) = vmaxq_f32( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_max1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_0123ABCDto3ABx' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1803, + "column": 3, + "source_line": " #define stbir__simdf_0123ABCDto3ABx( out, reg0, reg1 ) (out) = vextq_f32( reg0, reg1, 3 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_0123ABCDto3ABx" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_0123ABCDto23Ax' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1804, + "column": 3, + "source_line": " #define stbir__simdf_0123ABCDto23Ax( out, reg0, reg1 ) (out) = vextq_f32( reg0, reg1, 2 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_0123ABCDto23Ax" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_a1a1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1806, + "column": 3, + "source_line": " #define stbir__simdf_a1a1( out, alp, ones ) (out) = vzipq_f32(vuzpq_f32(alp, alp).val[1], ones).val[0]" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_a1a1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_1a1a' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1807, + "column": 3, + "source_line": " #define stbir__simdf_1a1a( out, alp, ones ) (out) = vzipq_f32(ones, vuzpq_f32(alp, alp).val[0]).val[0]" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_1a1a" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_aaa1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1811, + "column": 5, + "source_line": " #define stbir__simdf_aaa1( out, alp, ones ) (out) = vcopyq_laneq_f32(vdupq_n_f32(vgetq_lane_f32(alp, 3)), 3, ones, 3)" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_aaa1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_1aaa' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1812, + "column": 5, + "source_line": " #define stbir__simdf_1aaa( out, alp, ones ) (out) = vcopyq_laneq_f32(vdupq_n_f32(vgetq_lane_f32(alp, 0)), 0, ones, 0)" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_1aaa" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir_make16' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1815, + "column": 7, + "source_line": " #define stbir_make16(a,b,c,d) vcombine_u8( \\" + }, + "unit_kind": "macro", + "unit_name": "stbir_make16" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir_make16' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1827, + "column": 7, + "source_line": " #define stbir_make16(a,b,c,d) (uint8x16_t){4*a+0,4*a+1,4*a+2,4*a+3,4*b+0,4*b+1,4*b+2,4*b+3,4*c+0,4*c+1,4*c+2,4*c+3,4*d+0,4*d+1,4*d+2,4*d+3}" + }, + "unit_kind": "macro", + "unit_name": "stbir_make16" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir_make16x2' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1828, + "column": 7, + "source_line": " #define stbir_make16x2(a,b) (uint8x16x2_t){{vreinterpretq_u8_f32(a),vreinterpretq_u8_f32(b)}}" + }, + "unit_kind": "macro", + "unit_name": "stbir_make16x2" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_swiz' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1831, + "column": 5, + "source_line": " #define stbir__simdf_swiz( reg, one, two, three, four ) vreinterpretq_f32_u8( vqtbl1q_u8( vreinterpretq_u8_f32(reg), stbir_make16(one, two, three, four) ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_swiz" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_swiz2' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1832, + "column": 5, + "source_line": " #define stbir__simdf_swiz2( rega, regb, one, two, three, four ) vreinterpretq_f32_u8( vqtbl2q_u8( stbir_make16x2(rega,regb), stbir_make16(one, two, three, four) ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_swiz2" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_16madd' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1834, + "column": 5, + "source_line": " #define stbir__simdi_16madd( out, reg0, reg1 ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_16madd" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_aaa1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1845, + "column": 5, + "source_line": " #define stbir__simdf_aaa1( out, alp, ones ) (out) = vsetq_lane_f32(1.0f, vdupq_n_f32(vgetq_lane_f32(alp, 3)), 3)" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_aaa1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_1aaa' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1846, + "column": 5, + "source_line": " #define stbir__simdf_1aaa( out, alp, ones ) (out) = vsetq_lane_f32(1.0f, vdupq_n_f32(vgetq_lane_f32(alp, 0)), 0)" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_1aaa" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir_make8' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1854, + "column": 7, + "source_line": " #define stbir_make8(a,b) vcreate_u8( \\" + }, + "unit_kind": "macro", + "unit_name": "stbir_make8" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir_make8x2' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1858, + "column": 7, + "source_line": " #define stbir_make8x2(reg) (uint8x8x2_t){ { vget_low_u8(vreinterpretq_u8_f32(reg)), vget_high_u8(vreinterpretq_u8_f32(reg)) } }" + }, + "unit_kind": "macro", + "unit_name": "stbir_make8x2" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir_make8' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1859, + "column": 7, + "source_line": " #define stbir_make8(a,b) (uint8x8_t){4*a+0,4*a+1,4*a+2,4*a+3,4*b+0,4*b+1,4*b+2,4*b+3}" + }, + "unit_kind": "macro", + "unit_name": "stbir_make8" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_swiz' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1862, + "column": 5, + "source_line": " #define stbir__simdf_swiz( reg, one, two, three, four ) vreinterpretq_f32_u8( vcombine_u8( \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_swiz" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_16madd' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1866, + "column": 5, + "source_line": " #define stbir__simdi_16madd( out, reg0, reg1 ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_16madd" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_and' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1879, + "column": 3, + "source_line": " #define stbir__simdi_and( out, reg0, reg1 ) (out) = vandq_u32( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_and" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_or' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1880, + "column": 3, + "source_line": " #define stbir__simdi_or( out, reg0, reg1 ) (out) = vorrq_u32( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_or" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_pack_to_8bytes' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1882, + "column": 3, + "source_line": " #define stbir__simdf_pack_to_8bytes(out,aa,bb) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_pack_to_8bytes" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_pack_to_8words' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1892, + "column": 3, + "source_line": " #define stbir__simdf_pack_to_8words(out,aa,bb) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_pack_to_8words" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__interleave_pack_and_store_16_u8' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1901, + "column": 3, + "source_line": " #define stbir__interleave_pack_and_store_16_u8( ptr, r0, r1, r2, r3 ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__interleave_pack_and_store_16_u8" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_load4_transposed' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1913, + "column": 3, + "source_line": " #define stbir__simdf_load4_transposed( o0, o1, o2, o3, ptr ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_load4_transposed" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_32shr' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1922, + "column": 3, + "source_line": " #define stbir__simdi_32shr( out, reg, imm ) out = vshrq_n_u32( reg, imm )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_32shr" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR__SIMDF_CONST' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1925, + "column": 5, + "source_line": " #define STBIR__SIMDF_CONST(var, x) __declspec(align(8)) float var[] = { x, x, x, x }" + }, + "unit_kind": "macro", + "unit_name": "STBIR__SIMDF_CONST" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR__SIMDI_CONST' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1926, + "column": 5, + "source_line": " #define STBIR__SIMDI_CONST(var, x) __declspec(align(8)) uint32_t var[] = { x, x, x, x }" + }, + "unit_kind": "macro", + "unit_name": "STBIR__SIMDI_CONST" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR__CONSTF' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1927, + "column": 5, + "source_line": " #define STBIR__CONSTF(var) (*(const float32x4_t*)var)" + }, + "unit_kind": "macro", + "unit_name": "STBIR__CONSTF" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR__CONSTI' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1928, + "column": 5, + "source_line": " #define STBIR__CONSTI(var) (*(const uint32x4_t*)var)" + }, + "unit_kind": "macro", + "unit_name": "STBIR__CONSTI" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR__SIMDF_CONST' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1930, + "column": 5, + "source_line": " #define STBIR__SIMDF_CONST(var, x) stbir__simdf var = { x, x, x, x }" + }, + "unit_kind": "macro", + "unit_name": "STBIR__SIMDF_CONST" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR__SIMDI_CONST' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1931, + "column": 5, + "source_line": " #define STBIR__SIMDI_CONST(var, x) stbir__simdi var = { x, x, x, x }" + }, + "unit_kind": "macro", + "unit_name": "STBIR__SIMDI_CONST" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR__CONSTF' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1932, + "column": 5, + "source_line": " #define STBIR__CONSTF(var) (var)" + }, + "unit_kind": "macro", + "unit_name": "STBIR__CONSTF" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR__CONSTI' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1933, + "column": 5, + "source_line": " #define STBIR__CONSTI(var) (var)" + }, + "unit_kind": "macro", + "unit_name": "STBIR__CONSTI" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir_simdi_castf' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1981, + "column": 3, + "source_line": " #define stbir_simdi_castf( reg ) (reg)" + }, + "unit_kind": "macro", + "unit_name": "stbir_simdi_castf" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir_simdf_casti' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1982, + "column": 3, + "source_line": " #define stbir_simdf_casti( reg ) (reg)" + }, + "unit_kind": "macro", + "unit_name": "stbir_simdf_casti" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_load' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1984, + "column": 3, + "source_line": " #define stbir__simdf_load( reg, ptr ) (reg) = wasm_v128_load( (void const*)(ptr) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_load" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_load' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1985, + "column": 3, + "source_line": " #define stbir__simdi_load( reg, ptr ) (reg) = wasm_v128_load( (void const*)(ptr) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_load" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_load1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1986, + "column": 3, + "source_line": " #define stbir__simdf_load1( out, ptr ) (out) = wasm_v128_load32_splat( (void const*)(ptr) ) // top values can be random (not denormal or nan for perf)" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_load1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_load1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1987, + "column": 3, + "source_line": " #define stbir__simdi_load1( out, ptr ) (out) = wasm_v128_load32_splat( (void const*)(ptr) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_load1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_load1z' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1988, + "column": 3, + "source_line": " #define stbir__simdf_load1z( out, ptr ) (out) = wasm_v128_load32_zero( (void const*)(ptr) ) // top values must be zero" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_load1z" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_frep4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1989, + "column": 3, + "source_line": " #define stbir__simdf_frep4( fvar ) wasm_f32x4_splat( fvar )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_frep4" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_load1frep4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1990, + "column": 3, + "source_line": " #define stbir__simdf_load1frep4( out, fvar ) (out) = wasm_f32x4_splat( fvar )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_load1frep4" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_load2' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1991, + "column": 3, + "source_line": " #define stbir__simdf_load2( out, ptr ) (out) = wasm_v128_load64_splat( (void const*)(ptr) ) // top values can be random (not denormal or nan for perf)" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_load2" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_load2z' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1992, + "column": 3, + "source_line": " #define stbir__simdf_load2z( out, ptr ) (out) = wasm_v128_load64_zero( (void const*)(ptr) ) // top values must be zero" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_load2z" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_load2hmerge' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1993, + "column": 3, + "source_line": " #define stbir__simdf_load2hmerge( out, reg, ptr ) (out) = wasm_v128_load64_lane( (void const*)(ptr), reg, 1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_load2hmerge" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_zeroP' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1995, + "column": 3, + "source_line": " #define stbir__simdf_zeroP() wasm_f32x4_const_splat(0)" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_zeroP" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_zero' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1996, + "column": 3, + "source_line": " #define stbir__simdf_zero( reg ) (reg) = wasm_f32x4_const_splat(0)" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_zero" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_store' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1998, + "column": 3, + "source_line": " #define stbir__simdf_store( ptr, reg ) wasm_v128_store( (void*)(ptr), reg )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_store" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_store1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1999, + "column": 3, + "source_line": " #define stbir__simdf_store1( ptr, reg ) wasm_v128_store32_lane( (void*)(ptr), reg, 0 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_store1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_store2' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2000, + "column": 3, + "source_line": " #define stbir__simdf_store2( ptr, reg ) wasm_v128_store64_lane( (void*)(ptr), reg, 0 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_store2" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_store2h' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2001, + "column": 3, + "source_line": " #define stbir__simdf_store2h( ptr, reg ) wasm_v128_store64_lane( (void*)(ptr), reg, 1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_store2h" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_store' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2003, + "column": 3, + "source_line": " #define stbir__simdi_store( ptr, reg ) wasm_v128_store( (void*)(ptr), reg )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_store" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_store1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2004, + "column": 3, + "source_line": " #define stbir__simdi_store1( ptr, reg ) wasm_v128_store32_lane( (void*)(ptr), reg, 0 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_store1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_store2' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2005, + "column": 3, + "source_line": " #define stbir__simdi_store2( ptr, reg ) wasm_v128_store64_lane( (void*)(ptr), reg, 0 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_store2" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__prefetch' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2007, + "column": 3, + "source_line": " #define stbir__prefetch( ptr )" + }, + "unit_kind": "macro", + "unit_name": "stbir__prefetch" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_expand_u8_to_u32' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2009, + "column": 3, + "source_line": " #define stbir__simdi_expand_u8_to_u32(out0,out1,out2,out3,ireg) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_expand_u8_to_u32" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_expand_u8_to_1u32' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2019, + "column": 3, + "source_line": " #define stbir__simdi_expand_u8_to_1u32(out,ireg) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_expand_u8_to_1u32" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_expand_u16_to_u32' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2025, + "column": 3, + "source_line": " #define stbir__simdi_expand_u16_to_u32(out0,out1,ireg) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_expand_u16_to_u32" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_convert_float_to_i32' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2031, + "column": 3, + "source_line": " #define stbir__simdf_convert_float_to_i32( i, f ) (i) = wasm_i32x4_trunc_sat_f32x4(f)" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_convert_float_to_i32" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_convert_float_to_int' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2032, + "column": 3, + "source_line": " #define stbir__simdf_convert_float_to_int( f ) wasm_i32x4_extract_lane(wasm_i32x4_trunc_sat_f32x4(f), 0)" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_convert_float_to_int" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_to_int' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2033, + "column": 3, + "source_line": " #define stbir__simdi_to_int( i ) wasm_i32x4_extract_lane(i, 0)" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_to_int" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_convert_float_to_uint8' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2034, + "column": 3, + "source_line": " #define stbir__simdf_convert_float_to_uint8( f ) ((unsigned char)wasm_i32x4_extract_lane(wasm_i32x4_trunc_sat_f32x4(wasm_f32x4_max(wasm_f32x4_min(f,STBIR_max_uint8_as_float),wasm_f32x4_const_splat(0))), 0))" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_convert_float_to_uint8" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_convert_float_to_short' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2035, + "column": 3, + "source_line": " #define stbir__simdf_convert_float_to_short( f ) ((unsigned short)wasm_i32x4_extract_lane(wasm_i32x4_trunc_sat_f32x4(wasm_f32x4_max(wasm_f32x4_min(f,STBIR_max_uint16_as_float),wasm_f32x4_const_splat(0))), 0))" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_convert_float_to_short" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_convert_i32_to_float' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2036, + "column": 3, + "source_line": " #define stbir__simdi_convert_i32_to_float(out, ireg) (out) = wasm_f32x4_convert_i32x4(ireg)" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_convert_i32_to_float" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_add' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2037, + "column": 3, + "source_line": " #define stbir__simdf_add( out, reg0, reg1 ) (out) = wasm_f32x4_add( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_add" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_mult' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2038, + "column": 3, + "source_line": " #define stbir__simdf_mult( out, reg0, reg1 ) (out) = wasm_f32x4_mul( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_mult" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_mult_mem' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2039, + "column": 3, + "source_line": " #define stbir__simdf_mult_mem( out, reg, ptr ) (out) = wasm_f32x4_mul( reg, wasm_v128_load( (void const*)(ptr) ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_mult_mem" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_mult1_mem' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2040, + "column": 3, + "source_line": " #define stbir__simdf_mult1_mem( out, reg, ptr ) (out) = wasm_f32x4_mul( reg, wasm_v128_load32_splat( (void const*)(ptr) ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_mult1_mem" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_add_mem' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2041, + "column": 3, + "source_line": " #define stbir__simdf_add_mem( out, reg, ptr ) (out) = wasm_f32x4_add( reg, wasm_v128_load( (void const*)(ptr) ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_add_mem" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_add1_mem' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2042, + "column": 3, + "source_line": " #define stbir__simdf_add1_mem( out, reg, ptr ) (out) = wasm_f32x4_add( reg, wasm_v128_load32_splat( (void const*)(ptr) ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_add1_mem" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_madd' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2044, + "column": 3, + "source_line": " #define stbir__simdf_madd( out, add, mul1, mul2 ) (out) = wasm_f32x4_add( add, wasm_f32x4_mul( mul1, mul2 ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_madd" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_madd1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2045, + "column": 3, + "source_line": " #define stbir__simdf_madd1( out, add, mul1, mul2 ) (out) = wasm_f32x4_add( add, wasm_f32x4_mul( mul1, mul2 ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_madd1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_madd_mem' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2046, + "column": 3, + "source_line": " #define stbir__simdf_madd_mem( out, add, mul, ptr ) (out) = wasm_f32x4_add( add, wasm_f32x4_mul( mul, wasm_v128_load( (void const*)(ptr) ) ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_madd_mem" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_madd1_mem' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2047, + "column": 3, + "source_line": " #define stbir__simdf_madd1_mem( out, add, mul, ptr ) (out) = wasm_f32x4_add( add, wasm_f32x4_mul( mul, wasm_v128_load32_splat( (void const*)(ptr) ) ) )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_madd1_mem" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_add1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2049, + "column": 3, + "source_line": " #define stbir__simdf_add1( out, reg0, reg1 ) (out) = wasm_f32x4_add( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_add1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_mult1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2050, + "column": 3, + "source_line": " #define stbir__simdf_mult1( out, reg0, reg1 ) (out) = wasm_f32x4_mul( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_mult1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_and' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2052, + "column": 3, + "source_line": " #define stbir__simdf_and( out, reg0, reg1 ) (out) = wasm_v128_and( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_and" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_or' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2053, + "column": 3, + "source_line": " #define stbir__simdf_or( out, reg0, reg1 ) (out) = wasm_v128_or( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_or" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_min' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2055, + "column": 3, + "source_line": " #define stbir__simdf_min( out, reg0, reg1 ) (out) = wasm_f32x4_min( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_min" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_max' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2056, + "column": 3, + "source_line": " #define stbir__simdf_max( out, reg0, reg1 ) (out) = wasm_f32x4_max( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_max" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_min1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2057, + "column": 3, + "source_line": " #define stbir__simdf_min1( out, reg0, reg1 ) (out) = wasm_f32x4_min( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_min1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_max1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2058, + "column": 3, + "source_line": " #define stbir__simdf_max1( out, reg0, reg1 ) (out) = wasm_f32x4_max( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_max1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_0123ABCDto3ABx' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2060, + "column": 3, + "source_line": " #define stbir__simdf_0123ABCDto3ABx( out, reg0, reg1 ) (out) = wasm_i32x4_shuffle( reg0, reg1, 3, 4, 5, -1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_0123ABCDto3ABx" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_0123ABCDto23Ax' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2061, + "column": 3, + "source_line": " #define stbir__simdf_0123ABCDto23Ax( out, reg0, reg1 ) (out) = wasm_i32x4_shuffle( reg0, reg1, 2, 3, 4, -1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_0123ABCDto23Ax" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_aaa1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2063, + "column": 3, + "source_line": " #define stbir__simdf_aaa1(out,alp,ones) (out) = wasm_i32x4_shuffle(alp, ones, 3, 3, 3, 4)" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_aaa1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_1aaa' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2064, + "column": 3, + "source_line": " #define stbir__simdf_1aaa(out,alp,ones) (out) = wasm_i32x4_shuffle(alp, ones, 4, 0, 0, 0)" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_1aaa" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_a1a1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2065, + "column": 3, + "source_line": " #define stbir__simdf_a1a1(out,alp,ones) (out) = wasm_i32x4_shuffle(alp, ones, 1, 4, 3, 4)" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_a1a1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_1a1a' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2066, + "column": 3, + "source_line": " #define stbir__simdf_1a1a(out,alp,ones) (out) = wasm_i32x4_shuffle(alp, ones, 4, 0, 4, 2)" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_1a1a" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_swiz' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2068, + "column": 3, + "source_line": " #define stbir__simdf_swiz( reg, one, two, three, four ) wasm_i32x4_shuffle(reg, reg, one, two, three, four)" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_swiz" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_and' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2070, + "column": 3, + "source_line": " #define stbir__simdi_and( out, reg0, reg1 ) (out) = wasm_v128_and( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_and" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_or' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2071, + "column": 3, + "source_line": " #define stbir__simdi_or( out, reg0, reg1 ) (out) = wasm_v128_or( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_or" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_16madd' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2072, + "column": 3, + "source_line": " #define stbir__simdi_16madd( out, reg0, reg1 ) (out) = wasm_i32x4_dot_i16x8( reg0, reg1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_16madd" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_pack_to_8bytes' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2074, + "column": 3, + "source_line": " #define stbir__simdf_pack_to_8bytes(out,aa,bb) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_pack_to_8bytes" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_pack_to_8words' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2084, + "column": 3, + "source_line": " #define stbir__simdf_pack_to_8words(out,aa,bb) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_pack_to_8words" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__interleave_pack_and_store_16_u8' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2093, + "column": 3, + "source_line": " #define stbir__interleave_pack_and_store_16_u8( ptr, r0, r1, r2, r3 ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__interleave_pack_and_store_16_u8" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_load4_transposed' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2102, + "column": 3, + "source_line": " #define stbir__simdf_load4_transposed( o0, o1, o2, o3, ptr ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_load4_transposed" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_32shr' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2118, + "column": 3, + "source_line": " #define stbir__simdi_32shr( out, reg, imm ) out = wasm_u32x4_shr( reg, imm )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_32shr" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR__SIMDF_CONST' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2121, + "column": 3, + "source_line": " #define STBIR__SIMDF_CONST(var, x) stbir__simdf var = (v128_t)(stbir__f32x4){ x, x, x, x }" + }, + "unit_kind": "macro", + "unit_name": "STBIR__SIMDF_CONST" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR__SIMDI_CONST' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2122, + "column": 3, + "source_line": " #define STBIR__SIMDI_CONST(var, x) stbir__simdi var = { x, x, x, x }" + }, + "unit_kind": "macro", + "unit_name": "STBIR__SIMDI_CONST" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR__CONSTF' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2123, + "column": 3, + "source_line": " #define STBIR__CONSTF(var) (var)" + }, + "unit_kind": "macro", + "unit_name": "STBIR__CONSTF" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR__CONSTI' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2124, + "column": 3, + "source_line": " #define STBIR__CONSTI(var) (var)" + }, + "unit_kind": "macro", + "unit_name": "STBIR__CONSTI" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__if_simdf8_cast_to_simdf4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2210, + "column": 3, + "source_line": " #define stbir__if_simdf8_cast_to_simdf4( val ) ( val )" + }, + "unit_kind": "macro", + "unit_name": "stbir__if_simdf8_cast_to_simdf4" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_0123to3333' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2536, + "column": 1, + "source_line": "#define stbir__simdf_0123to3333( out, reg ) (out) = stbir__simdf_swiz( reg, 3,3,3,3 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_0123to3333" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_0123to2222' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2537, + "column": 1, + "source_line": "#define stbir__simdf_0123to2222( out, reg ) (out) = stbir__simdf_swiz( reg, 2,2,2,2 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_0123to2222" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_0123to1111' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2538, + "column": 1, + "source_line": "#define stbir__simdf_0123to1111( out, reg ) (out) = stbir__simdf_swiz( reg, 1,1,1,1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_0123to1111" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_0123to0000' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2539, + "column": 1, + "source_line": "#define stbir__simdf_0123to0000( out, reg ) (out) = stbir__simdf_swiz( reg, 0,0,0,0 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_0123to0000" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_0123to0003' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2540, + "column": 1, + "source_line": "#define stbir__simdf_0123to0003( out, reg ) (out) = stbir__simdf_swiz( reg, 0,0,0,3 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_0123to0003" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_0123to0001' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2541, + "column": 1, + "source_line": "#define stbir__simdf_0123to0001( out, reg ) (out) = stbir__simdf_swiz( reg, 0,0,0,1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_0123to0001" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_0123to1122' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2542, + "column": 1, + "source_line": "#define stbir__simdf_0123to1122( out, reg ) (out) = stbir__simdf_swiz( reg, 1,1,2,2 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_0123to1122" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_0123to2333' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2543, + "column": 1, + "source_line": "#define stbir__simdf_0123to2333( out, reg ) (out) = stbir__simdf_swiz( reg, 2,3,3,3 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_0123to2333" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_0123to0023' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2544, + "column": 1, + "source_line": "#define stbir__simdf_0123to0023( out, reg ) (out) = stbir__simdf_swiz( reg, 0,0,2,3 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_0123to0023" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_0123to1230' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2545, + "column": 1, + "source_line": "#define stbir__simdf_0123to1230( out, reg ) (out) = stbir__simdf_swiz( reg, 1,2,3,0 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_0123to1230" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_0123to2103' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2546, + "column": 1, + "source_line": "#define stbir__simdf_0123to2103( out, reg ) (out) = stbir__simdf_swiz( reg, 2,1,0,3 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_0123to2103" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_0123to3210' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2547, + "column": 1, + "source_line": "#define stbir__simdf_0123to3210( out, reg ) (out) = stbir__simdf_swiz( reg, 3,2,1,0 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_0123to3210" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_0123to2301' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2548, + "column": 1, + "source_line": "#define stbir__simdf_0123to2301( out, reg ) (out) = stbir__simdf_swiz( reg, 2,3,0,1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_0123to2301" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_0123to3012' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2549, + "column": 1, + "source_line": "#define stbir__simdf_0123to3012( out, reg ) (out) = stbir__simdf_swiz( reg, 3,0,1,2 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_0123to3012" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_0123to0011' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2550, + "column": 1, + "source_line": "#define stbir__simdf_0123to0011( out, reg ) (out) = stbir__simdf_swiz( reg, 0,0,1,1 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_0123to0011" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_0123to1100' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2551, + "column": 1, + "source_line": "#define stbir__simdf_0123to1100( out, reg ) (out) = stbir__simdf_swiz( reg, 1,1,0,0 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_0123to1100" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_0123to2233' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2552, + "column": 1, + "source_line": "#define stbir__simdf_0123to2233( out, reg ) (out) = stbir__simdf_swiz( reg, 2,2,3,3 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_0123to2233" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_0123to1133' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2553, + "column": 1, + "source_line": "#define stbir__simdf_0123to1133( out, reg ) (out) = stbir__simdf_swiz( reg, 1,1,3,3 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_0123to1133" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_0123to0022' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2554, + "column": 1, + "source_line": "#define stbir__simdf_0123to0022( out, reg ) (out) = stbir__simdf_swiz( reg, 0,0,2,2 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_0123to0022" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdf_0123to1032' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2555, + "column": 1, + "source_line": "#define stbir__simdf_0123to1032( out, reg ) (out) = stbir__simdf_swiz( reg, 1,0,3,2 )" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdf_0123to1032" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_SIMD_STREAMOUT_PTR' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2581, + "column": 1, + "source_line": "#define STBIR_SIMD_STREAMOUT_PTR( star ) STBIR_STREAMOUT_PTR( star )" + }, + "unit_kind": "macro", + "unit_name": "STBIR_SIMD_STREAMOUT_PTR" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_SIMD_NO_UNROLL' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2582, + "column": 1, + "source_line": "#define STBIR_SIMD_NO_UNROLL(ptr) STBIR_NO_UNROLL(ptr)" + }, + "unit_kind": "macro", + "unit_name": "STBIR_SIMD_NO_UNROLL" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_SIMD_STREAMOUT_PTR' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2719, + "column": 1, + "source_line": "#define STBIR_SIMD_STREAMOUT_PTR( star ) STBIR_STREAMOUT_PTR( star )" + }, + "unit_kind": "macro", + "unit_name": "STBIR_SIMD_STREAMOUT_PTR" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_SIMD_NO_UNROLL' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2720, + "column": 1, + "source_line": "#define STBIR_SIMD_NO_UNROLL(ptr)" + }, + "unit_kind": "macro", + "unit_name": "STBIR_SIMD_NO_UNROLL" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_PROFILE_FUNC' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2736, + "column": 3, + "source_line": " #define STBIR_PROFILE_FUNC() __rdtsc()" + }, + "unit_kind": "macro", + "unit_name": "STBIR_PROFILE_FUNC" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_PROFILE_FUNC' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2753, + "column": 3, + "source_line": " #define STBIR_PROFILE_FUNC() _ReadStatusReg(ARM64_CNTVCT)" + }, + "unit_kind": "macro", + "unit_name": "STBIR_PROFILE_FUNC" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_PROFILE_START_ll' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2781, + "column": 1, + "source_line": "#define STBIR_PROFILE_START_ll( info, wh ) { stbir_uint64 wh##thiszonetime = STBIR_PROFILE_FUNC(); stbir_uint64 * wh##save_parent_excluded_ptr = info->current_zone_excluded_ptr; stbir_uint64 wh##current_zone_excluded = 0; info->current_zone_excluded_ptr = &wh##current_zone_excluded;" + }, + "unit_kind": "macro", + "unit_name": "STBIR_PROFILE_START_ll" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_PROFILE_END_ll' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2782, + "column": 1, + "source_line": "#define STBIR_PROFILE_END_ll( info, wh ) wh##thiszonetime = STBIR_PROFILE_FUNC() - wh##thiszonetime; info->profile.named.wh += wh##thiszonetime - wh##current_zone_excluded; *wh##save_parent_excluded_ptr += wh##thiszonetime; info->current_zone_excluded_ptr = wh##save_parent_excluded_ptr; }" + }, + "unit_kind": "macro", + "unit_name": "STBIR_PROFILE_END_ll" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_PROFILE_FIRST_START_ll' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2783, + "column": 1, + "source_line": "#define STBIR_PROFILE_FIRST_START_ll( info, wh ) { int i; info->current_zone_excluded_ptr = &info->profile.named.total; for(i=0;iprofile.array);i++) info->profile.array[i]=0; } STBIR_PROFILE_START_ll( info, wh );" + }, + "unit_kind": "macro", + "unit_name": "STBIR_PROFILE_FIRST_START_ll" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_PROFILE_CLEAR_EXTRAS_ll' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2784, + "column": 1, + "source_line": "#define STBIR_PROFILE_CLEAR_EXTRAS_ll( info, num ) { int extra; for(extra=1;extra<(num);extra++) { int i; for(i=0;iprofile.array);i++) (info)[extra].profile.array[i]=0; } }" + }, + "unit_kind": "macro", + "unit_name": "STBIR_PROFILE_CLEAR_EXTRAS_ll" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_PROFILE_START' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2787, + "column": 1, + "source_line": "#define STBIR_PROFILE_START( wh ) STBIR_PROFILE_START_ll( split_info, wh )" + }, + "unit_kind": "macro", + "unit_name": "STBIR_PROFILE_START" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_PROFILE_END' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2788, + "column": 1, + "source_line": "#define STBIR_PROFILE_END( wh ) STBIR_PROFILE_END_ll( split_info, wh )" + }, + "unit_kind": "macro", + "unit_name": "STBIR_PROFILE_END" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_PROFILE_FIRST_START' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2789, + "column": 1, + "source_line": "#define STBIR_PROFILE_FIRST_START( wh ) STBIR_PROFILE_FIRST_START_ll( split_info, wh )" + }, + "unit_kind": "macro", + "unit_name": "STBIR_PROFILE_FIRST_START" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_PROFILE_CLEAR_EXTRAS' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2790, + "column": 1, + "source_line": "#define STBIR_PROFILE_CLEAR_EXTRAS() STBIR_PROFILE_CLEAR_EXTRAS_ll( split_info, split_count )" + }, + "unit_kind": "macro", + "unit_name": "STBIR_PROFILE_CLEAR_EXTRAS" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_PROFILE_BUILD_START' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2793, + "column": 1, + "source_line": "#define STBIR_PROFILE_BUILD_START( wh ) STBIR_PROFILE_START_ll( profile_info, wh )" + }, + "unit_kind": "macro", + "unit_name": "STBIR_PROFILE_BUILD_START" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_PROFILE_BUILD_END' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2794, + "column": 1, + "source_line": "#define STBIR_PROFILE_BUILD_END( wh ) STBIR_PROFILE_END_ll( profile_info, wh )" + }, + "unit_kind": "macro", + "unit_name": "STBIR_PROFILE_BUILD_END" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_PROFILE_BUILD_FIRST_START' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2795, + "column": 1, + "source_line": "#define STBIR_PROFILE_BUILD_FIRST_START( wh ) STBIR_PROFILE_FIRST_START_ll( profile_info, wh )" + }, + "unit_kind": "macro", + "unit_name": "STBIR_PROFILE_BUILD_FIRST_START" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_PROFILE_BUILD_CLEAR' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2796, + "column": 1, + "source_line": "#define STBIR_PROFILE_BUILD_CLEAR( info ) { int i; for(i=0;iprofile.array);i++) info->profile.array[i]=0; }" + }, + "unit_kind": "macro", + "unit_name": "STBIR_PROFILE_BUILD_CLEAR" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_PROFILE_START' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2806, + "column": 1, + "source_line": "#define STBIR_PROFILE_START( wh )" + }, + "unit_kind": "macro", + "unit_name": "STBIR_PROFILE_START" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_PROFILE_END' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2807, + "column": 1, + "source_line": "#define STBIR_PROFILE_END( wh )" + }, + "unit_kind": "macro", + "unit_name": "STBIR_PROFILE_END" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_PROFILE_FIRST_START' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2808, + "column": 1, + "source_line": "#define STBIR_PROFILE_FIRST_START( wh )" + }, + "unit_kind": "macro", + "unit_name": "STBIR_PROFILE_FIRST_START" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_PROFILE_CLEAR_EXTRAS' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2809, + "column": 1, + "source_line": "#define STBIR_PROFILE_CLEAR_EXTRAS( )" + }, + "unit_kind": "macro", + "unit_name": "STBIR_PROFILE_CLEAR_EXTRAS" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_PROFILE_BUILD_START' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2811, + "column": 1, + "source_line": "#define STBIR_PROFILE_BUILD_START( wh )" + }, + "unit_kind": "macro", + "unit_name": "STBIR_PROFILE_BUILD_START" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_PROFILE_BUILD_END' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2812, + "column": 1, + "source_line": "#define STBIR_PROFILE_BUILD_END( wh )" + }, + "unit_kind": "macro", + "unit_name": "STBIR_PROFILE_BUILD_END" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_PROFILE_BUILD_FIRST_START' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2813, + "column": 1, + "source_line": "#define STBIR_PROFILE_BUILD_FIRST_START( wh )" + }, + "unit_kind": "macro", + "unit_name": "STBIR_PROFILE_BUILD_FIRST_START" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_PROFILE_BUILD_CLEAR' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2814, + "column": 1, + "source_line": "#define STBIR_PROFILE_BUILD_CLEAR( info )" + }, + "unit_kind": "macro", + "unit_name": "STBIR_PROFILE_BUILD_CLEAR" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_CEILF' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2821, + "column": 1, + "source_line": "#define STBIR_CEILF(x) ((float)ceil((float)(x)))" + }, + "unit_kind": "macro", + "unit_name": "STBIR_CEILF" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_FLOORF' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2822, + "column": 1, + "source_line": "#define STBIR_FLOORF(x) ((float)floor((float)(x)))" + }, + "unit_kind": "macro", + "unit_name": "STBIR_FLOORF" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_CEILF' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2824, + "column": 1, + "source_line": "#define STBIR_CEILF(x) ceilf(x)" + }, + "unit_kind": "macro", + "unit_name": "STBIR_CEILF" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_FLOORF' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2825, + "column": 1, + "source_line": "#define STBIR_FLOORF(x) floorf(x)" + }, + "unit_kind": "macro", + "unit_name": "STBIR_FLOORF" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_MEMCPY' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2832, + "column": 1, + "source_line": "#define STBIR_MEMCPY( dest, src, len ) memcpy( dest, src, len )" + }, + "unit_kind": "macro", + "unit_name": "STBIR_MEMCPY" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_MOVE_1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 3698, + "column": 3, + "source_line": " #define STBIR_MOVE_1( dest, src ) { STBIR_NO_UNROLL(dest); ((stbir_uint32*)(dest))[0] = ((stbir_uint32*)(src))[0]; }" + }, + "unit_kind": "macro", + "unit_name": "STBIR_MOVE_1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_MOVE_2' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 3699, + "column": 3, + "source_line": " #define STBIR_MOVE_2( dest, src ) { STBIR_NO_UNROLL(dest); ((stbir_uint64*)(dest))[0] = ((stbir_uint64*)(src))[0]; }" + }, + "unit_kind": "macro", + "unit_name": "STBIR_MOVE_2" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_MOVE_4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 3701, + "column": 3, + "source_line": " #define STBIR_MOVE_4( dest, src ) { stbir__simdf t; STBIR_NO_UNROLL(dest); stbir__simdf_load( t, src ); stbir__simdf_store( dest, t ); }" + }, + "unit_kind": "macro", + "unit_name": "STBIR_MOVE_4" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_MOVE_4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 3703, + "column": 3, + "source_line": " #define STBIR_MOVE_4( dest, src ) { STBIR_NO_UNROLL(dest); ((stbir_uint64*)(dest))[0] = ((stbir_uint64*)(src))[0]; ((stbir_uint64*)(dest))[1] = ((stbir_uint64*)(src))[1]; }" + }, + "unit_kind": "macro", + "unit_name": "STBIR_MOVE_4" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__1_coeff_only' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4710, + "column": 1, + "source_line": "#define stbir__1_coeff_only() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__1_coeff_only" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__2_coeff_only' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4716, + "column": 1, + "source_line": "#define stbir__2_coeff_only() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__2_coeff_only" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__3_coeff_only' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4725, + "column": 1, + "source_line": "#define stbir__3_coeff_only() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__3_coeff_only" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__store_output_tiny' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4735, + "column": 1, + "source_line": "#define stbir__store_output_tiny() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__store_output_tiny" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__4_coeff_start' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4741, + "column": 1, + "source_line": "#define stbir__4_coeff_start() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__4_coeff_start" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__4_coeff_continue_from_4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4747, + "column": 1, + "source_line": "#define stbir__4_coeff_continue_from_4( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__4_coeff_continue_from_4" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__1_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4752, + "column": 1, + "source_line": "#define stbir__1_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__1_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__2_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4758, + "column": 1, + "source_line": "#define stbir__2_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__2_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__3_coeff_setup' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4764, + "column": 1, + "source_line": "#define stbir__3_coeff_setup() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__3_coeff_setup" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__3_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4768, + "column": 1, + "source_line": "#define stbir__3_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__3_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__store_output' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4773, + "column": 1, + "source_line": "#define stbir__store_output() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__store_output" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__1_coeff_only' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4785, + "column": 1, + "source_line": "#define stbir__1_coeff_only() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__1_coeff_only" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__2_coeff_only' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4789, + "column": 1, + "source_line": "#define stbir__2_coeff_only() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__2_coeff_only" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__3_coeff_only' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4794, + "column": 1, + "source_line": "#define stbir__3_coeff_only() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__3_coeff_only" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__store_output_tiny' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4800, + "column": 1, + "source_line": "#define stbir__store_output_tiny() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__store_output_tiny" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__4_coeff_start' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4806, + "column": 1, + "source_line": "#define stbir__4_coeff_start() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__4_coeff_start" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__4_coeff_continue_from_4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4813, + "column": 1, + "source_line": "#define stbir__4_coeff_continue_from_4( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__4_coeff_continue_from_4" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__1_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4819, + "column": 1, + "source_line": "#define stbir__1_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__1_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__2_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4822, + "column": 1, + "source_line": "#define stbir__2_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__2_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__3_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4826, + "column": 1, + "source_line": "#define stbir__3_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__3_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__store_output' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4831, + "column": 1, + "source_line": "#define stbir__store_output() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__store_output" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__1_coeff_only' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4849, + "column": 1, + "source_line": "#define stbir__1_coeff_only() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__1_coeff_only" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__2_coeff_only' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4857, + "column": 1, + "source_line": "#define stbir__2_coeff_only() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__2_coeff_only" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__3_coeff_only' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4864, + "column": 1, + "source_line": "#define stbir__3_coeff_only() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__3_coeff_only" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__store_output_tiny' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4874, + "column": 1, + "source_line": "#define stbir__store_output_tiny() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__store_output_tiny" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__4_coeff_start' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4884, + "column": 1, + "source_line": "#define stbir__4_coeff_start() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__4_coeff_start" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__4_coeff_continue_from_4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4891, + "column": 1, + "source_line": "#define stbir__4_coeff_continue_from_4( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__4_coeff_continue_from_4" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__1_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4897, + "column": 1, + "source_line": "#define stbir__1_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__1_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__2_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4905, + "column": 1, + "source_line": "#define stbir__2_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__2_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__3_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4912, + "column": 1, + "source_line": "#define stbir__3_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__3_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__store_output' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4919, + "column": 1, + "source_line": "#define stbir__store_output() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__store_output" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__4_coeff_start' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4931, + "column": 1, + "source_line": "#define stbir__4_coeff_start() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__4_coeff_start" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__4_coeff_continue_from_4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4940, + "column": 1, + "source_line": "#define stbir__4_coeff_continue_from_4( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__4_coeff_continue_from_4" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__1_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4948, + "column": 1, + "source_line": "#define stbir__1_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__1_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__2_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4955, + "column": 1, + "source_line": "#define stbir__2_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__2_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__3_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4960, + "column": 1, + "source_line": "#define stbir__3_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__3_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__store_output' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4969, + "column": 1, + "source_line": "#define stbir__store_output() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__store_output" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__1_coeff_only' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4982, + "column": 1, + "source_line": "#define stbir__1_coeff_only() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__1_coeff_only" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__2_coeff_only' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4988, + "column": 1, + "source_line": "#define stbir__2_coeff_only() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__2_coeff_only" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__3_coeff_only' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4998, + "column": 1, + "source_line": "#define stbir__3_coeff_only() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__3_coeff_only" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__store_output_tiny' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5010, + "column": 1, + "source_line": "#define stbir__store_output_tiny() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__store_output_tiny" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__4_coeff_start' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5017, + "column": 1, + "source_line": "#define stbir__4_coeff_start() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__4_coeff_start" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__4_coeff_continue_from_4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5032, + "column": 1, + "source_line": "#define stbir__4_coeff_continue_from_4( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__4_coeff_continue_from_4" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__1_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5046, + "column": 1, + "source_line": "#define stbir__1_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__1_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__2_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5051, + "column": 1, + "source_line": "#define stbir__2_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__2_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__3_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5059, + "column": 1, + "source_line": "#define stbir__3_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__3_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__store_output' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5070, + "column": 1, + "source_line": "#define stbir__store_output() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__store_output" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__1_coeff_only' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5089, + "column": 1, + "source_line": "#define stbir__1_coeff_only() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__1_coeff_only" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__2_coeff_only' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5097, + "column": 1, + "source_line": "#define stbir__2_coeff_only() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__2_coeff_only" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__3_coeff_only' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5108, + "column": 1, + "source_line": "#define stbir__3_coeff_only() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__3_coeff_only" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__store_output_tiny' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5122, + "column": 1, + "source_line": "#define stbir__store_output_tiny() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__store_output_tiny" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__4_coeff_start' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5133, + "column": 1, + "source_line": "#define stbir__4_coeff_start() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__4_coeff_start" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__4_coeff_continue_from_4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5142, + "column": 1, + "source_line": "#define stbir__4_coeff_continue_from_4( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__4_coeff_continue_from_4" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__1_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5150, + "column": 1, + "source_line": "#define stbir__1_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__1_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__2_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5155, + "column": 1, + "source_line": "#define stbir__2_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__2_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__3_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5161, + "column": 2, + "source_line": " #define stbir__3_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__3_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__store_output' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5169, + "column": 1, + "source_line": "#define stbir__store_output() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__store_output" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__4_coeff_start' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5189, + "column": 1, + "source_line": "#define stbir__4_coeff_start() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__4_coeff_start" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__4_coeff_continue_from_4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5200, + "column": 1, + "source_line": "#define stbir__4_coeff_continue_from_4( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__4_coeff_continue_from_4" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__1_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5210, + "column": 1, + "source_line": "#define stbir__1_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__1_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__2_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5216, + "column": 1, + "source_line": "#define stbir__2_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__2_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__3_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5226, + "column": 1, + "source_line": "#define stbir__3_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__3_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__store_output' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5238, + "column": 1, + "source_line": "#define stbir__store_output() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__store_output" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__1_coeff_only' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5262, + "column": 1, + "source_line": "#define stbir__1_coeff_only() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__1_coeff_only" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__2_coeff_only' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5269, + "column": 1, + "source_line": "#define stbir__2_coeff_only() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__2_coeff_only" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__3_coeff_only' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5280, + "column": 1, + "source_line": "#define stbir__3_coeff_only() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__3_coeff_only" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__store_output_tiny' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5295, + "column": 1, + "source_line": "#define stbir__store_output_tiny() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__store_output_tiny" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__4_coeff_start' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5303, + "column": 1, + "source_line": "#define stbir__4_coeff_start() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__4_coeff_start" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__4_coeff_continue_from_4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5322, + "column": 1, + "source_line": "#define stbir__4_coeff_continue_from_4( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__4_coeff_continue_from_4" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__1_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5340, + "column": 1, + "source_line": "#define stbir__1_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__1_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__2_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5346, + "column": 1, + "source_line": "#define stbir__2_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__2_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__3_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5356, + "column": 1, + "source_line": "#define stbir__3_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__3_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__store_output' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5370, + "column": 1, + "source_line": "#define stbir__store_output() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__store_output" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__1_coeff_only' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5389, + "column": 1, + "source_line": "#define stbir__1_coeff_only() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__1_coeff_only" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__2_coeff_only' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5396, + "column": 1, + "source_line": "#define stbir__2_coeff_only() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__2_coeff_only" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__3_coeff_only' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5405, + "column": 1, + "source_line": "#define stbir__3_coeff_only() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__3_coeff_only" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__store_output_tiny' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5416, + "column": 1, + "source_line": "#define stbir__store_output_tiny() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__store_output_tiny" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__4_coeff_start' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5424, + "column": 1, + "source_line": "#define stbir__4_coeff_start() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__4_coeff_start" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__4_coeff_continue_from_4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5433, + "column": 1, + "source_line": "#define stbir__4_coeff_continue_from_4( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__4_coeff_continue_from_4" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__1_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5441, + "column": 1, + "source_line": "#define stbir__1_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__1_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__2_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5446, + "column": 1, + "source_line": "#define stbir__2_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__2_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__3_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5452, + "column": 2, + "source_line": " #define stbir__3_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__3_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__store_output' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5460, + "column": 1, + "source_line": "#define stbir__store_output() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__store_output" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__4_coeff_start' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5469, + "column": 1, + "source_line": "#define stbir__4_coeff_start() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__4_coeff_start" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__4_coeff_continue_from_4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5482, + "column": 1, + "source_line": "#define stbir__4_coeff_continue_from_4( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__4_coeff_continue_from_4" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__1_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5494, + "column": 1, + "source_line": "#define stbir__1_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__1_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__2_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5500, + "column": 1, + "source_line": "#define stbir__2_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__2_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__3_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5508, + "column": 1, + "source_line": "#define stbir__3_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__3_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__store_output' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5518, + "column": 1, + "source_line": "#define stbir__store_output() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__store_output" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__1_coeff_only' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5529, + "column": 1, + "source_line": "#define stbir__1_coeff_only() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__1_coeff_only" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__2_coeff_only' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5538, + "column": 1, + "source_line": "#define stbir__2_coeff_only() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__2_coeff_only" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__3_coeff_only' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5552, + "column": 1, + "source_line": "#define stbir__3_coeff_only() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__3_coeff_only" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__store_output_tiny' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5571, + "column": 1, + "source_line": "#define stbir__store_output_tiny() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__store_output_tiny" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__4_coeff_start' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5580, + "column": 1, + "source_line": "#define stbir__4_coeff_start() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__4_coeff_start" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__4_coeff_continue_from_4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5604, + "column": 1, + "source_line": "#define stbir__4_coeff_continue_from_4( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__4_coeff_continue_from_4" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__1_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5627, + "column": 1, + "source_line": "#define stbir__1_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__1_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__2_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5635, + "column": 1, + "source_line": "#define stbir__2_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__2_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__3_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5648, + "column": 1, + "source_line": "#define stbir__3_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__3_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__store_output' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5666, + "column": 1, + "source_line": "#define stbir__store_output() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__store_output" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__1_coeff_only' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5688, + "column": 1, + "source_line": "#define stbir__1_coeff_only() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__1_coeff_only" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__2_coeff_only' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5696, + "column": 1, + "source_line": "#define stbir__2_coeff_only() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__2_coeff_only" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__3_coeff_only' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5707, + "column": 1, + "source_line": "#define stbir__3_coeff_only() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__3_coeff_only" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__store_output_tiny' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5721, + "column": 1, + "source_line": "#define stbir__store_output_tiny() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__store_output_tiny" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__4_coeff_start' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5730, + "column": 1, + "source_line": "#define stbir__4_coeff_start() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__4_coeff_start" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__4_coeff_continue_from_4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5743, + "column": 1, + "source_line": "#define stbir__4_coeff_continue_from_4( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__4_coeff_continue_from_4" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__1_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5755, + "column": 1, + "source_line": "#define stbir__1_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__1_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__2_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5760, + "column": 1, + "source_line": "#define stbir__2_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__2_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__3_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5767, + "column": 1, + "source_line": "#define stbir__3_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__3_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__store_output' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5777, + "column": 1, + "source_line": "#define stbir__store_output() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__store_output" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__4_coeff_start' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5793, + "column": 1, + "source_line": "#define stbir__4_coeff_start() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__4_coeff_start" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__4_coeff_continue_from_4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5810, + "column": 1, + "source_line": "#define stbir__4_coeff_continue_from_4( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__4_coeff_continue_from_4" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__1_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5826, + "column": 1, + "source_line": "#define stbir__1_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__1_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__2_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5833, + "column": 1, + "source_line": "#define stbir__2_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__2_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__3_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5843, + "column": 1, + "source_line": "#define stbir__3_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__3_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__store_output' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5856, + "column": 1, + "source_line": "#define stbir__store_output() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__store_output" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__1_coeff_only' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5869, + "column": 1, + "source_line": "#define stbir__1_coeff_only() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__1_coeff_only" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__2_coeff_only' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5880, + "column": 1, + "source_line": "#define stbir__2_coeff_only() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__2_coeff_only" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__3_coeff_only' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5899, + "column": 1, + "source_line": "#define stbir__3_coeff_only() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__3_coeff_only" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__store_output_tiny' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5926, + "column": 1, + "source_line": "#define stbir__store_output_tiny() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__store_output_tiny" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__4_coeff_start' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5938, + "column": 1, + "source_line": "#define stbir__4_coeff_start() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__4_coeff_start" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__4_coeff_continue_from_4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 5974, + "column": 1, + "source_line": "#define stbir__4_coeff_continue_from_4( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__4_coeff_continue_from_4" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__1_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 6009, + "column": 1, + "source_line": "#define stbir__1_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__1_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__2_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 6020, + "column": 1, + "source_line": "#define stbir__2_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__2_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__3_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 6039, + "column": 1, + "source_line": "#define stbir__3_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__3_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__store_output' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 6066, + "column": 1, + "source_line": "#define stbir__store_output() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__store_output" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR__FLOAT_BUFFER_IS_EMPTY' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 6372, + "column": 1, + "source_line": "#define STBIR__FLOAT_BUFFER_IS_EMPTY(ptr) ((ptr)[0]==STBIR__FLOAT_EMPTY_MARKER)" + }, + "unit_kind": "macro", + "unit_name": "STBIR__FLOAT_BUFFER_IS_EMPTY" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR__FREE_AND_CLEAR' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 6819, + "column": 3, + "source_line": " #define STBIR__FREE_AND_CLEAR( ptr ) { if ( ptr ) { void * p = (ptr); (ptr) = 0; STBIR_FREE( p, info->user_data); } }" + }, + "unit_kind": "macro", + "unit_name": "STBIR__FREE_AND_CLEAR" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR__NEXT_PTR' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 7143, + "column": 5, + "source_line": " #define STBIR__NEXT_PTR( ptr, size, ntype ) if ( alloced ) { void * p = STBIR_MALLOC( size, user_data); if ( p == 0 ) { stbir__free_internal_mem( info ); return 0; } (ptr) = (ntype*)p; }" + }, + "unit_kind": "macro", + "unit_name": "STBIR__NEXT_PTR" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR__NEXT_PTR' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 7145, + "column": 5, + "source_line": " #define STBIR__NEXT_PTR( ptr, size, ntype ) advance_mem = (void*) ( ( ((size_t)advance_mem) + 15 ) & ~15 ); if ( alloced ) ptr = (ntype*)advance_mem; advance_mem = (char*)(((size_t)advance_mem) + (size));" + }, + "unit_kind": "macro", + "unit_name": "STBIR__NEXT_PTR" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_RETURN_ERROR_AND_ASSERT' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 7891, + "column": 3, + "source_line": " #define STBIR_RETURN_ERROR_AND_ASSERT( exp ) STBIR_ASSERT( !(exp) ); if (exp) return 0;" + }, + "unit_kind": "macro", + "unit_name": "STBIR_RETURN_ERROR_AND_ASSERT" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_strs_join2' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8253, + "column": 1, + "source_line": "#define STBIR_strs_join2( start, mid, end ) start##mid##end" + }, + "unit_kind": "macro", + "unit_name": "STBIR_strs_join2" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_strs_join1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8254, + "column": 1, + "source_line": "#define STBIR_strs_join1( start, mid, end ) STBIR_strs_join2( start, mid, end )" + }, + "unit_kind": "macro", + "unit_name": "STBIR_strs_join1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_strs_join24' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8256, + "column": 1, + "source_line": "#define STBIR_strs_join24( start, mid1, mid2, end ) start##mid1##mid2##end" + }, + "unit_kind": "macro", + "unit_name": "STBIR_strs_join24" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_strs_join14' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8257, + "column": 1, + "source_line": "#define STBIR_strs_join14( start, mid1, mid2, end ) STBIR_strs_join24( start, mid1, mid2, end )" + }, + "unit_kind": "macro", + "unit_name": "STBIR_strs_join14" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR__CODER_NAME' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8262, + "column": 1, + "source_line": "#define STBIR__CODER_NAME( name ) STBIR_strs_join1( name, _, stbir__decode_suffix )" + }, + "unit_kind": "macro", + "unit_name": "STBIR__CODER_NAME" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR__CODER_NAME' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8264, + "column": 1, + "source_line": "#define STBIR__CODER_NAME( name ) name" + }, + "unit_kind": "macro", + "unit_name": "STBIR__CODER_NAME" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__decode_simdf8_flip' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8268, + "column": 1, + "source_line": "#define stbir__decode_simdf8_flip(reg) STBIR_strs_join1( STBIR_strs_join1( STBIR_strs_join1( STBIR_strs_join1( stbir__simdf8_0123to,stbir__decode_order0,stbir__decode_order1),stbir__decode_order2,stbir__decode_order3),stbir__decode_order0,stbir__decode_order1),stbir__decode_order2,stbir__decode_order3)(reg, reg)" + }, + "unit_kind": "macro", + "unit_name": "stbir__decode_simdf8_flip" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__decode_simdf4_flip' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8269, + "column": 1, + "source_line": "#define stbir__decode_simdf4_flip(reg) STBIR_strs_join1( STBIR_strs_join1( stbir__simdf_0123to,stbir__decode_order0,stbir__decode_order1),stbir__decode_order2,stbir__decode_order3)(reg, reg)" + }, + "unit_kind": "macro", + "unit_name": "stbir__decode_simdf4_flip" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__encode_simdf8_unflip' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8270, + "column": 1, + "source_line": "#define stbir__encode_simdf8_unflip(reg) STBIR_strs_join1( STBIR_strs_join1( STBIR_strs_join1( STBIR_strs_join1( stbir__simdf8_0123to,stbir__encode_order0,stbir__encode_order1),stbir__encode_order2,stbir__encode_order3),stbir__encode_order0,stbir__encode_order1),stbir__encode_order2,stbir__encode_order3)(reg, reg)" + }, + "unit_kind": "macro", + "unit_name": "stbir__encode_simdf8_unflip" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__encode_simdf4_unflip' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8271, + "column": 1, + "source_line": "#define stbir__encode_simdf4_unflip(reg) STBIR_strs_join1( STBIR_strs_join1( stbir__simdf_0123to,stbir__encode_order0,stbir__encode_order1),stbir__encode_order2,stbir__encode_order3)(reg, reg)" + }, + "unit_kind": "macro", + "unit_name": "stbir__encode_simdf4_unflip" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__decode_simdf8_flip' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8281, + "column": 1, + "source_line": "#define stbir__decode_simdf8_flip(reg)" + }, + "unit_kind": "macro", + "unit_name": "stbir__decode_simdf8_flip" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__decode_simdf4_flip' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8282, + "column": 1, + "source_line": "#define stbir__decode_simdf4_flip(reg)" + }, + "unit_kind": "macro", + "unit_name": "stbir__decode_simdf4_flip" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__encode_simdf8_unflip' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8283, + "column": 1, + "source_line": "#define stbir__encode_simdf8_unflip(reg)" + }, + "unit_kind": "macro", + "unit_name": "stbir__encode_simdf8_unflip" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__encode_simdf4_unflip' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8284, + "column": 1, + "source_line": "#define stbir__encode_simdf4_unflip(reg)" + }, + "unit_kind": "macro", + "unit_name": "stbir__encode_simdf4_unflip" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__min_max_shift20' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8747, + "column": 1, + "source_line": "#define stbir__min_max_shift20( i, f ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__min_max_shift20" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__scale_and_convert' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8752, + "column": 1, + "source_line": "#define stbir__scale_and_convert( i, f ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__scale_and_convert" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__linear_to_srgb_finish' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8758, + "column": 1, + "source_line": "#define stbir__linear_to_srgb_finish( i, f ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__linear_to_srgb_finish" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_table_lookup2' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8768, + "column": 1, + "source_line": "#define stbir__simdi_table_lookup2( v0,v1, table ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_table_lookup2" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_table_lookup3' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8779, + "column": 1, + "source_line": "#define stbir__simdi_table_lookup3( v0,v1,v2, table ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_table_lookup3" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__simdi_table_lookup4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8793, + "column": 1, + "source_line": "#define stbir__simdi_table_lookup4( v0,v1,v2,v3, table ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__simdi_table_lookup4" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir_scalar_hi_clamp' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 9750, + "column": 3, + "source_line": " #define stbir_scalar_hi_clamp( v ) if ( v > STBIR_FLOAT_HIGH_CLAMP ) v = STBIR_FLOAT_HIGH_CLAMP;" + }, + "unit_kind": "macro", + "unit_name": "stbir_scalar_hi_clamp" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir_scalar_hi_clamp' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 9752, + "column": 3, + "source_line": " #define stbir_scalar_hi_clamp( v )" + }, + "unit_kind": "macro", + "unit_name": "stbir_scalar_hi_clamp" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir_scalar_lo_clamp' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 9755, + "column": 3, + "source_line": " #define stbir_scalar_lo_clamp( v ) if ( v < STBIR_FLOAT_LOW_CLAMP ) v = STBIR_FLOAT_LOW_CLAMP;" + }, + "unit_kind": "macro", + "unit_name": "stbir_scalar_lo_clamp" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir_scalar_lo_clamp' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 9757, + "column": 3, + "source_line": " #define stbir_scalar_lo_clamp( v )" + }, + "unit_kind": "macro", + "unit_name": "stbir_scalar_lo_clamp" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_chans' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 9896, + "column": 1, + "source_line": "#define STBIR_chans( start, end ) STBIR_strs_join14(start,STBIR__vertical_channels,end,_cont)" + }, + "unit_kind": "macro", + "unit_name": "STBIR_chans" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_chans' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 9898, + "column": 1, + "source_line": "#define STBIR_chans( start, end ) STBIR_strs_join1(start,STBIR__vertical_channels,end)" + }, + "unit_kind": "macro", + "unit_name": "STBIR_chans" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbIF0' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 9902, + "column": 1, + "source_line": "#define stbIF0( code ) code" + }, + "unit_kind": "macro", + "unit_name": "stbIF0" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbIF0' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 9904, + "column": 1, + "source_line": "#define stbIF0( code )" + }, + "unit_kind": "macro", + "unit_name": "stbIF0" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbIF1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 9907, + "column": 1, + "source_line": "#define stbIF1( code ) code" + }, + "unit_kind": "macro", + "unit_name": "stbIF1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbIF1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 9909, + "column": 1, + "source_line": "#define stbIF1( code )" + }, + "unit_kind": "macro", + "unit_name": "stbIF1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbIF2' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 9912, + "column": 1, + "source_line": "#define stbIF2( code ) code" + }, + "unit_kind": "macro", + "unit_name": "stbIF2" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbIF2' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 9914, + "column": 1, + "source_line": "#define stbIF2( code )" + }, + "unit_kind": "macro", + "unit_name": "stbIF2" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbIF3' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 9917, + "column": 1, + "source_line": "#define stbIF3( code ) code" + }, + "unit_kind": "macro", + "unit_name": "stbIF3" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbIF3' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 9919, + "column": 1, + "source_line": "#define stbIF3( code )" + }, + "unit_kind": "macro", + "unit_name": "stbIF3" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbIF4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 9922, + "column": 1, + "source_line": "#define stbIF4( code ) code" + }, + "unit_kind": "macro", + "unit_name": "stbIF4" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbIF4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 9924, + "column": 1, + "source_line": "#define stbIF4( code )" + }, + "unit_kind": "macro", + "unit_name": "stbIF4" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbIF5' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 9927, + "column": 1, + "source_line": "#define stbIF5( code ) code" + }, + "unit_kind": "macro", + "unit_name": "stbIF5" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbIF5' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 9929, + "column": 1, + "source_line": "#define stbIF5( code )" + }, + "unit_kind": "macro", + "unit_name": "stbIF5" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbIF6' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 9932, + "column": 1, + "source_line": "#define stbIF6( code ) code" + }, + "unit_kind": "macro", + "unit_name": "stbIF6" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbIF6' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 9934, + "column": 1, + "source_line": "#define stbIF6( code )" + }, + "unit_kind": "macro", + "unit_name": "stbIF6" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbIF7' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 9937, + "column": 1, + "source_line": "#define stbIF7( code ) code" + }, + "unit_kind": "macro", + "unit_name": "stbIF7" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbIF7' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 9939, + "column": 1, + "source_line": "#define stbIF7( code )" + }, + "unit_kind": "macro", + "unit_name": "stbIF7" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIR_chans' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 10282, + "column": 1, + "source_line": "#define STBIR_chans( start, end ) STBIR_strs_join1(start,STBIR__horizontal_channels,end)" + }, + "unit_kind": "macro", + "unit_name": "STBIR_chans" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__2_coeff_only' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 10285, + "column": 1, + "source_line": "#define stbir__2_coeff_only() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__2_coeff_only" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__2_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 10291, + "column": 1, + "source_line": "#define stbir__2_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__2_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__3_coeff_only' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 10297, + "column": 1, + "source_line": "#define stbir__3_coeff_only() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__3_coeff_only" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__3_coeff_remnant' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 10303, + "column": 1, + "source_line": "#define stbir__3_coeff_remnant( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__3_coeff_remnant" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__3_coeff_setup' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 10309, + "column": 1, + "source_line": "#define stbir__3_coeff_setup()" + }, + "unit_kind": "macro", + "unit_name": "stbir__3_coeff_setup" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__4_coeff_start' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 10313, + "column": 1, + "source_line": "#define stbir__4_coeff_start() \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__4_coeff_start" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbir__4_coeff_continue_from_4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 10319, + "column": 1, + "source_line": "#define stbir__4_coeff_continue_from_4( ofs ) \\" + }, + "unit_kind": "macro", + "unit_name": "stbir__4_coeff_continue_from_4" + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'stbir_uint64'.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 396, + "column": 1, + "source_line": "typedef unsigned __int64 stbir_uint64;" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 472, + "column": 1, + "source_line": "STBIRDEF unsigned char * stbir_resize_uint8_srgb( const unsigned char *input_pixels , int input_w , int input_h, int input_stride_in_bytes," + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 476, + "column": 1, + "source_line": "STBIRDEF unsigned char * stbir_resize_uint8_linear( const unsigned char *input_pixels , int input_w , int input_h, int input_stride_in_bytes," + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 480, + "column": 1, + "source_line": "STBIRDEF float * stbir_resize_float_linear( const float *input_pixels , int input_w , int input_h, int input_stride_in_bytes," + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 526, + "column": 1, + "source_line": "STBIRDEF void * stbir_resize( const void *input_pixels , int input_w , int input_h, int input_stride_in_bytes," + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 606, + "column": 1, + "source_line": "STBIRDEF void stbir_resize_init( STBIR_RESIZE * resize," + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 615, + "column": 1, + "source_line": "STBIRDEF void stbir_set_datatypes( STBIR_RESIZE * resize, stbir_datatype input_type, stbir_datatype output_type );" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 616, + "column": 1, + "source_line": "STBIRDEF void stbir_set_pixel_callbacks( STBIR_RESIZE * resize, stbir_input_callback * input_cb, stbir_output_callback * output_cb ); // no callbacks by default" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 617, + "column": 1, + "source_line": "STBIRDEF void stbir_set_user_data( STBIR_RESIZE * resize, void * user_data ); // pass back STBIR_RESIZE* by default" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 618, + "column": 1, + "source_line": "STBIRDEF void stbir_set_buffer_ptrs( STBIR_RESIZE * resize, const void * input_pixels, int input_stride_in_bytes, void * output_pixels, int output_stride_in_bytes );" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 627, + "column": 1, + "source_line": "STBIRDEF int stbir_set_pixel_layouts( STBIR_RESIZE * resize, stbir_pixel_layout input_pixel_layout, stbir_pixel_layout output_pixel_layout ); // sets new buffer layouts" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 628, + "column": 1, + "source_line": "STBIRDEF int stbir_set_edgemodes( STBIR_RESIZE * resize, stbir_edge horizontal_edge, stbir_edge vertical_edge ); // CLAMP by default" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 630, + "column": 1, + "source_line": "STBIRDEF int stbir_set_filters( STBIR_RESIZE * resize, stbir_filter horizontal_filter, stbir_filter vertical_filter ); // STBIR_DEFAULT_FILTER_UPSAMPLE/DOWNSAMPLE by default" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 631, + "column": 1, + "source_line": "STBIRDEF int stbir_set_filter_callbacks( STBIR_RESIZE * resize, stbir__kernel_callback * horizontal_filter, stbir__support_callback * horizontal_support, stbir__kernel_callback * vertical_filter, stbir__support_callback * vertical_support );" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 633, + "column": 1, + "source_line": "STBIRDEF int stbir_set_pixel_subrect( STBIR_RESIZE * resize, int subx, int suby, int subw, int subh ); // sets both sub-regions (full regions by default)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 634, + "column": 1, + "source_line": "STBIRDEF int stbir_set_input_subrect( STBIR_RESIZE * resize, double s0, double t0, double s1, double t1 ); // sets input sub-region (full region by default)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 635, + "column": 1, + "source_line": "STBIRDEF int stbir_set_output_pixel_subrect( STBIR_RESIZE * resize, int subx, int suby, int subw, int subh ); // sets output sub-region (full region by default)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 641, + "column": 1, + "source_line": "STBIRDEF int stbir_set_non_pm_alpha_speed_over_quality( STBIR_RESIZE * resize, int non_pma_alpha_speed_over_quality );" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 653, + "column": 1, + "source_line": "STBIRDEF int stbir_build_samplers( STBIR_RESIZE * resize );" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 656, + "column": 1, + "source_line": "STBIRDEF void stbir_free_samplers( STBIR_RESIZE * resize );" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 661, + "column": 1, + "source_line": "STBIRDEF int stbir_resize_extended( STBIR_RESIZE * resize );" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 676, + "column": 1, + "source_line": "STBIRDEF int stbir_build_samplers_with_splits( STBIR_RESIZE * resize, int try_splits );" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 689, + "column": 1, + "source_line": "STBIRDEF int stbir_resize_extended_split( STBIR_RESIZE * resize, int split_start, int split_count );" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 767, + "column": 1, + "source_line": "STBIRDEF void stbir_resize_build_profile_info( STBIR_PROFILE_INFO * out_info, STBIR_RESIZE const * resize );" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 770, + "column": 1, + "source_line": "STBIRDEF void stbir_resize_extended_profile_info( STBIR_PROFILE_INFO * out_info, STBIR_RESIZE const * resize );" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 773, + "column": 1, + "source_line": "STBIRDEF void stbir_resize_split_profile_info( STBIR_PROFILE_INFO * out_info, STBIR_RESIZE const * resize, int split_start, int split_num );" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 904, + "column": 1, + "source_line": "static unsigned char stbir__type_size[] = {" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_FIELD_DECLARATION", + "message": "Nested aggregate field definitions are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 977, + "column": 3, + "source_line": " union" + }, + "unit_kind": "struct_field", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_FIELD_DECLARATION", + "message": "Nested aggregate field definitions are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1013, + "column": 3, + "source_line": " union" + }, + "unit_kind": "struct_field", + "unit_name": null + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1077, + "column": 1, + "source_line": "static stbir__inline int stbir__min(int a, int b)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__inline" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1082, + "column": 1, + "source_line": "static stbir__inline int stbir__max(int a, int b)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__inline" + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1087, + "column": 1, + "source_line": "static float stbir__srgb_uchar_to_linear_float[256] = {" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1122, + "column": 1, + "source_line": "static const stbir_uint32 fp32_to_srgb8_tab4[104] = {" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1138, + "column": 1, + "source_line": "static stbir__inline stbir_uint8 stbir__linear_to_srgb_uchar(float in)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__inline" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__simdf'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1405, + "column": 3, + "source_line": " static const stbir__simdf STBIR_zeroones = { 0.0f,1.0f,0.0f,1.0f };" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__simdf" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__simdf'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1406, + "column": 3, + "source_line": " static const stbir__simdf STBIR_onezeros = { 1.0f,0.0f,1.0f,0.0f };" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__simdf" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR__SIMDI_CONST'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1481, + "column": 5, + "source_line": " static STBIR__SIMDI_CONST(stbir__s32_32768, 32768);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR__SIMDI_CONST" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR__SIMDI_CONST'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1482, + "column": 5, + "source_line": " static STBIR__SIMDI_CONST(stbir__s16_32768, ((32768<<16)|32768));" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR__SIMDI_CONST" + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1625, + "column": 5, + "source_line": " static __m256i stbir_00001111 = { STBIR__CONST_4d_32i( 0, 0, 0, 0 ), STBIR__CONST_4d_32i( 1, 1, 1, 1 ) };" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1628, + "column": 5, + "source_line": " static __m256i stbir_22223333 = { STBIR__CONST_4d_32i( 2, 2, 2, 2 ), STBIR__CONST_4d_32i( 3, 3, 3, 3 ) };" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1635, + "column": 5, + "source_line": " static __m256i stbir_00112233 = { STBIR__CONST_4d_32i( 0, 0, 1, 1 ), STBIR__CONST_4d_32i( 2, 2, 3, 3 ) };" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1639, + "column": 5, + "source_line": " static __m256i stbir_load6 = { STBIR__CONST_4_32i( 0x80000000 ), STBIR__CONST_4d_32i( 0x80000000, 0x80000000, 0, 0 ) };" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1679, + "column": 3, + "source_line": " static stbir__inline float stbir_simd_floorf(float x) // martins floorf" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__inline" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1696, + "column": 3, + "source_line": " static stbir__inline float stbir_simd_ceilf(float x) // martins ceilf" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__inline" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'stbir_make16x2'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1821, + "column": 7, + "source_line": " static stbir__inline uint8x16x2_t stbir_make16x2(float32x4_t rega,float32x4_t regb)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir_make16x2" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'stbir_make8x2'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1849, + "column": 7, + "source_line": " static stbir__inline uint8x8x2_t stbir_make8x2(float32x4_t reg)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir_make8x2" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1940, + "column": 3, + "source_line": " static stbir__inline float stbir_simd_floorf(float x)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__inline" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 1958, + "column": 3, + "source_line": " static stbir__inline float stbir_simd_ceilf(float x)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__inline" + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Compiler-specific declaration attributes are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2120, + "column": 3, + "source_line": " typedef float stbir__f32x4 __attribute__((__vector_size__(16), __aligned__(16)));" + }, + "unit_kind": "attribute_declaration", + "unit_name": null + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2130, + "column": 3, + "source_line": " static stbir__inline float stbir_simd_floorf(float x)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__inline" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2139, + "column": 3, + "source_line": " static stbir__inline float stbir_simd_ceilf(float x)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__inline" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__simdf8'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2178, + "column": 3, + "source_line": " static const stbir__simdf8 STBIR_max_uint16_as_float_inverted8 = { stbir__max_uint16_as_float_inverted,stbir__max_uint16_as_float_inverted,stbir__max_uint16_as_float_inverted,stbir__max_uint16_as_float_inverted,stbir__max_uint16_as_float_inverted,stbir__max_uint16_as_float_inverted,stbir__max_uint16_as_float_inverted,stbir__max_uint16_as_float_inverted };" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__simdf8" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__simdf8'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2179, + "column": 3, + "source_line": " static const stbir__simdf8 STBIR_max_uint8_as_float_inverted8 = { stbir__max_uint8_as_float_inverted,stbir__max_uint8_as_float_inverted,stbir__max_uint8_as_float_inverted,stbir__max_uint8_as_float_inverted,stbir__max_uint8_as_float_inverted,stbir__max_uint8_as_float_inverted,stbir__max_uint8_as_float_inverted,stbir__max_uint8_as_float_inverted };" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__simdf8" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__simdf8'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2180, + "column": 3, + "source_line": " static const stbir__simdf8 STBIR_ones8 = { 1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0 };" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__simdf8" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__simdf8'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2181, + "column": 3, + "source_line": " static const stbir__simdf8 STBIR_simd_point58 = { 0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5 };" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__simdf8" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__simdf8'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2182, + "column": 3, + "source_line": " static const stbir__simdf8 STBIR_max_uint8_as_float8 = { stbir__max_uint8_as_float,stbir__max_uint8_as_float,stbir__max_uint8_as_float,stbir__max_uint8_as_float, stbir__max_uint8_as_float,stbir__max_uint8_as_float,stbir__max_uint8_as_float,stbir__max_uint8_as_float };" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__simdf8" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__simdf8'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2183, + "column": 3, + "source_line": " static const stbir__simdf8 STBIR_max_uint16_as_float8 = { stbir__max_uint16_as_float,stbir__max_uint16_as_float,stbir__max_uint16_as_float,stbir__max_uint16_as_float, stbir__max_uint16_as_float,stbir__max_uint16_as_float,stbir__max_uint16_as_float,stbir__max_uint16_as_float };" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__simdf8" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2237, + "column": 3, + "source_line": " static stbir__inline float stbir__half_to_float( stbir__FP16 h )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__inline" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2251, + "column": 3, + "source_line": " static stbir__inline stbir__FP16 stbir__float_to_half(float val)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__inline" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2301, + "column": 3, + "source_line": " static stbir__inline void stbir__half_to_float_SIMD(float * output, stbir__FP16 const * input)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__inline" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2306, + "column": 3, + "source_line": " static stbir__inline void stbir__float_to_half_SIMD(stbir__FP16 * output, float const * input)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__inline" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2311, + "column": 3, + "source_line": " static stbir__inline float stbir__half_to_float( stbir__FP16 h )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__inline" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2316, + "column": 3, + "source_line": " static stbir__inline stbir__FP16 stbir__float_to_half( float f )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__inline" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2326, + "column": 3, + "source_line": " stbir__inline static void stbir__half_to_float_SIMD(float * output, void const * input)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__inline" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2380, + "column": 3, + "source_line": " stbir__inline static void stbir__float_to_half_SIMD(void * output, float const * input)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__inline" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2462, + "column": 3, + "source_line": " static stbir__inline void stbir__half_to_float_SIMD(float * output, stbir__FP16 const * input)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__inline" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2470, + "column": 3, + "source_line": " static stbir__inline void stbir__float_to_half_SIMD(stbir__FP16 * output, float const * input)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__inline" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2478, + "column": 3, + "source_line": " static stbir__inline float stbir__half_to_float( stbir__FP16 h )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__inline" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2483, + "column": 3, + "source_line": " static stbir__inline stbir__FP16 stbir__float_to_half( float f )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__inline" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2490, + "column": 3, + "source_line": " static stbir__inline void stbir__half_to_float_SIMD(float * output, stbir__FP16 const * input)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__inline" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2497, + "column": 3, + "source_line": " static stbir__inline void stbir__float_to_half_SIMD(stbir__FP16 * output, float const * input)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__inline" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2504, + "column": 3, + "source_line": " static stbir__inline float stbir__half_to_float( stbir__FP16 h )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__inline" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2509, + "column": 3, + "source_line": " static stbir__inline stbir__FP16 stbir__float_to_half( float f )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__inline" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2516, + "column": 3, + "source_line": " static stbir__inline void stbir__half_to_float_SIMD(float * output, stbir__FP16 const * input)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__inline" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2523, + "column": 3, + "source_line": " static stbir__inline void stbir__float_to_half_SIMD(stbir__FP16 * output, float const * input)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__inline" + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2564, + "column": 1, + "source_line": "static const int STBIR_mask[9] = { 0,0,0,-1,-1,-1,0,0,0 };" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR__SIMDF_CONST'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2566, + "column": 1, + "source_line": "static const STBIR__SIMDF_CONST(STBIR_max_uint8_as_float, stbir__max_uint8_as_float);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR__SIMDF_CONST" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR__SIMDF_CONST'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2567, + "column": 1, + "source_line": "static const STBIR__SIMDF_CONST(STBIR_max_uint16_as_float, stbir__max_uint16_as_float);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR__SIMDF_CONST" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR__SIMDF_CONST'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2568, + "column": 1, + "source_line": "static const STBIR__SIMDF_CONST(STBIR_max_uint8_as_float_inverted, stbir__max_uint8_as_float_inverted);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR__SIMDF_CONST" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR__SIMDF_CONST'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2569, + "column": 1, + "source_line": "static const STBIR__SIMDF_CONST(STBIR_max_uint16_as_float_inverted, stbir__max_uint16_as_float_inverted);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR__SIMDF_CONST" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR__SIMDF_CONST'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2571, + "column": 1, + "source_line": "static const STBIR__SIMDF_CONST(STBIR_simd_point5, 0.5f);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR__SIMDF_CONST" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR__SIMDF_CONST'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2572, + "column": 1, + "source_line": "static const STBIR__SIMDF_CONST(STBIR_ones, 1.0f);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR__SIMDF_CONST" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR__SIMDI_CONST'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2573, + "column": 1, + "source_line": "static const STBIR__SIMDI_CONST(STBIR_almost_zero, (127 - 13) << 23);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR__SIMDI_CONST" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR__SIMDI_CONST'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2574, + "column": 1, + "source_line": "static const STBIR__SIMDI_CONST(STBIR_almost_one, 0x3f7fffff);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR__SIMDI_CONST" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR__SIMDI_CONST'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2575, + "column": 1, + "source_line": "static const STBIR__SIMDI_CONST(STBIR_mantissa_mask, 0xff);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR__SIMDI_CONST" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR__SIMDI_CONST'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2576, + "column": 1, + "source_line": "static const STBIR__SIMDI_CONST(STBIR_topscale, 0x02000000);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR__SIMDI_CONST" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2735, + "column": 3, + "source_line": " STBIRDEF stbir_uint64 __rdtsc();" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR_PROFILE_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2740, + "column": 3, + "source_line": " static stbir__inline stbir_uint64 STBIR_PROFILE_FUNC()" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR_PROFILE_FUNC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR_PROFILE_FUNC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2757, + "column": 3, + "source_line": " static stbir__inline stbir_uint64 STBIR_PROFILE_FUNC()" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR_PROFILE_FUNC" + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 3102, + "column": 1, + "source_line": "static stbir__edge_wrap_func * stbir__edge_wrap_slow[] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbir__inline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 3110, + "column": 1, + "source_line": "stbir__inline static int stbir__edge_wrap(stbir_edge edge, int n, int max)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbir__inline" + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'STBIR_ONLY_PROFILE_BUILD_GET_INFO'.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 3931, + "column": 1, + "source_line": "static void stbir__calculate_filters( stbir__sampler * samp, stbir__sampler * other_axis_for_pivot, void * user_data STBIR_ONLY_PROFILE_BUILD_GET_INFO )" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'STBIR_ONLY_PROFILE_GET_SPLIT_INFO'.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 4610, + "column": 1, + "source_line": "static void stbir__decode_scanline(stbir__info const * stbir_info, int n, float * output_buffer STBIR_ONLY_PROFILE_GET_SPLIT_INFO )" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 6161, + "column": 1, + "source_line": "static STBIR_VERTICAL_GATHERFUNC * stbir__vertical_gathers[ 8 ] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 6166, + "column": 1, + "source_line": "static STBIR_VERTICAL_GATHERFUNC * stbir__vertical_gathers_continues[ 8 ] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 6173, + "column": 1, + "source_line": "static STBIR_VERTICAL_SCATTERFUNC * stbir__vertical_scatter_sets[ 8 ] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 6178, + "column": 1, + "source_line": "static STBIR_VERTICAL_SCATTERFUNC * stbir__vertical_scatter_blends[ 8 ] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'STBIR_ONLY_PROFILE_GET_SPLIT_INFO'.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 6184, + "column": 1, + "source_line": "static void stbir__encode_scanline( stbir__info const * stbir_info, void *output_buffer_data, float * encode_buffer, int row STBIR_ONLY_PROFILE_GET_SPLIT_INFO )" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'STBIR_ONLY_PROFILE_GET_SPLIT_INFO'.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 6236, + "column": 1, + "source_line": "static void stbir__resample_horizontal_gather(stbir__info const * stbir_info, float* output_buffer, float const * input_buffer STBIR_ONLY_PROFILE_GET_SPLIT_INFO )" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 6570, + "column": 1, + "source_line": "static stbir__kernel_callback * stbir__builtin_kernels[] = { 0, stbir__filter_trapezoid, stbir__filter_triangle, stbir__filter_cubic, stbir__filter_catmullrom, stbir__filter_mitchell, stbir__filter_point };" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 6571, + "column": 1, + "source_line": "static stbir__support_callback * stbir__builtin_supports[] = { 0, stbir__support_trapezoid, stbir__support_one, stbir__support_two, stbir__support_two, stbir__support_two, stbir__support_zeropoint5 };" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 6883, + "column": 1, + "source_line": "static stbir__horizontal_gather_channels_func ** stbir__horizontal_gather_n_coeffs_funcs[8] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 6888, + "column": 1, + "source_line": "static stbir__horizontal_gather_channels_func ** stbir__horizontal_gather_channels_funcs[8] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 6896, + "column": 1, + "source_line": "static float stbir__compute_weights[5][STBIR_RESIZE_CLASSIFICATIONS][4]= // 5 = 0=1chan, 1=2chan, 2=3chan, 3=4chan, 4=7chan" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 6957, + "column": 1, + "source_line": "static STBIR__V_FIRST_INFO STBIR__V_FIRST_INFO_BUFFER = {0};" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 7034, + "column": 1, + "source_line": "static unsigned char stbir__pixel_channels[] = {" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 7042, + "column": 1, + "source_line": "static stbir_internal_pixel_layout stbir__pixel_layout_convert_public_to_internal[] = {" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'STBIR_ONLY_PROFILE_BUILD_GET_INFO'.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 7048, + "column": 1, + "source_line": "static stbir__info * stbir__alloc_internal_mem_and_build_samplers( stbir__sampler * horizontal, stbir__sampler * vertical, stbir__contributors * conservative, stbir_pixel_layout input_pixel_layout_public, stbir_pixel_layout output_pixel_layout_public, int splits, int new_x, int new_y, int fast_alpha, void * user_data STBIR_ONLY_PROFILE_BUILD_GET_INFO )" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 7720, + "column": 1, + "source_line": "STBIRDEF void stbir_resize_init( STBIR_RESIZE * resize," + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 7739, + "column": 1, + "source_line": "STBIRDEF void stbir_set_datatypes( STBIR_RESIZE * resize, stbir_datatype input_type, stbir_datatype output_type ) // by default, datatype from resize_init" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 7747, + "column": 1, + "source_line": "STBIRDEF void stbir_set_pixel_callbacks( STBIR_RESIZE * resize, stbir_input_callback * input_cb, stbir_output_callback * output_cb ) // no callbacks by default" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 7759, + "column": 1, + "source_line": "STBIRDEF void stbir_set_user_data( STBIR_RESIZE * resize, void * user_data ) // pass back STBIR_RESIZE* by default" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 7766, + "column": 1, + "source_line": "STBIRDEF void stbir_set_buffer_ptrs( STBIR_RESIZE * resize, const void * input_pixels, int input_stride_in_bytes, void * output_pixels, int output_stride_in_bytes )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 7777, + "column": 1, + "source_line": "STBIRDEF int stbir_set_edgemodes( STBIR_RESIZE * resize, stbir_edge horizontal_edge, stbir_edge vertical_edge ) // CLAMP by default" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 7785, + "column": 1, + "source_line": "STBIRDEF int stbir_set_filters( STBIR_RESIZE * resize, stbir_filter horizontal_filter, stbir_filter vertical_filter ) // STBIR_DEFAULT_FILTER_UPSAMPLE/DOWNSAMPLE by default" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 7793, + "column": 1, + "source_line": "STBIRDEF int stbir_set_filter_callbacks( STBIR_RESIZE * resize, stbir__kernel_callback * horizontal_filter, stbir__support_callback * horizontal_support, stbir__kernel_callback * vertical_filter, stbir__support_callback * vertical_support )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 7801, + "column": 1, + "source_line": "STBIRDEF int stbir_set_pixel_layouts( STBIR_RESIZE * resize, stbir_pixel_layout input_pixel_layout, stbir_pixel_layout output_pixel_layout ) // sets new pixel layouts" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 7810, + "column": 1, + "source_line": "STBIRDEF int stbir_set_non_pm_alpha_speed_over_quality( STBIR_RESIZE * resize, int non_pma_alpha_speed_over_quality ) // sets alpha speed" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 7817, + "column": 1, + "source_line": "STBIRDEF int stbir_set_input_subrect( STBIR_RESIZE * resize, double s0, double t0, double s1, double t1 ) // sets input region (full region by default)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 7835, + "column": 1, + "source_line": "STBIRDEF int stbir_set_output_pixel_subrect( STBIR_RESIZE * resize, int subx, int suby, int subw, int subh ) // sets input region (full region by default)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 7850, + "column": 1, + "source_line": "STBIRDEF int stbir_set_pixel_subrect( STBIR_RESIZE * resize, int subx, int suby, int subw, int subh ) // sets both regions (full regions by default)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 7949, + "column": 1, + "source_line": "STBIRDEF void stbir_free_samplers( STBIR_RESIZE * resize )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 7959, + "column": 1, + "source_line": "STBIRDEF int stbir_build_samplers_with_splits( STBIR_RESIZE * resize, int splits )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 7975, + "column": 1, + "source_line": "STBIRDEF int stbir_build_samplers( STBIR_RESIZE * resize )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 7980, + "column": 1, + "source_line": "STBIRDEF int stbir_resize_extended( STBIR_RESIZE * resize )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8024, + "column": 1, + "source_line": "STBIRDEF int stbir_resize_extended_split( STBIR_RESIZE * resize, int split_start, int split_count )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8120, + "column": 1, + "source_line": "STBIRDEF unsigned char * stbir_resize_uint8_linear( const unsigned char *input_pixels , int input_w , int input_h, int input_stride_in_bytes," + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8129, + "column": 1, + "source_line": "STBIRDEF unsigned char * stbir_resize_uint8_srgb( const unsigned char *input_pixels , int input_w , int input_h, int input_stride_in_bytes," + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8139, + "column": 1, + "source_line": "STBIRDEF float * stbir_resize_float_linear( const float *input_pixels , int input_w , int input_h, int input_stride_in_bytes," + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8149, + "column": 1, + "source_line": "STBIRDEF void * stbir_resize( const void *input_pixels , int input_w , int input_h, int input_stride_in_bytes," + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8161, + "column": 1, + "source_line": "STBIRDEF void stbir_resize_build_profile_info( STBIR_PROFILE_INFO * info, STBIR_RESIZE const * resize )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8179, + "column": 1, + "source_line": "STBIRDEF void stbir_resize_split_profile_info( STBIR_PROFILE_INFO * info, STBIR_RESIZE const * resize, int split_start, int split_count )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIRDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8219, + "column": 1, + "source_line": "STBIRDEF void stbir_resize_extended_profile_info( STBIR_PROFILE_INFO * info, STBIR_RESIZE const * resize )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIRDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR__CODER_NAME'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8293, + "column": 1, + "source_line": "static float * STBIR__CODER_NAME( stbir__decode_uint8_linear_scaled )( float * decodep, int width_times_channels, void const * inputp )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR__CODER_NAME" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR__CODER_NAME'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8395, + "column": 1, + "source_line": "static void STBIR__CODER_NAME( stbir__encode_uint8_linear_scaled )( void * outputp, int width_times_channels, float const * encode )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR__CODER_NAME" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR__CODER_NAME'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8512, + "column": 1, + "source_line": "static float * STBIR__CODER_NAME(stbir__decode_uint8_linear)( float * decodep, int width_times_channels, void const * inputp )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR__CODER_NAME" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR__CODER_NAME'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8607, + "column": 1, + "source_line": "static void STBIR__CODER_NAME( stbir__encode_uint8_linear )( void * outputp, int width_times_channels, float const * encode )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR__CODER_NAME" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR__CODER_NAME'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8706, + "column": 1, + "source_line": "static float * STBIR__CODER_NAME(stbir__decode_uint8_srgb)( float * decodep, int width_times_channels, void const * inputp )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR__CODER_NAME" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR__CODER_NAME'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8810, + "column": 1, + "source_line": "static void STBIR__CODER_NAME( stbir__encode_uint8_srgb )( void * outputp, int width_times_channels, float const * encode )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR__CODER_NAME" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR__CODER_NAME'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8897, + "column": 1, + "source_line": "static float * STBIR__CODER_NAME(stbir__decode_uint8_srgb4_linearalpha)( float * decodep, int width_times_channels, void const * inputp )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR__CODER_NAME" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR__CODER_NAME'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8915, + "column": 1, + "source_line": "static void STBIR__CODER_NAME( stbir__encode_uint8_srgb4_linearalpha )( void * outputp, int width_times_channels, float const * encode )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR__CODER_NAME" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR__CODER_NAME'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 8984, + "column": 1, + "source_line": "static float * STBIR__CODER_NAME(stbir__decode_uint8_srgb2_linearalpha)( float * decodep, int width_times_channels, void const * inputp )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR__CODER_NAME" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR__CODER_NAME'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 9009, + "column": 1, + "source_line": "static void STBIR__CODER_NAME( stbir__encode_uint8_srgb2_linearalpha )( void * outputp, int width_times_channels, float const * encode )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR__CODER_NAME" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR__CODER_NAME'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 9072, + "column": 1, + "source_line": "static float * STBIR__CODER_NAME(stbir__decode_uint16_linear_scaled)( float * decodep, int width_times_channels, void const * inputp )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR__CODER_NAME" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR__CODER_NAME'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 9162, + "column": 1, + "source_line": "static void STBIR__CODER_NAME(stbir__encode_uint16_linear_scaled)( void * outputp, int width_times_channels, float const * encode )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR__CODER_NAME" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR__CODER_NAME'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 9278, + "column": 1, + "source_line": "static float * STBIR__CODER_NAME(stbir__decode_uint16_linear)( float * decodep, int width_times_channels, void const * inputp )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR__CODER_NAME" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR__CODER_NAME'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 9364, + "column": 1, + "source_line": "static void STBIR__CODER_NAME(stbir__encode_uint16_linear)( void * outputp, int width_times_channels, float const * encode )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR__CODER_NAME" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR__CODER_NAME'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 9462, + "column": 1, + "source_line": "static float * STBIR__CODER_NAME(stbir__decode_half_float_linear)( float * decodep, int width_times_channels, void const * inputp )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR__CODER_NAME" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR__CODER_NAME'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 9549, + "column": 1, + "source_line": "static void STBIR__CODER_NAME( stbir__encode_half_float_linear )( void * outputp, int width_times_channels, float const * encode )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR__CODER_NAME" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR__CODER_NAME'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 9633, + "column": 1, + "source_line": "static float * STBIR__CODER_NAME(stbir__decode_float_linear)( float * decodep, int width_times_channels, void const * inputp )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR__CODER_NAME" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR__CODER_NAME'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 9737, + "column": 1, + "source_line": "static void STBIR__CODER_NAME( stbir__encode_float_linear )( void * outputp, int width_times_channels, float const * encode )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR__CODER_NAME" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR_chans'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 9942, + "column": 1, + "source_line": "static void STBIR_chans( stbir__vertical_scatter_with_,_coeffs)( float ** outputs, float const * vertical_coefficients, float const * input, float const * input_end )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR_chans" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR_chans'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 10114, + "column": 1, + "source_line": "static void STBIR_chans( stbir__vertical_gather_with_,_coeffs)( float * outputp, float const * vertical_coefficients, float const ** inputs, float const * input0_end )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR_chans" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR_chans'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 10328, + "column": 1, + "source_line": "static void STBIR_chans( stbir__horizontal_gather_,_channels_with_1_coeff)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR_chans" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR_chans'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 10341, + "column": 1, + "source_line": "static void STBIR_chans( stbir__horizontal_gather_,_channels_with_2_coeffs)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR_chans" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR_chans'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 10354, + "column": 1, + "source_line": "static void STBIR_chans( stbir__horizontal_gather_,_channels_with_3_coeffs)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR_chans" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR_chans'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 10367, + "column": 1, + "source_line": "static void STBIR_chans( stbir__horizontal_gather_,_channels_with_4_coeffs)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR_chans" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR_chans'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 10380, + "column": 1, + "source_line": "static void STBIR_chans( stbir__horizontal_gather_,_channels_with_5_coeffs)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR_chans" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR_chans'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 10394, + "column": 1, + "source_line": "static void STBIR_chans( stbir__horizontal_gather_,_channels_with_6_coeffs)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR_chans" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR_chans'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 10408, + "column": 1, + "source_line": "static void STBIR_chans( stbir__horizontal_gather_,_channels_with_7_coeffs)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR_chans" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR_chans'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 10424, + "column": 1, + "source_line": "static void STBIR_chans( stbir__horizontal_gather_,_channels_with_8_coeffs)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR_chans" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR_chans'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 10438, + "column": 1, + "source_line": "static void STBIR_chans( stbir__horizontal_gather_,_channels_with_9_coeffs)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR_chans" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR_chans'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 10453, + "column": 1, + "source_line": "static void STBIR_chans( stbir__horizontal_gather_,_channels_with_10_coeffs)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR_chans" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR_chans'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 10468, + "column": 1, + "source_line": "static void STBIR_chans( stbir__horizontal_gather_,_channels_with_11_coeffs)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR_chans" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR_chans'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 10484, + "column": 1, + "source_line": "static void STBIR_chans( stbir__horizontal_gather_,_channels_with_12_coeffs)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR_chans" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR_chans'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 10499, + "column": 1, + "source_line": "static void STBIR_chans( stbir__horizontal_gather_,_channels_with_n_coeffs_mod0 )( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR_chans" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR_chans'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 10521, + "column": 1, + "source_line": "static void STBIR_chans( stbir__horizontal_gather_,_channels_with_n_coeffs_mod1 )( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR_chans" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR_chans'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 10544, + "column": 1, + "source_line": "static void STBIR_chans( stbir__horizontal_gather_,_channels_with_n_coeffs_mod2 )( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR_chans" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR_chans'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 10568, + "column": 1, + "source_line": "static void STBIR_chans( stbir__horizontal_gather_,_channels_with_n_coeffs_mod3 )( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR_chans" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR_chans'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 10593, + "column": 1, + "source_line": "static stbir__horizontal_gather_channels_func * STBIR_chans(stbir__horizontal_gather_,_channels_with_n_coeffs_funcs)[4]=" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR_chans" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBIR_chans'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 10601, + "column": 1, + "source_line": "static stbir__horizontal_gather_channels_func * STBIR_chans(stbir__horizontal_gather_,_channels_funcs)[12]=" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIR_chans" + }, + { + "code": "C_CONFLICTING_TYPEDEF", + "message": "Conflicting typedef declarations for 'stbir_uint8'.", + "severity": "error", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 399, + "column": 1, + "source_line": "typedef uint8_t stbir_uint8;" + }, + "unit_kind": "typedef", + "unit_name": "stbir_uint8" + }, + { + "code": "C_CONFLICTING_TYPEDEF", + "message": "Conflicting typedef declarations for 'stbir_uint16'.", + "severity": "error", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 400, + "column": 1, + "source_line": "typedef uint16_t stbir_uint16;" + }, + "unit_kind": "typedef", + "unit_name": "stbir_uint16" + }, + { + "code": "C_CONFLICTING_TYPEDEF", + "message": "Conflicting typedef declarations for 'stbir_uint32'.", + "severity": "error", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 401, + "column": 1, + "source_line": "typedef uint32_t stbir_uint32;" + }, + "unit_kind": "typedef", + "unit_name": "stbir_uint32" + }, + { + "code": "C_CONFLICTING_TYPEDEF", + "message": "Conflicting typedef declarations for 'stbir__FP16'.", + "severity": "error", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2221, + "column": 3, + "source_line": " typedef float16_t stbir__FP16;" + }, + "unit_kind": "typedef", + "unit_name": "stbir__FP16" + }, + { + "code": "C_CONFLICTING_TYPEDEF", + "message": "Conflicting typedef declarations for 'stbir__FP16'.", + "severity": "error", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2226, + "column": 3, + "source_line": " typedef union stbir__FP16" + }, + "unit_kind": "typedef", + "unit_name": "stbir__FP16" + }, + { + "code": "C_DUPLICATE_FUNCTION_DEFINITION", + "message": "Duplicate definition for function 'stbir_overlapping_memcpy'.", + "severity": "error", + "location": { + "filename": "stb/stb_image_resize2.h", + "line": 2840, + "column": 1, + "source_line": "static void stbir_overlapping_memcpy( void * dest, void const * src, size_t bytes )" + }, + "unit_kind": "function", + "unit_name": "stbir_overlapping_memcpy" + } + ] +} diff --git a/tests/parser/c/fixtures/stb/stb_image_write.json b/tests/parser/c/fixtures/stb/stb_image_write.json new file mode 100644 index 000000000..55a2a306f --- /dev/null +++ b/tests/parser/c/fixtures/stb/stb_image_write.json @@ -0,0 +1,14524 @@ +{ + "files": { + "stb/stb_image_write.h": { + "filename": "stb/stb_image_write.h", + "language": "c", + "parser_status": "partial", + "preprocessing": "raw", + "functions": [ + { + "name": "stbi__start_write_callbacks", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbi__write_context", + "name": "stbi__write_context", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "func", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_write_func *func", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbi_write_func", + "name": "stbi_write_func", + "type": { + "model": "CFunctionType", + "qualifiers": [], + "source_text": "typedef void stbi_write_func(void *context, void *data, int size)", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameter_types": [ + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *context", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int size" + } + ], + "is_variadic": false, + "prototype_style": "prototype" + }, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 187, + "column": 1, + "source_line": "typedef void stbi_write_func(void *context, void *data, int size);" + }, + "declaration_locations": [] + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 269, + "column": 4, + "source_line": " stbi_write_func *func;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "context", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *context", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 270, + "column": 4, + "source_line": " void *context;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char buffer[64]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "64", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 271, + "column": 4, + "source_line": " unsigned char buffer[64];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "buf_used", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int buf_used" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 272, + "column": 4, + "source_line": " int buf_used;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_image_write.h:267:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 267, + "column": 1, + "source_line": "typedef struct" + } + }, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 267, + "column": 1, + "source_line": "typedef struct" + }, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_write_func *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_write_func" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_write_func *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_write_func" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "context", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *context", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *context", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 276, + "column": 1, + "source_line": "static void stbi__start_write_callbacks(stbi__write_context *s, stbi_write_func *c, void *context)" + }, + "start": { + "filename": "stb/stb_image_write.h", + "line": 276, + "column": 1, + "source_line": "static void stbi__start_write_callbacks(stbi__write_context *s, stbi_write_func *c, void *context)" + }, + "end": { + "filename": "stb/stb_image_write.h", + "line": 280, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__stdio_write", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "context", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *context", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *context", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "size", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int size" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int size" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 284, + "column": 1, + "source_line": "static void stbi__stdio_write(void *context, void *data, int size)" + }, + "start": { + "filename": "stb/stb_image_write.h", + "line": 284, + "column": 1, + "source_line": "static void stbi__stdio_write(void *context, void *data, int size)" + }, + "end": { + "filename": "stb/stb_image_write.h", + "line": 287, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbiw__fopen", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "FILE", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "FILE", + "name": "FILE", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "parameters": [ + { + "name": "filename", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char const *filename", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char const *filename", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mode", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char const *mode", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char const *mode", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 304, + "column": 1, + "source_line": "static FILE *stbiw__fopen(char const *filename, char const *mode)" + }, + "start": { + "filename": "stb/stb_image_write.h", + "line": 304, + "column": 1, + "source_line": "static FILE *stbiw__fopen(char const *filename, char const *mode)" + }, + "end": { + "filename": "stb/stb_image_write.h", + "line": 330, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__start_write_file", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "filename", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *filename", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *filename", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 332, + "column": 1, + "source_line": "static int stbi__start_write_file(stbi__write_context *s, const char *filename)" + }, + "start": { + "filename": "stb/stb_image_write.h", + "line": 332, + "column": 1, + "source_line": "static int stbi__start_write_file(stbi__write_context *s, const char *filename)" + }, + "end": { + "filename": "stb/stb_image_write.h", + "line": 337, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi__end_write_file", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 339, + "column": 1, + "source_line": "static void stbi__end_write_file(stbi__write_context *s)" + }, + "start": { + "filename": "stb/stb_image_write.h", + "line": 339, + "column": 1, + "source_line": "static void stbi__end_write_file(stbi__write_context *s)" + }, + "end": { + "filename": "stb/stb_image_write.h", + "line": 342, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbiw__writefv", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "fmt", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *fmt", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *fmt", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "v", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "va_list v", + "name": "va_list", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "declared_type": { + "reference": "va_list" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 349, + "column": 1, + "source_line": "static void stbiw__writefv(stbi__write_context *s, const char *fmt, va_list v)" + }, + "start": { + "filename": "stb/stb_image_write.h", + "line": 349, + "column": 1, + "source_line": "static void stbiw__writefv(stbi__write_context *s, const char *fmt, va_list v)" + }, + "end": { + "filename": "stb/stb_image_write.h", + "line": 376, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbiw__writef", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "fmt", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *fmt", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *fmt", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": true, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 378, + "column": 1, + "source_line": "static void stbiw__writef(stbi__write_context *s, const char *fmt, ...)" + }, + "start": { + "filename": "stb/stb_image_write.h", + "line": 378, + "column": 1, + "source_line": "static void stbiw__writef(stbi__write_context *s, const char *fmt, ...)" + }, + "end": { + "filename": "stb/stb_image_write.h", + "line": 384, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbiw__write_flush", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 386, + "column": 1, + "source_line": "static void stbiw__write_flush(stbi__write_context *s)" + }, + "start": { + "filename": "stb/stb_image_write.h", + "line": 386, + "column": 1, + "source_line": "static void stbiw__write_flush(stbi__write_context *s)" + }, + "end": { + "filename": "stb/stb_image_write.h", + "line": 392, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbiw__putc", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char c" + }, + "declared_type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char c" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 394, + "column": 1, + "source_line": "static void stbiw__putc(stbi__write_context *s, unsigned char c)" + }, + "start": { + "filename": "stb/stb_image_write.h", + "line": 394, + "column": 1, + "source_line": "static void stbiw__putc(stbi__write_context *s, unsigned char c)" + }, + "end": { + "filename": "stb/stb_image_write.h", + "line": 397, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbiw__write1", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "a", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char a" + }, + "declared_type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char a" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 399, + "column": 1, + "source_line": "static void stbiw__write1(stbi__write_context *s, unsigned char a)" + }, + "start": { + "filename": "stb/stb_image_write.h", + "line": 399, + "column": 1, + "source_line": "static void stbiw__write1(stbi__write_context *s, unsigned char a)" + }, + "end": { + "filename": "stb/stb_image_write.h", + "line": 404, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbiw__write3", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "a", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char a" + }, + "declared_type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char a" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char b" + }, + "declared_type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char b" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char c" + }, + "declared_type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char c" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 406, + "column": 1, + "source_line": "static void stbiw__write3(stbi__write_context *s, unsigned char a, unsigned char b, unsigned char c)" + }, + "start": { + "filename": "stb/stb_image_write.h", + "line": 406, + "column": 1, + "source_line": "static void stbiw__write3(stbi__write_context *s, unsigned char a, unsigned char b, unsigned char c)" + }, + "end": { + "filename": "stb/stb_image_write.h", + "line": 416, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbiw__write_pixel", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "rgb_dir", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int rgb_dir" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int rgb_dir" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int comp" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int comp" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "write_alpha", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int write_alpha" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int write_alpha" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "expand_mono", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int expand_mono" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int expand_mono" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "d", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *d", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *d", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 418, + "column": 1, + "source_line": "static void stbiw__write_pixel(stbi__write_context *s, int rgb_dir, int comp, int write_alpha, int expand_mono, unsigned char *d)" + }, + "start": { + "filename": "stb/stb_image_write.h", + "line": 418, + "column": 1, + "source_line": "static void stbiw__write_pixel(stbi__write_context *s, int rgb_dir, int comp, int write_alpha, int expand_mono, unsigned char *d)" + }, + "end": { + "filename": "stb/stb_image_write.h", + "line": 449, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbiw__write_pixels", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "rgb_dir", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int rgb_dir" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int rgb_dir" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "vdir", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int vdir" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int vdir" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int comp" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int comp" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "write_alpha", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int write_alpha" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int write_alpha" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "scanline_pad", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int scanline_pad" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int scanline_pad" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "expand_mono", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int expand_mono" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int expand_mono" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 451, + "column": 1, + "source_line": "static void stbiw__write_pixels(stbi__write_context *s, int rgb_dir, int vdir, int x, int y, int comp, void *data, int write_alpha, int scanline_pad, int expand_mono)" + }, + "start": { + "filename": "stb/stb_image_write.h", + "line": 451, + "column": 1, + "source_line": "static void stbiw__write_pixels(stbi__write_context *s, int rgb_dir, int vdir, int x, int y, int comp, void *data, int write_alpha, int scanline_pad, int expand_mono)" + }, + "end": { + "filename": "stb/stb_image_write.h", + "line": 476, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbiw__outfile", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "rgb_dir", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int rgb_dir" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int rgb_dir" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "vdir", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int vdir" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int vdir" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int comp" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int comp" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "expand_mono", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int expand_mono" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int expand_mono" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "alpha", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int alpha" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int alpha" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "pad", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int pad" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int pad" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "fmt", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *fmt", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *fmt", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": true, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 478, + "column": 1, + "source_line": "static int stbiw__outfile(stbi__write_context *s, int rgb_dir, int vdir, int x, int y, int comp, int expand_mono, void *data, int alpha, int pad, const char *fmt, ...)" + }, + "start": { + "filename": "stb/stb_image_write.h", + "line": 478, + "column": 1, + "source_line": "static int stbiw__outfile(stbi__write_context *s, int rgb_dir, int vdir, int x, int y, int comp, int expand_mono, void *data, int alpha, int pad, const char *fmt, ...)" + }, + "end": { + "filename": "stb/stb_image_write.h", + "line": 490, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi_write_bmp_core", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int comp" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int comp" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const void *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [ + "const" + ], + "source_text": "const void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const void *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [ + "const" + ], + "source_text": "const void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 492, + "column": 1, + "source_line": "static int stbi_write_bmp_core(stbi__write_context *s, int x, int y, int comp, const void *data)" + }, + "start": { + "filename": "stb/stb_image_write.h", + "line": 492, + "column": 1, + "source_line": "static int stbi_write_bmp_core(stbi__write_context *s, int x, int y, int comp, const void *data)" + }, + "end": { + "filename": "stb/stb_image_write.h", + "line": 510, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi_write_tga_core", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int comp" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int comp" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 532, + "column": 1, + "source_line": "static int stbi_write_tga_core(stbi__write_context *s, int x, int y, int comp, void *data)" + }, + "start": { + "filename": "stb/stb_image_write.h", + "line": 532, + "column": 1, + "source_line": "static int stbi_write_tga_core(stbi__write_context *s, int x, int y, int comp, void *data)" + }, + "end": { + "filename": "stb/stb_image_write.h", + "line": 609, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbiw__linear_to_rgbe", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "rgbe", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *rgbe", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *rgbe", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "linear", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *linear", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *linear", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 639, + "column": 1, + "source_line": "static void stbiw__linear_to_rgbe(unsigned char *rgbe, float *linear)" + }, + "start": { + "filename": "stb/stb_image_write.h", + "line": 639, + "column": 1, + "source_line": "static void stbiw__linear_to_rgbe(unsigned char *rgbe, float *linear)" + }, + "end": { + "filename": "stb/stb_image_write.h", + "line": 654, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbiw__write_run_data", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "length", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int length" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int length" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "databyte", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char databyte" + }, + "declared_type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char databyte" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 656, + "column": 1, + "source_line": "static void stbiw__write_run_data(stbi__write_context *s, int length, unsigned char databyte)" + }, + "start": { + "filename": "stb/stb_image_write.h", + "line": 656, + "column": 1, + "source_line": "static void stbiw__write_run_data(stbi__write_context *s, int length, unsigned char databyte)" + }, + "end": { + "filename": "stb/stb_image_write.h", + "line": 662, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbiw__write_dump_data", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "length", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int length" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int length" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 664, + "column": 1, + "source_line": "static void stbiw__write_dump_data(stbi__write_context *s, int length, unsigned char *data)" + }, + "start": { + "filename": "stb/stb_image_write.h", + "line": 664, + "column": 1, + "source_line": "static void stbiw__write_dump_data(stbi__write_context *s, int length, unsigned char *data)" + }, + "end": { + "filename": "stb/stb_image_write.h", + "line": 670, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbiw__write_hdr_scanline", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "width", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ncomp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ncomp" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ncomp" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "scratch", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *scratch", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *scratch", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "scanline", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *scanline", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *scanline", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 672, + "column": 1, + "source_line": "static void stbiw__write_hdr_scanline(stbi__write_context *s, int width, int ncomp, unsigned char *scratch, float *scanline)" + }, + "start": { + "filename": "stb/stb_image_write.h", + "line": 672, + "column": 1, + "source_line": "static void stbiw__write_hdr_scanline(stbi__write_context *s, int width, int ncomp, unsigned char *scratch, float *scanline)" + }, + "end": { + "filename": "stb/stb_image_write.h", + "line": 759, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi_write_hdr_core", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int comp" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int comp" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 761, + "column": 1, + "source_line": "static int stbi_write_hdr_core(stbi__write_context *s, int x, int y, int comp, float *data)" + }, + "start": { + "filename": "stb/stb_image_write.h", + "line": 761, + "column": 1, + "source_line": "static int stbi_write_hdr_core(stbi__write_context *s, int x, int y, int comp, float *data)" + }, + "end": { + "filename": "stb/stb_image_write.h", + "line": 785, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbiw__sbgrowf", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "parameters": [ + { + "name": "arr", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void **arr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void **arr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "increment", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int increment" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int increment" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "itemsize", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int itemsize" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int itemsize" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 826, + "column": 1, + "source_line": "static void *stbiw__sbgrowf(void **arr, int increment, int itemsize)" + }, + "start": { + "filename": "stb/stb_image_write.h", + "line": 826, + "column": 1, + "source_line": "static void *stbiw__sbgrowf(void **arr, int increment, int itemsize)" + }, + "end": { + "filename": "stb/stb_image_write.h", + "line": 837, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbiw__zlib_flushf", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "parameters": [ + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "bitbuffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned int *bitbuffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned int *bitbuffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "bitcount", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *bitcount", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *bitcount", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 839, + "column": 1, + "source_line": "static unsigned char *stbiw__zlib_flushf(unsigned char *data, unsigned int *bitbuffer, int *bitcount)" + }, + "start": { + "filename": "stb/stb_image_write.h", + "line": 839, + "column": 1, + "source_line": "static unsigned char *stbiw__zlib_flushf(unsigned char *data, unsigned int *bitbuffer, int *bitcount)" + }, + "end": { + "filename": "stb/stb_image_write.h", + "line": 847, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbiw__zlib_bitrev", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "code", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int code" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int code" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "codebits", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int codebits" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int codebits" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 849, + "column": 1, + "source_line": "static int stbiw__zlib_bitrev(int code, int codebits)" + }, + "start": { + "filename": "stb/stb_image_write.h", + "line": 849, + "column": 1, + "source_line": "static int stbiw__zlib_bitrev(int code, int codebits)" + }, + "end": { + "filename": "stb/stb_image_write.h", + "line": 857, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbiw__zlib_countm", + "result_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *b", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *b", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "limit", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int limit" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int limit" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 859, + "column": 1, + "source_line": "static unsigned int stbiw__zlib_countm(unsigned char *a, unsigned char *b, int limit)" + }, + "start": { + "filename": "stb/stb_image_write.h", + "line": 859, + "column": 1, + "source_line": "static unsigned int stbiw__zlib_countm(unsigned char *a, unsigned char *b, int limit)" + }, + "end": { + "filename": "stb/stb_image_write.h", + "line": 865, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbiw__zhash", + "result_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int" + }, + "parameters": [ + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 867, + "column": 1, + "source_line": "static unsigned int stbiw__zhash(unsigned char *data)" + }, + "start": { + "filename": "stb/stb_image_write.h", + "line": 867, + "column": 1, + "source_line": "static unsigned int stbiw__zhash(unsigned char *data)" + }, + "end": { + "filename": "stb/stb_image_write.h", + "line": 877, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbiw__crc32", + "result_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int" + }, + "parameters": [ + { + "name": "buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 1024, + "column": 1, + "source_line": "static unsigned int stbiw__crc32(unsigned char *buffer, int len)" + }, + "start": { + "filename": "stb/stb_image_write.h", + "line": 1024, + "column": 1, + "source_line": "static unsigned int stbiw__crc32(unsigned char *buffer, int len)" + }, + "end": { + "filename": "stb/stb_image_write.h", + "line": 1071, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbiw__wpcrc", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char **data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char **data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 1077, + "column": 1, + "source_line": "static void stbiw__wpcrc(unsigned char **data, int len)" + }, + "start": { + "filename": "stb/stb_image_write.h", + "line": 1077, + "column": 1, + "source_line": "static void stbiw__wpcrc(unsigned char **data, int len)" + }, + "end": { + "filename": "stb/stb_image_write.h", + "line": 1081, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbiw__paeth", + "result_type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 1083, + "column": 1, + "source_line": "static unsigned char stbiw__paeth(int a, int b, int c)" + }, + "start": { + "filename": "stb/stb_image_write.h", + "line": 1083, + "column": 1, + "source_line": "static unsigned char stbiw__paeth(int a, int b, int c)" + }, + "end": { + "filename": "stb/stb_image_write.h", + "line": 1089, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbiw__encode_png_line", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "pixels", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *pixels", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *pixels", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "stride_bytes", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int stride_bytes" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int stride_bytes" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "width", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "height", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int height" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int height" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "filter_type", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int filter_type" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int filter_type" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "line_buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "signed char *line_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CSignedChar", + "qualifiers": [], + "source_text": "signed char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "signed char *line_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CSignedChar", + "qualifiers": [], + "source_text": "signed char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 1092, + "column": 1, + "source_line": "static void stbiw__encode_png_line(unsigned char *pixels, int stride_bytes, int width, int height, int y, int n, int filter_type, signed char *line_buffer)" + }, + "start": { + "filename": "stb/stb_image_write.h", + "line": 1092, + "column": 1, + "source_line": "static void stbiw__encode_png_line(unsigned char *pixels, int stride_bytes, int width, int height, int y, int n, int filter_type, signed char *line_buffer)" + }, + "end": { + "filename": "stb/stb_image_write.h", + "line": 1126, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbiw__jpg_writeBits", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "bitBufP", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *bitBufP", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *bitBufP", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "bitCntP", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *bitCntP", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *bitCntP", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "bs", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const unsigned short *bs", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedShort", + "qualifiers": [ + "const" + ], + "source_text": "const unsigned short" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const unsigned short *bs", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedShort", + "qualifiers": [ + "const" + ], + "source_text": "const unsigned short" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 1253, + "column": 1, + "source_line": "static void stbiw__jpg_writeBits(stbi__write_context *s, int *bitBufP, int *bitCntP, const unsigned short *bs) {" + }, + "start": { + "filename": "stb/stb_image_write.h", + "line": 1253, + "column": 1, + "source_line": "static void stbiw__jpg_writeBits(stbi__write_context *s, int *bitBufP, int *bitCntP, const unsigned short *bs) {" + }, + "end": { + "filename": "stb/stb_image_write.h", + "line": 1268, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbiw__jpg_DCT", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "d0p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *d0p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *d0p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "d1p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *d1p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *d1p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "d2p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *d2p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *d2p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "d3p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *d3p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *d3p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "d4p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *d4p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *d4p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "d5p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *d5p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *d5p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "d6p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *d6p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *d6p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "d7p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *d7p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *d7p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 1270, + "column": 1, + "source_line": "static void stbiw__jpg_DCT(float *d0p, float *d1p, float *d2p, float *d3p, float *d4p, float *d5p, float *d6p, float *d7p) {" + }, + "start": { + "filename": "stb/stb_image_write.h", + "line": 1270, + "column": 1, + "source_line": "static void stbiw__jpg_DCT(float *d0p, float *d1p, float *d2p, float *d3p, float *d4p, float *d5p, float *d6p, float *d7p) {" + }, + "end": { + "filename": "stb/stb_image_write.h", + "line": 1316, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbiw__jpg_calcBits", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "val", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int val" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int val" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "bits", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned short bits[2]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedShort", + "qualifiers": [], + "source_text": "unsigned short" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned short bits[2]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "2", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CUnsignedShort", + "qualifiers": [], + "source_text": "unsigned short" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 1318, + "column": 1, + "source_line": "static void stbiw__jpg_calcBits(int val, unsigned short bits[2]) {" + }, + "start": { + "filename": "stb/stb_image_write.h", + "line": 1318, + "column": 1, + "source_line": "static void stbiw__jpg_calcBits(int val, unsigned short bits[2]) {" + }, + "end": { + "filename": "stb/stb_image_write.h", + "line": 1326, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbiw__jpg_processDU", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "bitBuf", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *bitBuf", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *bitBuf", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "bitCnt", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *bitCnt", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *bitCnt", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "CDU", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *CDU", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *CDU", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "du_stride", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int du_stride" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int du_stride" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "fdtbl", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *fdtbl", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *fdtbl", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "DC", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int DC" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int DC" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "HTDC", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const unsigned short HTDC[256][2]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "2", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CUnsignedShort", + "qualifiers": [ + "const" + ], + "source_text": "const unsigned short" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const unsigned short HTDC[256][2]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "256", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "2", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CUnsignedShort", + "qualifiers": [ + "const" + ], + "source_text": "const unsigned short" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "HTAC", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const unsigned short HTAC[256][2]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "2", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CUnsignedShort", + "qualifiers": [ + "const" + ], + "source_text": "const unsigned short" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const unsigned short HTAC[256][2]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "256", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "2", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CUnsignedShort", + "qualifiers": [ + "const" + ], + "source_text": "const unsigned short" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 1328, + "column": 1, + "source_line": "static int stbiw__jpg_processDU(stbi__write_context *s, int *bitBuf, int *bitCnt, float *CDU, int du_stride, float *fdtbl, int DC, const unsigned short HTDC[256][2], const unsigned short HTAC[256][2]) {" + }, + "start": { + "filename": "stb/stb_image_write.h", + "line": 1328, + "column": 1, + "source_line": "static int stbiw__jpg_processDU(stbi__write_context *s, int *bitBuf, int *bitCnt, float *CDU, int du_stride, float *fdtbl, int DC, const unsigned short HTDC[256][2], const unsigned short HTAC[256][2]) {" + }, + "end": { + "filename": "stb/stb_image_write.h", + "line": 1396, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbi_write_jpg_core", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "width", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "height", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int height" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int height" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int comp" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int comp" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const void * data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [ + "const" + ], + "source_text": "const void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const void * data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [ + "const" + ], + "source_text": "const void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "quality", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int quality" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int quality" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 1398, + "column": 1, + "source_line": "static int stbi_write_jpg_core(stbi__write_context *s, int width, int height, int comp, const void* data, int quality) {" + }, + "start": { + "filename": "stb/stb_image_write.h", + "line": 1398, + "column": 1, + "source_line": "static int stbi_write_jpg_core(stbi__write_context *s, int width, int height, int comp, const void* data, int quality) {" + }, + "end": { + "filename": "stb/stb_image_write.h", + "line": 1605, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + } + ], + "structs": [ + { + "reference": "struct@stb/stb_image_write.h:267:1" + } + ], + "unions": [], + "enums": [], + "typedefs": [ + { + "reference": "stbi_write_func" + }, + { + "reference": "stbi__write_context" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbiw_uint32", + "name": "stbiw_uint32", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "typedef unsigned int stbiw_uint32" + }, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 346, + "column": 1, + "source_line": "typedef unsigned int stbiw_uint32;" + }, + "declaration_locations": [] + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stb_image_write_test", + "name": "stb_image_write_test", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "typedef int stb_image_write_test[sizeof(stbiw_uint32)==4 ? 1 : -1]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "sizeof(stbiw_uint32)==4 ? 1 : -1", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 347, + "column": 1, + "source_line": "typedef int stb_image_write_test[sizeof(stbiw_uint32)==4 ? 1 : -1];" + }, + "declaration_locations": [] + } + ], + "variables": [ + { + "name": "stbi_write_png_compression_level", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "static int stbi_write_png_compression_level" + }, + "storage": [ + "static" + ], + "initializer": { + "source_text": "8" + }, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 251, + "column": 1, + "source_line": "static int stbi_write_png_compression_level = 8;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "stbi_write_tga_with_rle", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "static int stbi_write_tga_with_rle" + }, + "storage": [ + "static" + ], + "initializer": { + "source_text": "1" + }, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 252, + "column": 1, + "source_line": "static int stbi_write_tga_with_rle = 1;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "stbi_write_force_png_filter", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "static int stbi_write_force_png_filter" + }, + "storage": [ + "static" + ], + "initializer": { + "source_text": "-1" + }, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 253, + "column": 1, + "source_line": "static int stbi_write_force_png_filter = -1;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "stbi__flip_vertically_on_write", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "static int stbi__flip_vertically_on_write" + }, + "storage": [ + "static" + ], + "initializer": { + "source_text": "0" + }, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 260, + "column": 1, + "source_line": "static int stbi__flip_vertically_on_write = 0;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "macros": [ + { + "name": "INCLUDE_STB_IMAGE_WRITE_H", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 152, + "column": 1, + "source_line": "#define INCLUDE_STB_IMAGE_WRITE_H" + } + }, + { + "name": "STBIWDEF", + "value": "static", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 159, + "column": 1, + "source_line": "#define STBIWDEF static" + } + }, + { + "name": "STBIWDEF", + "value": "extern \"C\"", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 162, + "column": 1, + "source_line": "#define STBIWDEF extern \"C\"" + } + }, + { + "name": "STBIWDEF", + "value": "extern", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 164, + "column": 1, + "source_line": "#define STBIWDEF extern" + } + }, + { + "name": "_CRT_SECURE_NO_WARNINGS", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 203, + "column": 4, + "source_line": " #define _CRT_SECURE_NO_WARNINGS" + } + }, + { + "name": "_CRT_NONSTDC_NO_DEPRECATE", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 206, + "column": 4, + "source_line": " #define _CRT_NONSTDC_NO_DEPRECATE" + } + }, + { + "name": "STBIW_MALLOC", + "value": "malloc(sz)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 228, + "column": 1, + "source_line": "#define STBIW_MALLOC(sz) malloc(sz)" + } + }, + { + "name": "STBIW_REALLOC", + "value": "realloc(p,newsz)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 229, + "column": 1, + "source_line": "#define STBIW_REALLOC(p,newsz) realloc(p,newsz)" + } + }, + { + "name": "STBIW_FREE", + "value": "free(p)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 230, + "column": 1, + "source_line": "#define STBIW_FREE(p) free(p)" + } + }, + { + "name": "STBIW_REALLOC_SIZED", + "value": "STBIW_REALLOC(p,newsz)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 234, + "column": 1, + "source_line": "#define STBIW_REALLOC_SIZED(p,oldsz,newsz) STBIW_REALLOC(p,newsz)" + } + }, + { + "name": "STBIW_MEMMOVE", + "value": "memmove(a,b,sz)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 239, + "column": 1, + "source_line": "#define STBIW_MEMMOVE(a,b,sz) memmove(a,b,sz)" + } + }, + { + "name": "STBIW_ASSERT", + "value": "assert(x)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 245, + "column": 1, + "source_line": "#define STBIW_ASSERT(x) assert(x)" + } + }, + { + "name": "STBIW_UCHAR", + "value": "(unsigned char) ((x) & 0xff)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 248, + "column": 1, + "source_line": "#define STBIW_UCHAR(x) (unsigned char) ((x) & 0xff)" + } + }, + { + "name": "STBIW_EXTERN", + "value": "extern \"C\"", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 291, + "column": 1, + "source_line": "#define STBIW_EXTERN extern \"C\"" + } + }, + { + "name": "STBIW_EXTERN", + "value": "extern", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 293, + "column": 1, + "source_line": "#define STBIW_EXTERN extern" + } + }, + { + "name": "stbiw__max", + "value": "((a) > (b) ? (a) : (b))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 635, + "column": 1, + "source_line": "#define stbiw__max(a, b) ((a) > (b) ? (a) : (b))" + } + }, + { + "name": "stbiw__sbraw", + "value": "((int *) (void *) (a) - 2)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 814, + "column": 1, + "source_line": "#define stbiw__sbraw(a) ((int *) (void *) (a) - 2)" + } + }, + { + "name": "stbiw__sbm", + "value": "stbiw__sbraw(a)[0]", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 815, + "column": 1, + "source_line": "#define stbiw__sbm(a) stbiw__sbraw(a)[0]" + } + }, + { + "name": "stbiw__sbn", + "value": "stbiw__sbraw(a)[1]", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 816, + "column": 1, + "source_line": "#define stbiw__sbn(a) stbiw__sbraw(a)[1]" + } + }, + { + "name": "stbiw__sbneedgrow", + "value": "((a)==0 || stbiw__sbn(a)+n >= stbiw__sbm(a))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 818, + "column": 1, + "source_line": "#define stbiw__sbneedgrow(a,n) ((a)==0 || stbiw__sbn(a)+n >= stbiw__sbm(a))" + } + }, + { + "name": "stbiw__sbmaybegrow", + "value": "(stbiw__sbneedgrow(a,(n)) ? stbiw__sbgrow(a,n) : 0)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 819, + "column": 1, + "source_line": "#define stbiw__sbmaybegrow(a,n) (stbiw__sbneedgrow(a,(n)) ? stbiw__sbgrow(a,n) : 0)" + } + }, + { + "name": "stbiw__sbgrow", + "value": "stbiw__sbgrowf((void **) &(a), (n), sizeof(*(a)))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 820, + "column": 1, + "source_line": "#define stbiw__sbgrow(a,n) stbiw__sbgrowf((void **) &(a), (n), sizeof(*(a)))" + } + }, + { + "name": "stbiw__sbpush", + "value": "(stbiw__sbmaybegrow(a,1), (a)[stbiw__sbn(a)++] = (v))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 822, + "column": 1, + "source_line": "#define stbiw__sbpush(a, v) (stbiw__sbmaybegrow(a,1), (a)[stbiw__sbn(a)++] = (v))" + } + }, + { + "name": "stbiw__sbcount", + "value": "((a) ? stbiw__sbn(a) : 0)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 823, + "column": 1, + "source_line": "#define stbiw__sbcount(a) ((a) ? stbiw__sbn(a) : 0)" + } + }, + { + "name": "stbiw__sbfree", + "value": "((a) ? STBIW_FREE(stbiw__sbraw(a)),0 : 0)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 824, + "column": 1, + "source_line": "#define stbiw__sbfree(a) ((a) ? STBIW_FREE(stbiw__sbraw(a)),0 : 0)" + } + }, + { + "name": "stbiw__zlib_flush", + "value": "(out = stbiw__zlib_flushf(out, &bitbuf, &bitcount))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 879, + "column": 1, + "source_line": "#define stbiw__zlib_flush() (out = stbiw__zlib_flushf(out, &bitbuf, &bitcount))" + } + }, + { + "name": "stbiw__zlib_add", + "value": "(bitbuf |= (code) << bitcount, bitcount += (codebits), stbiw__zlib_flush())", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 880, + "column": 1, + "source_line": "#define stbiw__zlib_add(code,codebits) \\" + } + }, + { + "name": "stbiw__zlib_huffa", + "value": "stbiw__zlib_add(stbiw__zlib_bitrev(b,c),c)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 882, + "column": 1, + "source_line": "#define stbiw__zlib_huffa(b,c) stbiw__zlib_add(stbiw__zlib_bitrev(b,c),c)" + } + }, + { + "name": "stbiw__zlib_huff1", + "value": "stbiw__zlib_huffa(0x30 + (n), 8)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 884, + "column": 1, + "source_line": "#define stbiw__zlib_huff1(n) stbiw__zlib_huffa(0x30 + (n), 8)" + } + }, + { + "name": "stbiw__zlib_huff2", + "value": "stbiw__zlib_huffa(0x190 + (n)-144, 9)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 885, + "column": 1, + "source_line": "#define stbiw__zlib_huff2(n) stbiw__zlib_huffa(0x190 + (n)-144, 9)" + } + }, + { + "name": "stbiw__zlib_huff3", + "value": "stbiw__zlib_huffa(0 + (n)-256,7)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 886, + "column": 1, + "source_line": "#define stbiw__zlib_huff3(n) stbiw__zlib_huffa(0 + (n)-256,7)" + } + }, + { + "name": "stbiw__zlib_huff4", + "value": "stbiw__zlib_huffa(0xc0 + (n)-280,8)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 887, + "column": 1, + "source_line": "#define stbiw__zlib_huff4(n) stbiw__zlib_huffa(0xc0 + (n)-280,8)" + } + }, + { + "name": "stbiw__zlib_huff", + "value": "((n) <= 143 ? stbiw__zlib_huff1(n) : (n) <= 255 ? stbiw__zlib_huff2(n) : (n) <= 279 ? stbiw__zlib_huff3(n) : stbiw__zlib_huff4(n))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 888, + "column": 1, + "source_line": "#define stbiw__zlib_huff(n) ((n) <= 143 ? stbiw__zlib_huff1(n) : (n) <= 255 ? stbiw__zlib_huff2(n) : (n) <= 279 ? stbiw__zlib_huff3(n) : stbiw__zlib_huff4(n))" + } + }, + { + "name": "stbiw__zlib_huffb", + "value": "((n) <= 143 ? stbiw__zlib_huff1(n) : stbiw__zlib_huff2(n))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 889, + "column": 1, + "source_line": "#define stbiw__zlib_huffb(n) ((n) <= 143 ? stbiw__zlib_huff1(n) : stbiw__zlib_huff2(n))" + } + }, + { + "name": "stbiw__ZHASH", + "value": "16384", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 891, + "column": 1, + "source_line": "#define stbiw__ZHASH 16384" + } + }, + { + "name": "stbiw__wpng4", + "value": "((o)[0]=STBIW_UCHAR(a),(o)[1]=STBIW_UCHAR(b),(o)[2]=STBIW_UCHAR(c),(o)[3]=STBIW_UCHAR(d),(o)+=4)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 1073, + "column": 1, + "source_line": "#define stbiw__wpng4(o,a,b,c,d) ((o)[0]=STBIW_UCHAR(a),(o)[1]=STBIW_UCHAR(b),(o)[2]=STBIW_UCHAR(c),(o)[3]=STBIW_UCHAR(d),(o)+=4)" + } + }, + { + "name": "stbiw__wp32", + "value": "stbiw__wpng4(data, (v)>>24,(v)>>16,(v)>>8,(v));", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 1074, + "column": 1, + "source_line": "#define stbiw__wp32(data,v) stbiw__wpng4(data, (v)>>24,(v)>>16,(v)>>8,(v));" + } + }, + { + "name": "stbiw__wptag", + "value": "stbiw__wpng4(data, s[0],s[1],s[2],s[3])", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 1075, + "column": 1, + "source_line": "#define stbiw__wptag(data,s) stbiw__wpng4(data, s[0],s[1],s[2],s[3])" + } + } + ], + "includes": [ + { + "target": "stdlib.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 154, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "stdio.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 211, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "stdarg.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 214, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "stdlib.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 215, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "string.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 216, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "math.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 217, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "assert.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 244, + "column": 1, + "source_line": "#include " + } + } + ], + "raw_directives": [ + { + "directive": "ifndef", + "argument": "INCLUDE_STB_IMAGE_WRITE_H", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 151, + "column": 1, + "source_line": "#ifndef INCLUDE_STB_IMAGE_WRITE_H" + } + }, + { + "directive": "ifndef", + "argument": "STBIWDEF", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 157, + "column": 1, + "source_line": "#ifndef STBIWDEF" + } + }, + { + "directive": "ifdef", + "argument": "STB_IMAGE_WRITE_STATIC", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 158, + "column": 1, + "source_line": "#ifdef STB_IMAGE_WRITE_STATIC" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 160, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "ifdef", + "argument": "__cplusplus", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 161, + "column": 1, + "source_line": "#ifdef __cplusplus" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 163, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 165, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 166, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 167, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_IMAGE_WRITE_STATIC", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 169, + "column": 1, + "source_line": "#ifndef STB_IMAGE_WRITE_STATIC // C++ forbids static forward declarations" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 173, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_WRITE_NO_STDIO", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 175, + "column": 1, + "source_line": "#ifndef STBI_WRITE_NO_STDIO" + } + }, + { + "directive": "ifdef", + "argument": "STBIW_WINDOWS_UTF8", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 182, + "column": 1, + "source_line": "#ifdef STBIW_WINDOWS_UTF8" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 184, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 185, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 197, + "column": 1, + "source_line": "#endif//INCLUDE_STB_IMAGE_WRITE_H" + } + }, + { + "directive": "ifdef", + "argument": "STB_IMAGE_WRITE_IMPLEMENTATION", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 199, + "column": 1, + "source_line": "#ifdef STB_IMAGE_WRITE_IMPLEMENTATION" + } + }, + { + "directive": "ifdef", + "argument": "_WIN32", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 201, + "column": 1, + "source_line": "#ifdef _WIN32" + } + }, + { + "directive": "ifndef", + "argument": "_CRT_SECURE_NO_WARNINGS", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 202, + "column": 4, + "source_line": " #ifndef _CRT_SECURE_NO_WARNINGS" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 204, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "_CRT_NONSTDC_NO_DEPRECATE", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 205, + "column": 4, + "source_line": " #ifndef _CRT_NONSTDC_NO_DEPRECATE" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 207, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 208, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_WRITE_NO_STDIO", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 210, + "column": 1, + "source_line": "#ifndef STBI_WRITE_NO_STDIO" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 212, + "column": 1, + "source_line": "#endif // STBI_WRITE_NO_STDIO" + } + }, + { + "directive": "if", + "argument": "defined(STBIW_MALLOC) && defined(STBIW_FREE) && (defined(STBIW_REALLOC) || defined(STBIW_REALLOC_SIZED))", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 219, + "column": 1, + "source_line": "#if defined(STBIW_MALLOC) && defined(STBIW_FREE) && (defined(STBIW_REALLOC) || defined(STBIW_REALLOC_SIZED))" + } + }, + { + "directive": "elif", + "argument": "!defined(STBIW_MALLOC) && !defined(STBIW_FREE) && !defined(STBIW_REALLOC) && !defined(STBIW_REALLOC_SIZED)", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 221, + "column": 1, + "source_line": "#elif !defined(STBIW_MALLOC) && !defined(STBIW_FREE) && !defined(STBIW_REALLOC) && !defined(STBIW_REALLOC_SIZED)" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 223, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 225, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBIW_MALLOC", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 227, + "column": 1, + "source_line": "#ifndef STBIW_MALLOC" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 231, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBIW_REALLOC_SIZED", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 233, + "column": 1, + "source_line": "#ifndef STBIW_REALLOC_SIZED" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 235, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBIW_MEMMOVE", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 238, + "column": 1, + "source_line": "#ifndef STBIW_MEMMOVE" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 240, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBIW_ASSERT", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 243, + "column": 1, + "source_line": "#ifndef STBIW_ASSERT" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 246, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STB_IMAGE_WRITE_STATIC", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 250, + "column": 1, + "source_line": "#ifdef STB_IMAGE_WRITE_STATIC" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 254, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 258, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_WRITE_NO_STDIO", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 282, + "column": 1, + "source_line": "#ifndef STBI_WRITE_NO_STDIO" + } + }, + { + "directive": "if", + "argument": "defined(_WIN32) && defined(STBIW_WINDOWS_UTF8)", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 289, + "column": 1, + "source_line": "#if defined(_WIN32) && defined(STBIW_WINDOWS_UTF8)" + } + }, + { + "directive": "ifdef", + "argument": "__cplusplus", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 290, + "column": 1, + "source_line": "#ifdef __cplusplus" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 292, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 294, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 302, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "defined(_WIN32) && defined(STBIW_WINDOWS_UTF8)", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 307, + "column": 1, + "source_line": "#if defined(_WIN32) && defined(STBIW_WINDOWS_UTF8)" + } + }, + { + "directive": "if", + "argument": "defined(_MSC_VER) && _MSC_VER >= 1400", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 316, + "column": 1, + "source_line": "#if defined(_MSC_VER) && _MSC_VER >= 1400" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 319, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 321, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "elif", + "argument": "defined(_MSC_VER) && _MSC_VER >= 1400", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 323, + "column": 1, + "source_line": "#elif defined(_MSC_VER) && _MSC_VER >= 1400" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 326, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 328, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 344, + "column": 1, + "source_line": "#endif // !STBI_WRITE_NO_STDIO" + } + }, + { + "directive": "ifndef", + "argument": "STBI_WRITE_NO_STDIO", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 519, + "column": 1, + "source_line": "#ifndef STBI_WRITE_NO_STDIO" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 530, + "column": 1, + "source_line": "#endif //!STBI_WRITE_NO_STDIO" + } + }, + { + "directive": "ifndef", + "argument": "STBI_WRITE_NO_STDIO", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 618, + "column": 1, + "source_line": "#ifndef STBI_WRITE_NO_STDIO" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 629, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_WRITE_NO_STDIO", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 637, + "column": 1, + "source_line": "#ifndef STBI_WRITE_NO_STDIO" + } + }, + { + "directive": "ifdef", + "argument": "__STDC_LIB_EXT1__", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 773, + "column": 1, + "source_line": "#ifdef __STDC_LIB_EXT1__" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 775, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 777, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 804, + "column": 1, + "source_line": "#endif // STBI_WRITE_NO_STDIO" + } + }, + { + "directive": "ifndef", + "argument": "STBIW_ZLIB_COMPRESS", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 812, + "column": 1, + "source_line": "#ifndef STBIW_ZLIB_COMPRESS" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 893, + "column": 1, + "source_line": "#endif // STBIW_ZLIB_COMPRESS" + } + }, + { + "directive": "ifdef", + "argument": "STBIW_ZLIB_COMPRESS", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 897, + "column": 1, + "source_line": "#ifdef STBIW_ZLIB_COMPRESS" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 900, + "column": 1, + "source_line": "#else // use builtin" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 1021, + "column": 1, + "source_line": "#endif // STBIW_ZLIB_COMPRESS" + } + }, + { + "directive": "ifdef", + "argument": "STBIW_CRC32", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 1026, + "column": 1, + "source_line": "#ifdef STBIW_CRC32" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 1028, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 1070, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_WRITE_NO_STDIO", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 1214, + "column": 1, + "source_line": "#ifndef STBI_WRITE_NO_STDIO" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 1229, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBI_WRITE_NO_STDIO", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 1615, + "column": 1, + "source_line": "#ifndef STBI_WRITE_NO_STDIO" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 1626, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 1628, + "column": 1, + "source_line": "#endif // STB_IMAGE_WRITE_IMPLEMENTATION" + } + } + ], + "macro_dependencies": [ + { + "name": "STBIWDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 170, + "column": 1, + "source_line": "STBIWDEF int stbi_write_tga_with_rle;" + }, + "source_text": "STBIWDEF int stbi_write_tga_with_rle" + }, + { + "name": "STBIWDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 171, + "column": 1, + "source_line": "STBIWDEF int stbi_write_png_compression_level;" + }, + "source_text": "STBIWDEF int stbi_write_png_compression_level" + }, + { + "name": "STBIWDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 172, + "column": 1, + "source_line": "STBIWDEF int stbi_write_force_png_filter;" + }, + "source_text": "STBIWDEF int stbi_write_force_png_filter" + }, + { + "name": "STBIWDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 176, + "column": 1, + "source_line": "STBIWDEF int stbi_write_png(char const *filename, int w, int h, int comp, const void *data, int stride_in_bytes);" + }, + "source_text": "STBIWDEF int stbi_write_png(char const *filename, int w, int h, int comp, const void *data, int stride_in_bytes)" + }, + { + "name": "STBIWDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 177, + "column": 1, + "source_line": "STBIWDEF int stbi_write_bmp(char const *filename, int w, int h, int comp, const void *data);" + }, + "source_text": "STBIWDEF int stbi_write_bmp(char const *filename, int w, int h, int comp, const void *data)" + }, + { + "name": "STBIWDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 178, + "column": 1, + "source_line": "STBIWDEF int stbi_write_tga(char const *filename, int w, int h, int comp, const void *data);" + }, + "source_text": "STBIWDEF int stbi_write_tga(char const *filename, int w, int h, int comp, const void *data)" + }, + { + "name": "STBIWDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 179, + "column": 1, + "source_line": "STBIWDEF int stbi_write_hdr(char const *filename, int w, int h, int comp, const float *data);" + }, + "source_text": "STBIWDEF int stbi_write_hdr(char const *filename, int w, int h, int comp, const float *data)" + }, + { + "name": "STBIWDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 180, + "column": 1, + "source_line": "STBIWDEF int stbi_write_jpg(char const *filename, int x, int y, int comp, const void *data, int quality);" + }, + "source_text": "STBIWDEF int stbi_write_jpg(char const *filename, int x, int y, int comp, const void *data, int quality)" + }, + { + "name": "STBIWDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 183, + "column": 1, + "source_line": "STBIWDEF int stbiw_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input);" + }, + "source_text": "STBIWDEF int stbiw_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input)" + }, + { + "name": "STBIWDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 189, + "column": 1, + "source_line": "STBIWDEF int stbi_write_png_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data, int stride_in_bytes);" + }, + "source_text": "STBIWDEF int stbi_write_png_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data, int stride_in_bytes)" + }, + { + "name": "STBIWDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 190, + "column": 1, + "source_line": "STBIWDEF int stbi_write_bmp_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data);" + }, + "source_text": "STBIWDEF int stbi_write_bmp_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data)" + }, + { + "name": "STBIWDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 191, + "column": 1, + "source_line": "STBIWDEF int stbi_write_tga_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data);" + }, + "source_text": "STBIWDEF int stbi_write_tga_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data)" + }, + { + "name": "STBIWDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 192, + "column": 1, + "source_line": "STBIWDEF int stbi_write_hdr_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const float *data);" + }, + "source_text": "STBIWDEF int stbi_write_hdr_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const float *data)" + }, + { + "name": "STBIWDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 193, + "column": 1, + "source_line": "STBIWDEF int stbi_write_jpg_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int quality);" + }, + "source_text": "STBIWDEF int stbi_write_jpg_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int quality)" + }, + { + "name": "STBIWDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 195, + "column": 1, + "source_line": "STBIWDEF void stbi_flip_vertically_on_write(int flip_boolean);" + }, + "source_text": "STBIWDEF void stbi_flip_vertically_on_write(int flip_boolean)" + }, + { + "name": "STBIWDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 262, + "column": 1, + "source_line": "STBIWDEF void stbi_flip_vertically_on_write(int flag)" + }, + "source_text": "STBIWDEF void stbi_flip_vertically_on_write(int flag)" + }, + { + "name": "STBIW_EXTERN", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 295, + "column": 1, + "source_line": "STBIW_EXTERN __declspec(dllimport) int __stdcall MultiByteToWideChar(unsigned int cp, unsigned long flags, const char *str, int cbmb, wchar_t *widestr, int cchwide);" + }, + "source_text": "STBIW_EXTERN __declspec(dllimport) int __stdcall MultiByteToWideChar(unsigned int cp, unsigned long flags, const char *str, int cbmb, wchar_t *widestr, int cchwide)" + }, + { + "name": "STBIW_EXTERN", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 296, + "column": 1, + "source_line": "STBIW_EXTERN __declspec(dllimport) int __stdcall WideCharToMultiByte(unsigned int cp, unsigned long flags, const wchar_t *widestr, int cchwide, char *str, int cbmb, const char *defchar, int *used_default);" + }, + "source_text": "STBIW_EXTERN __declspec(dllimport) int __stdcall WideCharToMultiByte(unsigned int cp, unsigned long flags, const wchar_t *widestr, int cchwide, char *str, int cbmb, const char *defchar, int *used_default)" + }, + { + "name": "STBIWDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 298, + "column": 1, + "source_line": "STBIWDEF int stbiw_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input)" + }, + "source_text": "STBIWDEF int stbiw_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input)" + }, + { + "name": "STBIWDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 512, + "column": 1, + "source_line": "STBIWDEF int stbi_write_bmp_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data)" + }, + "source_text": "STBIWDEF int stbi_write_bmp_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data)" + }, + { + "name": "STBIWDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 520, + "column": 1, + "source_line": "STBIWDEF int stbi_write_bmp(char const *filename, int x, int y, int comp, const void *data)" + }, + "source_text": "STBIWDEF int stbi_write_bmp(char const *filename, int x, int y, int comp, const void *data)" + }, + { + "name": "STBIWDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 611, + "column": 1, + "source_line": "STBIWDEF int stbi_write_tga_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data)" + }, + "source_text": "STBIWDEF int stbi_write_tga_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data)" + }, + { + "name": "STBIWDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 619, + "column": 1, + "source_line": "STBIWDEF int stbi_write_tga(char const *filename, int x, int y, int comp, const void *data)" + }, + "source_text": "STBIWDEF int stbi_write_tga(char const *filename, int x, int y, int comp, const void *data)" + }, + { + "name": "STBIWDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 787, + "column": 1, + "source_line": "STBIWDEF int stbi_write_hdr_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const float *data)" + }, + "source_text": "STBIWDEF int stbi_write_hdr_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const float *data)" + }, + { + "name": "STBIWDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 794, + "column": 1, + "source_line": "STBIWDEF int stbi_write_hdr(char const *filename, int x, int y, int comp, const float *data)" + }, + "source_text": "STBIWDEF int stbi_write_hdr(char const *filename, int x, int y, int comp, const float *data)" + }, + { + "name": "STBIWDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 895, + "column": 1, + "source_line": "STBIWDEF unsigned char * stbi_zlib_compress(unsigned char *data, int data_len, int *out_len, int quality)" + }, + "source_text": "STBIWDEF unsigned char * stbi_zlib_compress(unsigned char *data, int data_len, int *out_len, int quality)" + }, + { + "name": "STBIWDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 1128, + "column": 1, + "source_line": "STBIWDEF unsigned char *stbi_write_png_to_mem(const unsigned char *pixels, int stride_bytes, int x, int y, int n, int *out_len)" + }, + "source_text": "STBIWDEF unsigned char *stbi_write_png_to_mem(const unsigned char *pixels, int stride_bytes, int x, int y, int n, int *out_len)" + }, + { + "name": "STBIWDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 1215, + "column": 1, + "source_line": "STBIWDEF int stbi_write_png(char const *filename, int x, int y, int comp, const void *data, int stride_bytes)" + }, + "source_text": "STBIWDEF int stbi_write_png(char const *filename, int x, int y, int comp, const void *data, int stride_bytes)" + }, + { + "name": "STBIWDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 1231, + "column": 1, + "source_line": "STBIWDEF int stbi_write_png_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int stride_bytes)" + }, + "source_text": "STBIWDEF int stbi_write_png_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int stride_bytes)" + }, + { + "name": "STBIWDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 1607, + "column": 1, + "source_line": "STBIWDEF int stbi_write_jpg_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int quality)" + }, + "source_text": "STBIWDEF int stbi_write_jpg_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int quality)" + }, + { + "name": "STBIWDEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 1616, + "column": 1, + "source_line": "STBIWDEF int stbi_write_jpg(char const *filename, int x, int y, int comp, const void *data, int quality)" + }, + "source_text": "STBIWDEF int stbi_write_jpg(char const *filename, int x, int y, int comp, const void *data, int quality)" + } + ], + "diagnostics": [ + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIW_MALLOC' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 228, + "column": 1, + "source_line": "#define STBIW_MALLOC(sz) malloc(sz)" + }, + "unit_kind": "macro", + "unit_name": "STBIW_MALLOC" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIW_REALLOC' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 229, + "column": 1, + "source_line": "#define STBIW_REALLOC(p,newsz) realloc(p,newsz)" + }, + "unit_kind": "macro", + "unit_name": "STBIW_REALLOC" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIW_FREE' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 230, + "column": 1, + "source_line": "#define STBIW_FREE(p) free(p)" + }, + "unit_kind": "macro", + "unit_name": "STBIW_FREE" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIW_REALLOC_SIZED' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 234, + "column": 1, + "source_line": "#define STBIW_REALLOC_SIZED(p,oldsz,newsz) STBIW_REALLOC(p,newsz)" + }, + "unit_kind": "macro", + "unit_name": "STBIW_REALLOC_SIZED" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIW_MEMMOVE' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 239, + "column": 1, + "source_line": "#define STBIW_MEMMOVE(a,b,sz) memmove(a,b,sz)" + }, + "unit_kind": "macro", + "unit_name": "STBIW_MEMMOVE" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIW_ASSERT' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 245, + "column": 1, + "source_line": "#define STBIW_ASSERT(x) assert(x)" + }, + "unit_kind": "macro", + "unit_name": "STBIW_ASSERT" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIW_UCHAR' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 248, + "column": 1, + "source_line": "#define STBIW_UCHAR(x) (unsigned char) ((x) & 0xff)" + }, + "unit_kind": "macro", + "unit_name": "STBIW_UCHAR" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbiw__max' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 635, + "column": 1, + "source_line": "#define stbiw__max(a, b) ((a) > (b) ? (a) : (b))" + }, + "unit_kind": "macro", + "unit_name": "stbiw__max" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbiw__sbraw' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 814, + "column": 1, + "source_line": "#define stbiw__sbraw(a) ((int *) (void *) (a) - 2)" + }, + "unit_kind": "macro", + "unit_name": "stbiw__sbraw" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbiw__sbm' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 815, + "column": 1, + "source_line": "#define stbiw__sbm(a) stbiw__sbraw(a)[0]" + }, + "unit_kind": "macro", + "unit_name": "stbiw__sbm" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbiw__sbn' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 816, + "column": 1, + "source_line": "#define stbiw__sbn(a) stbiw__sbraw(a)[1]" + }, + "unit_kind": "macro", + "unit_name": "stbiw__sbn" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbiw__sbneedgrow' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 818, + "column": 1, + "source_line": "#define stbiw__sbneedgrow(a,n) ((a)==0 || stbiw__sbn(a)+n >= stbiw__sbm(a))" + }, + "unit_kind": "macro", + "unit_name": "stbiw__sbneedgrow" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbiw__sbmaybegrow' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 819, + "column": 1, + "source_line": "#define stbiw__sbmaybegrow(a,n) (stbiw__sbneedgrow(a,(n)) ? stbiw__sbgrow(a,n) : 0)" + }, + "unit_kind": "macro", + "unit_name": "stbiw__sbmaybegrow" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbiw__sbgrow' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 820, + "column": 1, + "source_line": "#define stbiw__sbgrow(a,n) stbiw__sbgrowf((void **) &(a), (n), sizeof(*(a)))" + }, + "unit_kind": "macro", + "unit_name": "stbiw__sbgrow" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbiw__sbpush' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 822, + "column": 1, + "source_line": "#define stbiw__sbpush(a, v) (stbiw__sbmaybegrow(a,1), (a)[stbiw__sbn(a)++] = (v))" + }, + "unit_kind": "macro", + "unit_name": "stbiw__sbpush" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbiw__sbcount' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 823, + "column": 1, + "source_line": "#define stbiw__sbcount(a) ((a) ? stbiw__sbn(a) : 0)" + }, + "unit_kind": "macro", + "unit_name": "stbiw__sbcount" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbiw__sbfree' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 824, + "column": 1, + "source_line": "#define stbiw__sbfree(a) ((a) ? STBIW_FREE(stbiw__sbraw(a)),0 : 0)" + }, + "unit_kind": "macro", + "unit_name": "stbiw__sbfree" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbiw__zlib_flush' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 879, + "column": 1, + "source_line": "#define stbiw__zlib_flush() (out = stbiw__zlib_flushf(out, &bitbuf, &bitcount))" + }, + "unit_kind": "macro", + "unit_name": "stbiw__zlib_flush" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbiw__zlib_add' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 880, + "column": 1, + "source_line": "#define stbiw__zlib_add(code,codebits) \\" + }, + "unit_kind": "macro", + "unit_name": "stbiw__zlib_add" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbiw__zlib_huffa' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 882, + "column": 1, + "source_line": "#define stbiw__zlib_huffa(b,c) stbiw__zlib_add(stbiw__zlib_bitrev(b,c),c)" + }, + "unit_kind": "macro", + "unit_name": "stbiw__zlib_huffa" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbiw__zlib_huff1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 884, + "column": 1, + "source_line": "#define stbiw__zlib_huff1(n) stbiw__zlib_huffa(0x30 + (n), 8)" + }, + "unit_kind": "macro", + "unit_name": "stbiw__zlib_huff1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbiw__zlib_huff2' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 885, + "column": 1, + "source_line": "#define stbiw__zlib_huff2(n) stbiw__zlib_huffa(0x190 + (n)-144, 9)" + }, + "unit_kind": "macro", + "unit_name": "stbiw__zlib_huff2" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbiw__zlib_huff3' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 886, + "column": 1, + "source_line": "#define stbiw__zlib_huff3(n) stbiw__zlib_huffa(0 + (n)-256,7)" + }, + "unit_kind": "macro", + "unit_name": "stbiw__zlib_huff3" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbiw__zlib_huff4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 887, + "column": 1, + "source_line": "#define stbiw__zlib_huff4(n) stbiw__zlib_huffa(0xc0 + (n)-280,8)" + }, + "unit_kind": "macro", + "unit_name": "stbiw__zlib_huff4" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbiw__zlib_huff' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 888, + "column": 1, + "source_line": "#define stbiw__zlib_huff(n) ((n) <= 143 ? stbiw__zlib_huff1(n) : (n) <= 255 ? stbiw__zlib_huff2(n) : (n) <= 279 ? stbiw__zlib_huff3(n) : stbiw__zlib_huff4(n))" + }, + "unit_kind": "macro", + "unit_name": "stbiw__zlib_huff" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbiw__zlib_huffb' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 889, + "column": 1, + "source_line": "#define stbiw__zlib_huffb(n) ((n) <= 143 ? stbiw__zlib_huff1(n) : stbiw__zlib_huff2(n))" + }, + "unit_kind": "macro", + "unit_name": "stbiw__zlib_huffb" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbiw__wpng4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 1073, + "column": 1, + "source_line": "#define stbiw__wpng4(o,a,b,c,d) ((o)[0]=STBIW_UCHAR(a),(o)[1]=STBIW_UCHAR(b),(o)[2]=STBIW_UCHAR(c),(o)[3]=STBIW_UCHAR(d),(o)+=4)" + }, + "unit_kind": "macro", + "unit_name": "stbiw__wpng4" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbiw__wp32' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 1074, + "column": 1, + "source_line": "#define stbiw__wp32(data,v) stbiw__wpng4(data, (v)>>24,(v)>>16,(v)>>8,(v));" + }, + "unit_kind": "macro", + "unit_name": "stbiw__wp32" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbiw__wptag' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 1075, + "column": 1, + "source_line": "#define stbiw__wptag(data,s) stbiw__wpng4(data, s[0],s[1],s[2],s[3])" + }, + "unit_kind": "macro", + "unit_name": "stbiw__wptag" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIWDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 170, + "column": 1, + "source_line": "STBIWDEF int stbi_write_tga_with_rle;" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIWDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIWDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 171, + "column": 1, + "source_line": "STBIWDEF int stbi_write_png_compression_level;" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIWDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIWDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 172, + "column": 1, + "source_line": "STBIWDEF int stbi_write_force_png_filter;" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIWDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIWDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 176, + "column": 1, + "source_line": "STBIWDEF int stbi_write_png(char const *filename, int w, int h, int comp, const void *data, int stride_in_bytes);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIWDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIWDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 177, + "column": 1, + "source_line": "STBIWDEF int stbi_write_bmp(char const *filename, int w, int h, int comp, const void *data);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIWDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIWDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 178, + "column": 1, + "source_line": "STBIWDEF int stbi_write_tga(char const *filename, int w, int h, int comp, const void *data);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIWDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIWDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 179, + "column": 1, + "source_line": "STBIWDEF int stbi_write_hdr(char const *filename, int w, int h, int comp, const float *data);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIWDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIWDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 180, + "column": 1, + "source_line": "STBIWDEF int stbi_write_jpg(char const *filename, int x, int y, int comp, const void *data, int quality);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIWDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIWDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 183, + "column": 1, + "source_line": "STBIWDEF int stbiw_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIWDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIWDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 189, + "column": 1, + "source_line": "STBIWDEF int stbi_write_png_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data, int stride_in_bytes);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIWDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIWDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 190, + "column": 1, + "source_line": "STBIWDEF int stbi_write_bmp_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIWDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIWDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 191, + "column": 1, + "source_line": "STBIWDEF int stbi_write_tga_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIWDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIWDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 192, + "column": 1, + "source_line": "STBIWDEF int stbi_write_hdr_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const float *data);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIWDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIWDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 193, + "column": 1, + "source_line": "STBIWDEF int stbi_write_jpg_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int quality);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIWDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIWDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 195, + "column": 1, + "source_line": "STBIWDEF void stbi_flip_vertically_on_write(int flip_boolean);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIWDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIWDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 262, + "column": 1, + "source_line": "STBIWDEF void stbi_flip_vertically_on_write(int flag)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIWDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIW_EXTERN'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 295, + "column": 1, + "source_line": "STBIW_EXTERN __declspec(dllimport) int __stdcall MultiByteToWideChar(unsigned int cp, unsigned long flags, const char *str, int cbmb, wchar_t *widestr, int cchwide);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIW_EXTERN" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIW_EXTERN'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 296, + "column": 1, + "source_line": "STBIW_EXTERN __declspec(dllimport) int __stdcall WideCharToMultiByte(unsigned int cp, unsigned long flags, const wchar_t *widestr, int cchwide, char *str, int cbmb, const char *defchar, int *used_default);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIW_EXTERN" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIWDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 298, + "column": 1, + "source_line": "STBIWDEF int stbiw_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIWDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIWDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 512, + "column": 1, + "source_line": "STBIWDEF int stbi_write_bmp_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIWDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIWDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 520, + "column": 1, + "source_line": "STBIWDEF int stbi_write_bmp(char const *filename, int x, int y, int comp, const void *data)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIWDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIWDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 611, + "column": 1, + "source_line": "STBIWDEF int stbi_write_tga_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIWDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIWDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 619, + "column": 1, + "source_line": "STBIWDEF int stbi_write_tga(char const *filename, int x, int y, int comp, const void *data)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIWDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIWDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 787, + "column": 1, + "source_line": "STBIWDEF int stbi_write_hdr_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const float *data)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIWDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIWDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 794, + "column": 1, + "source_line": "STBIWDEF int stbi_write_hdr(char const *filename, int x, int y, int comp, const float *data)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIWDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIWDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 895, + "column": 1, + "source_line": "STBIWDEF unsigned char * stbi_zlib_compress(unsigned char *data, int data_len, int *out_len, int quality)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIWDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIWDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 1128, + "column": 1, + "source_line": "STBIWDEF unsigned char *stbi_write_png_to_mem(const unsigned char *pixels, int stride_bytes, int x, int y, int n, int *out_len)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIWDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIWDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 1215, + "column": 1, + "source_line": "STBIWDEF int stbi_write_png(char const *filename, int x, int y, int comp, const void *data, int stride_bytes)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIWDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIWDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 1231, + "column": 1, + "source_line": "STBIWDEF int stbi_write_png_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int stride_bytes)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIWDEF" + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 1250, + "column": 1, + "source_line": "static const unsigned char stbiw__jpg_ZigZag[] = { 0,1,5,6,14,15,27,28,2,4,7,13,16,26,29,42,3,8,12,17,25,30,41,43,9,11,18," + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIWDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 1607, + "column": 1, + "source_line": "STBIWDEF int stbi_write_jpg_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int quality)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIWDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIWDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 1616, + "column": 1, + "source_line": "STBIWDEF int stbi_write_jpg(char const *filename, int x, int y, int comp, const void *data, int quality)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIWDEF" + }, + { + "code": "C_DUPLICATE_VARIABLE_DEFINITION", + "message": "Duplicate definition for variable 'stbi_write_png_compression_level'.", + "severity": "error", + "location": { + "filename": "stb/stb_image_write.h", + "line": 255, + "column": 1, + "source_line": "int stbi_write_png_compression_level = 8;" + }, + "unit_kind": "variable", + "unit_name": "stbi_write_png_compression_level" + }, + { + "code": "C_DUPLICATE_VARIABLE_DEFINITION", + "message": "Duplicate definition for variable 'stbi_write_tga_with_rle'.", + "severity": "error", + "location": { + "filename": "stb/stb_image_write.h", + "line": 256, + "column": 1, + "source_line": "int stbi_write_tga_with_rle = 1;" + }, + "unit_kind": "variable", + "unit_name": "stbi_write_tga_with_rle" + }, + { + "code": "C_DUPLICATE_VARIABLE_DEFINITION", + "message": "Duplicate definition for variable 'stbi_write_force_png_filter'.", + "severity": "error", + "location": { + "filename": "stb/stb_image_write.h", + "line": 257, + "column": 1, + "source_line": "int stbi_write_force_png_filter = -1;" + }, + "unit_kind": "variable", + "unit_name": "stbi_write_force_png_filter" + } + ] + } + }, + "functions": { + "stbi__start_write_callbacks": { + "name": "stbi__start_write_callbacks", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_write_func *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_write_func" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi_write_func *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi_write_func" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "context", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *context", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *context", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 276, + "column": 1, + "source_line": "static void stbi__start_write_callbacks(stbi__write_context *s, stbi_write_func *c, void *context)" + }, + "start": { + "filename": "stb/stb_image_write.h", + "line": 276, + "column": 1, + "source_line": "static void stbi__start_write_callbacks(stbi__write_context *s, stbi_write_func *c, void *context)" + }, + "end": { + "filename": "stb/stb_image_write.h", + "line": 280, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__stdio_write": { + "name": "stbi__stdio_write", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "context", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *context", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *context", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "size", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int size" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int size" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 284, + "column": 1, + "source_line": "static void stbi__stdio_write(void *context, void *data, int size)" + }, + "start": { + "filename": "stb/stb_image_write.h", + "line": 284, + "column": 1, + "source_line": "static void stbi__stdio_write(void *context, void *data, int size)" + }, + "end": { + "filename": "stb/stb_image_write.h", + "line": 287, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbiw__fopen": { + "name": "stbiw__fopen", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "FILE", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "FILE" + } + ] + }, + "parameters": [ + { + "name": "filename", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char const *filename", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char const *filename", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mode", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char const *mode", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char const *mode", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 304, + "column": 1, + "source_line": "static FILE *stbiw__fopen(char const *filename, char const *mode)" + }, + "start": { + "filename": "stb/stb_image_write.h", + "line": 304, + "column": 1, + "source_line": "static FILE *stbiw__fopen(char const *filename, char const *mode)" + }, + "end": { + "filename": "stb/stb_image_write.h", + "line": 330, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__start_write_file": { + "name": "stbi__start_write_file", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "filename", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *filename", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *filename", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 332, + "column": 1, + "source_line": "static int stbi__start_write_file(stbi__write_context *s, const char *filename)" + }, + "start": { + "filename": "stb/stb_image_write.h", + "line": 332, + "column": 1, + "source_line": "static int stbi__start_write_file(stbi__write_context *s, const char *filename)" + }, + "end": { + "filename": "stb/stb_image_write.h", + "line": 337, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi__end_write_file": { + "name": "stbi__end_write_file", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 339, + "column": 1, + "source_line": "static void stbi__end_write_file(stbi__write_context *s)" + }, + "start": { + "filename": "stb/stb_image_write.h", + "line": 339, + "column": 1, + "source_line": "static void stbi__end_write_file(stbi__write_context *s)" + }, + "end": { + "filename": "stb/stb_image_write.h", + "line": 342, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbiw__writefv": { + "name": "stbiw__writefv", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "fmt", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *fmt", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *fmt", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "v", + "type": { + "reference": "va_list" + }, + "declared_type": { + "reference": "va_list" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 349, + "column": 1, + "source_line": "static void stbiw__writefv(stbi__write_context *s, const char *fmt, va_list v)" + }, + "start": { + "filename": "stb/stb_image_write.h", + "line": 349, + "column": 1, + "source_line": "static void stbiw__writefv(stbi__write_context *s, const char *fmt, va_list v)" + }, + "end": { + "filename": "stb/stb_image_write.h", + "line": 376, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbiw__writef": { + "name": "stbiw__writef", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "fmt", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *fmt", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *fmt", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": true, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 378, + "column": 1, + "source_line": "static void stbiw__writef(stbi__write_context *s, const char *fmt, ...)" + }, + "start": { + "filename": "stb/stb_image_write.h", + "line": 378, + "column": 1, + "source_line": "static void stbiw__writef(stbi__write_context *s, const char *fmt, ...)" + }, + "end": { + "filename": "stb/stb_image_write.h", + "line": 384, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbiw__write_flush": { + "name": "stbiw__write_flush", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 386, + "column": 1, + "source_line": "static void stbiw__write_flush(stbi__write_context *s)" + }, + "start": { + "filename": "stb/stb_image_write.h", + "line": 386, + "column": 1, + "source_line": "static void stbiw__write_flush(stbi__write_context *s)" + }, + "end": { + "filename": "stb/stb_image_write.h", + "line": 392, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbiw__putc": { + "name": "stbiw__putc", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char c" + }, + "declared_type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char c" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 394, + "column": 1, + "source_line": "static void stbiw__putc(stbi__write_context *s, unsigned char c)" + }, + "start": { + "filename": "stb/stb_image_write.h", + "line": 394, + "column": 1, + "source_line": "static void stbiw__putc(stbi__write_context *s, unsigned char c)" + }, + "end": { + "filename": "stb/stb_image_write.h", + "line": 397, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbiw__write1": { + "name": "stbiw__write1", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "a", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char a" + }, + "declared_type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char a" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 399, + "column": 1, + "source_line": "static void stbiw__write1(stbi__write_context *s, unsigned char a)" + }, + "start": { + "filename": "stb/stb_image_write.h", + "line": 399, + "column": 1, + "source_line": "static void stbiw__write1(stbi__write_context *s, unsigned char a)" + }, + "end": { + "filename": "stb/stb_image_write.h", + "line": 404, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbiw__write3": { + "name": "stbiw__write3", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "a", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char a" + }, + "declared_type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char a" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char b" + }, + "declared_type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char b" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char c" + }, + "declared_type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char c" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 406, + "column": 1, + "source_line": "static void stbiw__write3(stbi__write_context *s, unsigned char a, unsigned char b, unsigned char c)" + }, + "start": { + "filename": "stb/stb_image_write.h", + "line": 406, + "column": 1, + "source_line": "static void stbiw__write3(stbi__write_context *s, unsigned char a, unsigned char b, unsigned char c)" + }, + "end": { + "filename": "stb/stb_image_write.h", + "line": 416, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbiw__write_pixel": { + "name": "stbiw__write_pixel", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "rgb_dir", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int rgb_dir" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int rgb_dir" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int comp" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int comp" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "write_alpha", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int write_alpha" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int write_alpha" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "expand_mono", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int expand_mono" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int expand_mono" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "d", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *d", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *d", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 418, + "column": 1, + "source_line": "static void stbiw__write_pixel(stbi__write_context *s, int rgb_dir, int comp, int write_alpha, int expand_mono, unsigned char *d)" + }, + "start": { + "filename": "stb/stb_image_write.h", + "line": 418, + "column": 1, + "source_line": "static void stbiw__write_pixel(stbi__write_context *s, int rgb_dir, int comp, int write_alpha, int expand_mono, unsigned char *d)" + }, + "end": { + "filename": "stb/stb_image_write.h", + "line": 449, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbiw__write_pixels": { + "name": "stbiw__write_pixels", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "rgb_dir", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int rgb_dir" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int rgb_dir" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "vdir", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int vdir" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int vdir" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int comp" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int comp" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "write_alpha", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int write_alpha" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int write_alpha" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "scanline_pad", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int scanline_pad" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int scanline_pad" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "expand_mono", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int expand_mono" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int expand_mono" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 451, + "column": 1, + "source_line": "static void stbiw__write_pixels(stbi__write_context *s, int rgb_dir, int vdir, int x, int y, int comp, void *data, int write_alpha, int scanline_pad, int expand_mono)" + }, + "start": { + "filename": "stb/stb_image_write.h", + "line": 451, + "column": 1, + "source_line": "static void stbiw__write_pixels(stbi__write_context *s, int rgb_dir, int vdir, int x, int y, int comp, void *data, int write_alpha, int scanline_pad, int expand_mono)" + }, + "end": { + "filename": "stb/stb_image_write.h", + "line": 476, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbiw__outfile": { + "name": "stbiw__outfile", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "rgb_dir", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int rgb_dir" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int rgb_dir" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "vdir", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int vdir" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int vdir" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int comp" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int comp" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "expand_mono", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int expand_mono" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int expand_mono" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "alpha", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int alpha" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int alpha" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "pad", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int pad" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int pad" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "fmt", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *fmt", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *fmt", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": true, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 478, + "column": 1, + "source_line": "static int stbiw__outfile(stbi__write_context *s, int rgb_dir, int vdir, int x, int y, int comp, int expand_mono, void *data, int alpha, int pad, const char *fmt, ...)" + }, + "start": { + "filename": "stb/stb_image_write.h", + "line": 478, + "column": 1, + "source_line": "static int stbiw__outfile(stbi__write_context *s, int rgb_dir, int vdir, int x, int y, int comp, int expand_mono, void *data, int alpha, int pad, const char *fmt, ...)" + }, + "end": { + "filename": "stb/stb_image_write.h", + "line": 490, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi_write_bmp_core": { + "name": "stbi_write_bmp_core", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int comp" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int comp" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const void *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [ + "const" + ], + "source_text": "const void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const void *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [ + "const" + ], + "source_text": "const void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 492, + "column": 1, + "source_line": "static int stbi_write_bmp_core(stbi__write_context *s, int x, int y, int comp, const void *data)" + }, + "start": { + "filename": "stb/stb_image_write.h", + "line": 492, + "column": 1, + "source_line": "static int stbi_write_bmp_core(stbi__write_context *s, int x, int y, int comp, const void *data)" + }, + "end": { + "filename": "stb/stb_image_write.h", + "line": 510, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi_write_tga_core": { + "name": "stbi_write_tga_core", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int comp" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int comp" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 532, + "column": 1, + "source_line": "static int stbi_write_tga_core(stbi__write_context *s, int x, int y, int comp, void *data)" + }, + "start": { + "filename": "stb/stb_image_write.h", + "line": 532, + "column": 1, + "source_line": "static int stbi_write_tga_core(stbi__write_context *s, int x, int y, int comp, void *data)" + }, + "end": { + "filename": "stb/stb_image_write.h", + "line": 609, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbiw__linear_to_rgbe": { + "name": "stbiw__linear_to_rgbe", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "rgbe", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *rgbe", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *rgbe", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "linear", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *linear", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *linear", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 639, + "column": 1, + "source_line": "static void stbiw__linear_to_rgbe(unsigned char *rgbe, float *linear)" + }, + "start": { + "filename": "stb/stb_image_write.h", + "line": 639, + "column": 1, + "source_line": "static void stbiw__linear_to_rgbe(unsigned char *rgbe, float *linear)" + }, + "end": { + "filename": "stb/stb_image_write.h", + "line": 654, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbiw__write_run_data": { + "name": "stbiw__write_run_data", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "length", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int length" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int length" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "databyte", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char databyte" + }, + "declared_type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char databyte" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 656, + "column": 1, + "source_line": "static void stbiw__write_run_data(stbi__write_context *s, int length, unsigned char databyte)" + }, + "start": { + "filename": "stb/stb_image_write.h", + "line": 656, + "column": 1, + "source_line": "static void stbiw__write_run_data(stbi__write_context *s, int length, unsigned char databyte)" + }, + "end": { + "filename": "stb/stb_image_write.h", + "line": 662, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbiw__write_dump_data": { + "name": "stbiw__write_dump_data", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "length", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int length" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int length" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 664, + "column": 1, + "source_line": "static void stbiw__write_dump_data(stbi__write_context *s, int length, unsigned char *data)" + }, + "start": { + "filename": "stb/stb_image_write.h", + "line": 664, + "column": 1, + "source_line": "static void stbiw__write_dump_data(stbi__write_context *s, int length, unsigned char *data)" + }, + "end": { + "filename": "stb/stb_image_write.h", + "line": 670, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbiw__write_hdr_scanline": { + "name": "stbiw__write_hdr_scanline", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "width", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ncomp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ncomp" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ncomp" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "scratch", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *scratch", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *scratch", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "scanline", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *scanline", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *scanline", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 672, + "column": 1, + "source_line": "static void stbiw__write_hdr_scanline(stbi__write_context *s, int width, int ncomp, unsigned char *scratch, float *scanline)" + }, + "start": { + "filename": "stb/stb_image_write.h", + "line": 672, + "column": 1, + "source_line": "static void stbiw__write_hdr_scanline(stbi__write_context *s, int width, int ncomp, unsigned char *scratch, float *scanline)" + }, + "end": { + "filename": "stb/stb_image_write.h", + "line": 759, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi_write_hdr_core": { + "name": "stbi_write_hdr_core", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int comp" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int comp" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 761, + "column": 1, + "source_line": "static int stbi_write_hdr_core(stbi__write_context *s, int x, int y, int comp, float *data)" + }, + "start": { + "filename": "stb/stb_image_write.h", + "line": 761, + "column": 1, + "source_line": "static int stbi_write_hdr_core(stbi__write_context *s, int x, int y, int comp, float *data)" + }, + "end": { + "filename": "stb/stb_image_write.h", + "line": 785, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbiw__sbgrowf": { + "name": "stbiw__sbgrowf", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "parameters": [ + { + "name": "arr", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void **arr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void **arr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "increment", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int increment" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int increment" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "itemsize", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int itemsize" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int itemsize" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 826, + "column": 1, + "source_line": "static void *stbiw__sbgrowf(void **arr, int increment, int itemsize)" + }, + "start": { + "filename": "stb/stb_image_write.h", + "line": 826, + "column": 1, + "source_line": "static void *stbiw__sbgrowf(void **arr, int increment, int itemsize)" + }, + "end": { + "filename": "stb/stb_image_write.h", + "line": 837, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbiw__zlib_flushf": { + "name": "stbiw__zlib_flushf", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "parameters": [ + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "bitbuffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned int *bitbuffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned int *bitbuffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "bitcount", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *bitcount", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *bitcount", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 839, + "column": 1, + "source_line": "static unsigned char *stbiw__zlib_flushf(unsigned char *data, unsigned int *bitbuffer, int *bitcount)" + }, + "start": { + "filename": "stb/stb_image_write.h", + "line": 839, + "column": 1, + "source_line": "static unsigned char *stbiw__zlib_flushf(unsigned char *data, unsigned int *bitbuffer, int *bitcount)" + }, + "end": { + "filename": "stb/stb_image_write.h", + "line": 847, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbiw__zlib_bitrev": { + "name": "stbiw__zlib_bitrev", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "code", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int code" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int code" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "codebits", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int codebits" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int codebits" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 849, + "column": 1, + "source_line": "static int stbiw__zlib_bitrev(int code, int codebits)" + }, + "start": { + "filename": "stb/stb_image_write.h", + "line": 849, + "column": 1, + "source_line": "static int stbiw__zlib_bitrev(int code, int codebits)" + }, + "end": { + "filename": "stb/stb_image_write.h", + "line": 857, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbiw__zlib_countm": { + "name": "stbiw__zlib_countm", + "result_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *b", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *b", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "limit", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int limit" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int limit" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 859, + "column": 1, + "source_line": "static unsigned int stbiw__zlib_countm(unsigned char *a, unsigned char *b, int limit)" + }, + "start": { + "filename": "stb/stb_image_write.h", + "line": 859, + "column": 1, + "source_line": "static unsigned int stbiw__zlib_countm(unsigned char *a, unsigned char *b, int limit)" + }, + "end": { + "filename": "stb/stb_image_write.h", + "line": 865, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbiw__zhash": { + "name": "stbiw__zhash", + "result_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int" + }, + "parameters": [ + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 867, + "column": 1, + "source_line": "static unsigned int stbiw__zhash(unsigned char *data)" + }, + "start": { + "filename": "stb/stb_image_write.h", + "line": 867, + "column": 1, + "source_line": "static unsigned int stbiw__zhash(unsigned char *data)" + }, + "end": { + "filename": "stb/stb_image_write.h", + "line": 877, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbiw__crc32": { + "name": "stbiw__crc32", + "result_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int" + }, + "parameters": [ + { + "name": "buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 1024, + "column": 1, + "source_line": "static unsigned int stbiw__crc32(unsigned char *buffer, int len)" + }, + "start": { + "filename": "stb/stb_image_write.h", + "line": 1024, + "column": 1, + "source_line": "static unsigned int stbiw__crc32(unsigned char *buffer, int len)" + }, + "end": { + "filename": "stb/stb_image_write.h", + "line": 1071, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbiw__wpcrc": { + "name": "stbiw__wpcrc", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char **data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char **data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 1077, + "column": 1, + "source_line": "static void stbiw__wpcrc(unsigned char **data, int len)" + }, + "start": { + "filename": "stb/stb_image_write.h", + "line": 1077, + "column": 1, + "source_line": "static void stbiw__wpcrc(unsigned char **data, int len)" + }, + "end": { + "filename": "stb/stb_image_write.h", + "line": 1081, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbiw__paeth": { + "name": "stbiw__paeth", + "result_type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 1083, + "column": 1, + "source_line": "static unsigned char stbiw__paeth(int a, int b, int c)" + }, + "start": { + "filename": "stb/stb_image_write.h", + "line": 1083, + "column": 1, + "source_line": "static unsigned char stbiw__paeth(int a, int b, int c)" + }, + "end": { + "filename": "stb/stb_image_write.h", + "line": 1089, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbiw__encode_png_line": { + "name": "stbiw__encode_png_line", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "pixels", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *pixels", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *pixels", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "stride_bytes", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int stride_bytes" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int stride_bytes" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "width", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "height", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int height" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int height" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "filter_type", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int filter_type" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int filter_type" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "line_buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "signed char *line_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CSignedChar", + "qualifiers": [], + "source_text": "signed char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "signed char *line_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CSignedChar", + "qualifiers": [], + "source_text": "signed char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 1092, + "column": 1, + "source_line": "static void stbiw__encode_png_line(unsigned char *pixels, int stride_bytes, int width, int height, int y, int n, int filter_type, signed char *line_buffer)" + }, + "start": { + "filename": "stb/stb_image_write.h", + "line": 1092, + "column": 1, + "source_line": "static void stbiw__encode_png_line(unsigned char *pixels, int stride_bytes, int width, int height, int y, int n, int filter_type, signed char *line_buffer)" + }, + "end": { + "filename": "stb/stb_image_write.h", + "line": 1126, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbiw__jpg_writeBits": { + "name": "stbiw__jpg_writeBits", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "bitBufP", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *bitBufP", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *bitBufP", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "bitCntP", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *bitCntP", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *bitCntP", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "bs", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const unsigned short *bs", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedShort", + "qualifiers": [ + "const" + ], + "source_text": "const unsigned short" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const unsigned short *bs", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedShort", + "qualifiers": [ + "const" + ], + "source_text": "const unsigned short" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 1253, + "column": 1, + "source_line": "static void stbiw__jpg_writeBits(stbi__write_context *s, int *bitBufP, int *bitCntP, const unsigned short *bs) {" + }, + "start": { + "filename": "stb/stb_image_write.h", + "line": 1253, + "column": 1, + "source_line": "static void stbiw__jpg_writeBits(stbi__write_context *s, int *bitBufP, int *bitCntP, const unsigned short *bs) {" + }, + "end": { + "filename": "stb/stb_image_write.h", + "line": 1268, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbiw__jpg_DCT": { + "name": "stbiw__jpg_DCT", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "d0p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *d0p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *d0p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "d1p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *d1p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *d1p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "d2p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *d2p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *d2p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "d3p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *d3p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *d3p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "d4p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *d4p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *d4p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "d5p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *d5p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *d5p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "d6p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *d6p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *d6p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "d7p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *d7p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *d7p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 1270, + "column": 1, + "source_line": "static void stbiw__jpg_DCT(float *d0p, float *d1p, float *d2p, float *d3p, float *d4p, float *d5p, float *d6p, float *d7p) {" + }, + "start": { + "filename": "stb/stb_image_write.h", + "line": 1270, + "column": 1, + "source_line": "static void stbiw__jpg_DCT(float *d0p, float *d1p, float *d2p, float *d3p, float *d4p, float *d5p, float *d6p, float *d7p) {" + }, + "end": { + "filename": "stb/stb_image_write.h", + "line": 1316, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbiw__jpg_calcBits": { + "name": "stbiw__jpg_calcBits", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "val", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int val" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int val" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "bits", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned short bits[2]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedShort", + "qualifiers": [], + "source_text": "unsigned short" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned short bits[2]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "2", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CUnsignedShort", + "qualifiers": [], + "source_text": "unsigned short" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 1318, + "column": 1, + "source_line": "static void stbiw__jpg_calcBits(int val, unsigned short bits[2]) {" + }, + "start": { + "filename": "stb/stb_image_write.h", + "line": 1318, + "column": 1, + "source_line": "static void stbiw__jpg_calcBits(int val, unsigned short bits[2]) {" + }, + "end": { + "filename": "stb/stb_image_write.h", + "line": 1326, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbiw__jpg_processDU": { + "name": "stbiw__jpg_processDU", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "bitBuf", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *bitBuf", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *bitBuf", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "bitCnt", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *bitCnt", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *bitCnt", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "CDU", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *CDU", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *CDU", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "du_stride", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int du_stride" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int du_stride" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "fdtbl", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *fdtbl", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *fdtbl", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "DC", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int DC" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int DC" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "HTDC", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const unsigned short HTDC[256][2]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "2", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CUnsignedShort", + "qualifiers": [ + "const" + ], + "source_text": "const unsigned short" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const unsigned short HTDC[256][2]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "256", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "2", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CUnsignedShort", + "qualifiers": [ + "const" + ], + "source_text": "const unsigned short" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "HTAC", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const unsigned short HTAC[256][2]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "2", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CUnsignedShort", + "qualifiers": [ + "const" + ], + "source_text": "const unsigned short" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const unsigned short HTAC[256][2]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "256", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "2", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CUnsignedShort", + "qualifiers": [ + "const" + ], + "source_text": "const unsigned short" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 1328, + "column": 1, + "source_line": "static int stbiw__jpg_processDU(stbi__write_context *s, int *bitBuf, int *bitCnt, float *CDU, int du_stride, float *fdtbl, int DC, const unsigned short HTDC[256][2], const unsigned short HTAC[256][2]) {" + }, + "start": { + "filename": "stb/stb_image_write.h", + "line": 1328, + "column": 1, + "source_line": "static int stbiw__jpg_processDU(stbi__write_context *s, int *bitBuf, int *bitCnt, float *CDU, int du_stride, float *fdtbl, int DC, const unsigned short HTDC[256][2], const unsigned short HTAC[256][2]) {" + }, + "end": { + "filename": "stb/stb_image_write.h", + "line": 1396, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbi_write_jpg_core": { + "name": "stbi_write_jpg_core", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbi__write_context *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbi__write_context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "width", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "height", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int height" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int height" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "comp", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int comp" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int comp" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const void * data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [ + "const" + ], + "source_text": "const void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const void * data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [ + "const" + ], + "source_text": "const void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "quality", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int quality" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int quality" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 1398, + "column": 1, + "source_line": "static int stbi_write_jpg_core(stbi__write_context *s, int width, int height, int comp, const void* data, int quality) {" + }, + "start": { + "filename": "stb/stb_image_write.h", + "line": 1398, + "column": 1, + "source_line": "static int stbi_write_jpg_core(stbi__write_context *s, int width, int height, int comp, const void* data, int quality) {" + }, + "end": { + "filename": "stb/stb_image_write.h", + "line": 1605, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + } + }, + "structs": {}, + "unions": {}, + "enums": {}, + "typedefs": { + "stbi_write_func": { + "reference": "stbi_write_func" + }, + "stbi__write_context": { + "reference": "stbi__write_context" + }, + "stbiw_uint32": { + "reference": "stbiw_uint32" + }, + "stb_image_write_test": { + "reference": "stb_image_write_test" + } + }, + "variables": { + "stbi_write_png_compression_level": { + "name": "stbi_write_png_compression_level", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "static int stbi_write_png_compression_level" + }, + "storage": [ + "static" + ], + "initializer": { + "source_text": "8" + }, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 251, + "column": 1, + "source_line": "static int stbi_write_png_compression_level = 8;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + "stbi_write_tga_with_rle": { + "name": "stbi_write_tga_with_rle", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "static int stbi_write_tga_with_rle" + }, + "storage": [ + "static" + ], + "initializer": { + "source_text": "1" + }, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 252, + "column": 1, + "source_line": "static int stbi_write_tga_with_rle = 1;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + "stbi_write_force_png_filter": { + "name": "stbi_write_force_png_filter", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "static int stbi_write_force_png_filter" + }, + "storage": [ + "static" + ], + "initializer": { + "source_text": "-1" + }, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 253, + "column": 1, + "source_line": "static int stbi_write_force_png_filter = -1;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + "stbi__flip_vertically_on_write": { + "name": "stbi__flip_vertically_on_write", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "static int stbi__flip_vertically_on_write" + }, + "storage": [ + "static" + ], + "initializer": { + "source_text": "0" + }, + "bit_width": null, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 260, + "column": 1, + "source_line": "static int stbi__flip_vertically_on_write = 0;" + }, + "callback_policy": null, + "declaration_locations": [] + } + }, + "macros": { + "INCLUDE_STB_IMAGE_WRITE_H": { + "name": "INCLUDE_STB_IMAGE_WRITE_H", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 152, + "column": 1, + "source_line": "#define INCLUDE_STB_IMAGE_WRITE_H" + } + }, + "STBIWDEF": { + "name": "STBIWDEF", + "value": "extern", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 164, + "column": 1, + "source_line": "#define STBIWDEF extern" + } + }, + "_CRT_SECURE_NO_WARNINGS": { + "name": "_CRT_SECURE_NO_WARNINGS", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 203, + "column": 4, + "source_line": " #define _CRT_SECURE_NO_WARNINGS" + } + }, + "_CRT_NONSTDC_NO_DEPRECATE": { + "name": "_CRT_NONSTDC_NO_DEPRECATE", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 206, + "column": 4, + "source_line": " #define _CRT_NONSTDC_NO_DEPRECATE" + } + }, + "STBIW_MALLOC": { + "name": "STBIW_MALLOC", + "value": "malloc(sz)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 228, + "column": 1, + "source_line": "#define STBIW_MALLOC(sz) malloc(sz)" + } + }, + "STBIW_REALLOC": { + "name": "STBIW_REALLOC", + "value": "realloc(p,newsz)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 229, + "column": 1, + "source_line": "#define STBIW_REALLOC(p,newsz) realloc(p,newsz)" + } + }, + "STBIW_FREE": { + "name": "STBIW_FREE", + "value": "free(p)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 230, + "column": 1, + "source_line": "#define STBIW_FREE(p) free(p)" + } + }, + "STBIW_REALLOC_SIZED": { + "name": "STBIW_REALLOC_SIZED", + "value": "STBIW_REALLOC(p,newsz)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 234, + "column": 1, + "source_line": "#define STBIW_REALLOC_SIZED(p,oldsz,newsz) STBIW_REALLOC(p,newsz)" + } + }, + "STBIW_MEMMOVE": { + "name": "STBIW_MEMMOVE", + "value": "memmove(a,b,sz)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 239, + "column": 1, + "source_line": "#define STBIW_MEMMOVE(a,b,sz) memmove(a,b,sz)" + } + }, + "STBIW_ASSERT": { + "name": "STBIW_ASSERT", + "value": "assert(x)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 245, + "column": 1, + "source_line": "#define STBIW_ASSERT(x) assert(x)" + } + }, + "STBIW_UCHAR": { + "name": "STBIW_UCHAR", + "value": "(unsigned char) ((x) & 0xff)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 248, + "column": 1, + "source_line": "#define STBIW_UCHAR(x) (unsigned char) ((x) & 0xff)" + } + }, + "STBIW_EXTERN": { + "name": "STBIW_EXTERN", + "value": "extern", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 293, + "column": 1, + "source_line": "#define STBIW_EXTERN extern" + } + }, + "stbiw__max": { + "name": "stbiw__max", + "value": "((a) > (b) ? (a) : (b))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 635, + "column": 1, + "source_line": "#define stbiw__max(a, b) ((a) > (b) ? (a) : (b))" + } + }, + "stbiw__sbraw": { + "name": "stbiw__sbraw", + "value": "((int *) (void *) (a) - 2)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 814, + "column": 1, + "source_line": "#define stbiw__sbraw(a) ((int *) (void *) (a) - 2)" + } + }, + "stbiw__sbm": { + "name": "stbiw__sbm", + "value": "stbiw__sbraw(a)[0]", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 815, + "column": 1, + "source_line": "#define stbiw__sbm(a) stbiw__sbraw(a)[0]" + } + }, + "stbiw__sbn": { + "name": "stbiw__sbn", + "value": "stbiw__sbraw(a)[1]", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 816, + "column": 1, + "source_line": "#define stbiw__sbn(a) stbiw__sbraw(a)[1]" + } + }, + "stbiw__sbneedgrow": { + "name": "stbiw__sbneedgrow", + "value": "((a)==0 || stbiw__sbn(a)+n >= stbiw__sbm(a))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 818, + "column": 1, + "source_line": "#define stbiw__sbneedgrow(a,n) ((a)==0 || stbiw__sbn(a)+n >= stbiw__sbm(a))" + } + }, + "stbiw__sbmaybegrow": { + "name": "stbiw__sbmaybegrow", + "value": "(stbiw__sbneedgrow(a,(n)) ? stbiw__sbgrow(a,n) : 0)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 819, + "column": 1, + "source_line": "#define stbiw__sbmaybegrow(a,n) (stbiw__sbneedgrow(a,(n)) ? stbiw__sbgrow(a,n) : 0)" + } + }, + "stbiw__sbgrow": { + "name": "stbiw__sbgrow", + "value": "stbiw__sbgrowf((void **) &(a), (n), sizeof(*(a)))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 820, + "column": 1, + "source_line": "#define stbiw__sbgrow(a,n) stbiw__sbgrowf((void **) &(a), (n), sizeof(*(a)))" + } + }, + "stbiw__sbpush": { + "name": "stbiw__sbpush", + "value": "(stbiw__sbmaybegrow(a,1), (a)[stbiw__sbn(a)++] = (v))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 822, + "column": 1, + "source_line": "#define stbiw__sbpush(a, v) (stbiw__sbmaybegrow(a,1), (a)[stbiw__sbn(a)++] = (v))" + } + }, + "stbiw__sbcount": { + "name": "stbiw__sbcount", + "value": "((a) ? stbiw__sbn(a) : 0)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 823, + "column": 1, + "source_line": "#define stbiw__sbcount(a) ((a) ? stbiw__sbn(a) : 0)" + } + }, + "stbiw__sbfree": { + "name": "stbiw__sbfree", + "value": "((a) ? STBIW_FREE(stbiw__sbraw(a)),0 : 0)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 824, + "column": 1, + "source_line": "#define stbiw__sbfree(a) ((a) ? STBIW_FREE(stbiw__sbraw(a)),0 : 0)" + } + }, + "stbiw__zlib_flush": { + "name": "stbiw__zlib_flush", + "value": "(out = stbiw__zlib_flushf(out, &bitbuf, &bitcount))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 879, + "column": 1, + "source_line": "#define stbiw__zlib_flush() (out = stbiw__zlib_flushf(out, &bitbuf, &bitcount))" + } + }, + "stbiw__zlib_add": { + "name": "stbiw__zlib_add", + "value": "(bitbuf |= (code) << bitcount, bitcount += (codebits), stbiw__zlib_flush())", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 880, + "column": 1, + "source_line": "#define stbiw__zlib_add(code,codebits) \\" + } + }, + "stbiw__zlib_huffa": { + "name": "stbiw__zlib_huffa", + "value": "stbiw__zlib_add(stbiw__zlib_bitrev(b,c),c)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 882, + "column": 1, + "source_line": "#define stbiw__zlib_huffa(b,c) stbiw__zlib_add(stbiw__zlib_bitrev(b,c),c)" + } + }, + "stbiw__zlib_huff1": { + "name": "stbiw__zlib_huff1", + "value": "stbiw__zlib_huffa(0x30 + (n), 8)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 884, + "column": 1, + "source_line": "#define stbiw__zlib_huff1(n) stbiw__zlib_huffa(0x30 + (n), 8)" + } + }, + "stbiw__zlib_huff2": { + "name": "stbiw__zlib_huff2", + "value": "stbiw__zlib_huffa(0x190 + (n)-144, 9)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 885, + "column": 1, + "source_line": "#define stbiw__zlib_huff2(n) stbiw__zlib_huffa(0x190 + (n)-144, 9)" + } + }, + "stbiw__zlib_huff3": { + "name": "stbiw__zlib_huff3", + "value": "stbiw__zlib_huffa(0 + (n)-256,7)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 886, + "column": 1, + "source_line": "#define stbiw__zlib_huff3(n) stbiw__zlib_huffa(0 + (n)-256,7)" + } + }, + "stbiw__zlib_huff4": { + "name": "stbiw__zlib_huff4", + "value": "stbiw__zlib_huffa(0xc0 + (n)-280,8)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 887, + "column": 1, + "source_line": "#define stbiw__zlib_huff4(n) stbiw__zlib_huffa(0xc0 + (n)-280,8)" + } + }, + "stbiw__zlib_huff": { + "name": "stbiw__zlib_huff", + "value": "((n) <= 143 ? stbiw__zlib_huff1(n) : (n) <= 255 ? stbiw__zlib_huff2(n) : (n) <= 279 ? stbiw__zlib_huff3(n) : stbiw__zlib_huff4(n))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 888, + "column": 1, + "source_line": "#define stbiw__zlib_huff(n) ((n) <= 143 ? stbiw__zlib_huff1(n) : (n) <= 255 ? stbiw__zlib_huff2(n) : (n) <= 279 ? stbiw__zlib_huff3(n) : stbiw__zlib_huff4(n))" + } + }, + "stbiw__zlib_huffb": { + "name": "stbiw__zlib_huffb", + "value": "((n) <= 143 ? stbiw__zlib_huff1(n) : stbiw__zlib_huff2(n))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 889, + "column": 1, + "source_line": "#define stbiw__zlib_huffb(n) ((n) <= 143 ? stbiw__zlib_huff1(n) : stbiw__zlib_huff2(n))" + } + }, + "stbiw__ZHASH": { + "name": "stbiw__ZHASH", + "value": "16384", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 891, + "column": 1, + "source_line": "#define stbiw__ZHASH 16384" + } + }, + "stbiw__wpng4": { + "name": "stbiw__wpng4", + "value": "((o)[0]=STBIW_UCHAR(a),(o)[1]=STBIW_UCHAR(b),(o)[2]=STBIW_UCHAR(c),(o)[3]=STBIW_UCHAR(d),(o)+=4)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 1073, + "column": 1, + "source_line": "#define stbiw__wpng4(o,a,b,c,d) ((o)[0]=STBIW_UCHAR(a),(o)[1]=STBIW_UCHAR(b),(o)[2]=STBIW_UCHAR(c),(o)[3]=STBIW_UCHAR(d),(o)+=4)" + } + }, + "stbiw__wp32": { + "name": "stbiw__wp32", + "value": "stbiw__wpng4(data, (v)>>24,(v)>>16,(v)>>8,(v));", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 1074, + "column": 1, + "source_line": "#define stbiw__wp32(data,v) stbiw__wpng4(data, (v)>>24,(v)>>16,(v)>>8,(v));" + } + }, + "stbiw__wptag": { + "name": "stbiw__wptag", + "value": "stbiw__wpng4(data, s[0],s[1],s[2],s[3])", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 1075, + "column": 1, + "source_line": "#define stbiw__wptag(data,s) stbiw__wpng4(data, s[0],s[1],s[2],s[3])" + } + } + }, + "includes": { + "stb/stb_image_write.h:stdlib.h": { + "target": "stdlib.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 215, + "column": 1, + "source_line": "#include " + } + }, + "stb/stb_image_write.h:stdio.h": { + "target": "stdio.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 211, + "column": 1, + "source_line": "#include " + } + }, + "stb/stb_image_write.h:stdarg.h": { + "target": "stdarg.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 214, + "column": 1, + "source_line": "#include " + } + }, + "stb/stb_image_write.h:string.h": { + "target": "string.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 216, + "column": 1, + "source_line": "#include " + } + }, + "stb/stb_image_write.h:math.h": { + "target": "math.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 217, + "column": 1, + "source_line": "#include " + } + }, + "stb/stb_image_write.h:assert.h": { + "target": "assert.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_image_write.h", + "line": 244, + "column": 1, + "source_line": "#include " + } + } + }, + "functions_by_file": { + "stb/stb_image_write.h": [ + "stbi__start_write_callbacks", + "stbi__stdio_write", + "stbiw__fopen", + "stbi__start_write_file", + "stbi__end_write_file", + "stbiw__writefv", + "stbiw__writef", + "stbiw__write_flush", + "stbiw__putc", + "stbiw__write1", + "stbiw__write3", + "stbiw__write_pixel", + "stbiw__write_pixels", + "stbiw__outfile", + "stbi_write_bmp_core", + "stbi_write_tga_core", + "stbiw__linear_to_rgbe", + "stbiw__write_run_data", + "stbiw__write_dump_data", + "stbiw__write_hdr_scanline", + "stbi_write_hdr_core", + "stbiw__sbgrowf", + "stbiw__zlib_flushf", + "stbiw__zlib_bitrev", + "stbiw__zlib_countm", + "stbiw__zhash", + "stbiw__crc32", + "stbiw__wpcrc", + "stbiw__paeth", + "stbiw__encode_png_line", + "stbiw__jpg_writeBits", + "stbiw__jpg_DCT", + "stbiw__jpg_calcBits", + "stbiw__jpg_processDU", + "stbi_write_jpg_core" + ] + }, + "enum_constants": {}, + "include_graph": { + "stb/stb_image_write.h": [] + }, + "system_includes": { + "stb/stb_image_write.h": [ + "assert.h", + "math.h", + "stdarg.h", + "stdio.h", + "stdlib.h", + "string.h" + ] + }, + "unresolved_includes": { + "stb/stb_image_write.h": [] + }, + "header_source_pairs": { + "stb/stb_image_write.h": [] + }, + "diagnostics": [ + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIW_MALLOC' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 228, + "column": 1, + "source_line": "#define STBIW_MALLOC(sz) malloc(sz)" + }, + "unit_kind": "macro", + "unit_name": "STBIW_MALLOC" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIW_REALLOC' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 229, + "column": 1, + "source_line": "#define STBIW_REALLOC(p,newsz) realloc(p,newsz)" + }, + "unit_kind": "macro", + "unit_name": "STBIW_REALLOC" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIW_FREE' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 230, + "column": 1, + "source_line": "#define STBIW_FREE(p) free(p)" + }, + "unit_kind": "macro", + "unit_name": "STBIW_FREE" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIW_REALLOC_SIZED' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 234, + "column": 1, + "source_line": "#define STBIW_REALLOC_SIZED(p,oldsz,newsz) STBIW_REALLOC(p,newsz)" + }, + "unit_kind": "macro", + "unit_name": "STBIW_REALLOC_SIZED" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIW_MEMMOVE' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 239, + "column": 1, + "source_line": "#define STBIW_MEMMOVE(a,b,sz) memmove(a,b,sz)" + }, + "unit_kind": "macro", + "unit_name": "STBIW_MEMMOVE" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIW_ASSERT' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 245, + "column": 1, + "source_line": "#define STBIW_ASSERT(x) assert(x)" + }, + "unit_kind": "macro", + "unit_name": "STBIW_ASSERT" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBIW_UCHAR' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 248, + "column": 1, + "source_line": "#define STBIW_UCHAR(x) (unsigned char) ((x) & 0xff)" + }, + "unit_kind": "macro", + "unit_name": "STBIW_UCHAR" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbiw__max' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 635, + "column": 1, + "source_line": "#define stbiw__max(a, b) ((a) > (b) ? (a) : (b))" + }, + "unit_kind": "macro", + "unit_name": "stbiw__max" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbiw__sbraw' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 814, + "column": 1, + "source_line": "#define stbiw__sbraw(a) ((int *) (void *) (a) - 2)" + }, + "unit_kind": "macro", + "unit_name": "stbiw__sbraw" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbiw__sbm' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 815, + "column": 1, + "source_line": "#define stbiw__sbm(a) stbiw__sbraw(a)[0]" + }, + "unit_kind": "macro", + "unit_name": "stbiw__sbm" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbiw__sbn' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 816, + "column": 1, + "source_line": "#define stbiw__sbn(a) stbiw__sbraw(a)[1]" + }, + "unit_kind": "macro", + "unit_name": "stbiw__sbn" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbiw__sbneedgrow' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 818, + "column": 1, + "source_line": "#define stbiw__sbneedgrow(a,n) ((a)==0 || stbiw__sbn(a)+n >= stbiw__sbm(a))" + }, + "unit_kind": "macro", + "unit_name": "stbiw__sbneedgrow" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbiw__sbmaybegrow' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 819, + "column": 1, + "source_line": "#define stbiw__sbmaybegrow(a,n) (stbiw__sbneedgrow(a,(n)) ? stbiw__sbgrow(a,n) : 0)" + }, + "unit_kind": "macro", + "unit_name": "stbiw__sbmaybegrow" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbiw__sbgrow' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 820, + "column": 1, + "source_line": "#define stbiw__sbgrow(a,n) stbiw__sbgrowf((void **) &(a), (n), sizeof(*(a)))" + }, + "unit_kind": "macro", + "unit_name": "stbiw__sbgrow" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbiw__sbpush' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 822, + "column": 1, + "source_line": "#define stbiw__sbpush(a, v) (stbiw__sbmaybegrow(a,1), (a)[stbiw__sbn(a)++] = (v))" + }, + "unit_kind": "macro", + "unit_name": "stbiw__sbpush" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbiw__sbcount' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 823, + "column": 1, + "source_line": "#define stbiw__sbcount(a) ((a) ? stbiw__sbn(a) : 0)" + }, + "unit_kind": "macro", + "unit_name": "stbiw__sbcount" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbiw__sbfree' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 824, + "column": 1, + "source_line": "#define stbiw__sbfree(a) ((a) ? STBIW_FREE(stbiw__sbraw(a)),0 : 0)" + }, + "unit_kind": "macro", + "unit_name": "stbiw__sbfree" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbiw__zlib_flush' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 879, + "column": 1, + "source_line": "#define stbiw__zlib_flush() (out = stbiw__zlib_flushf(out, &bitbuf, &bitcount))" + }, + "unit_kind": "macro", + "unit_name": "stbiw__zlib_flush" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbiw__zlib_add' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 880, + "column": 1, + "source_line": "#define stbiw__zlib_add(code,codebits) \\" + }, + "unit_kind": "macro", + "unit_name": "stbiw__zlib_add" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbiw__zlib_huffa' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 882, + "column": 1, + "source_line": "#define stbiw__zlib_huffa(b,c) stbiw__zlib_add(stbiw__zlib_bitrev(b,c),c)" + }, + "unit_kind": "macro", + "unit_name": "stbiw__zlib_huffa" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbiw__zlib_huff1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 884, + "column": 1, + "source_line": "#define stbiw__zlib_huff1(n) stbiw__zlib_huffa(0x30 + (n), 8)" + }, + "unit_kind": "macro", + "unit_name": "stbiw__zlib_huff1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbiw__zlib_huff2' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 885, + "column": 1, + "source_line": "#define stbiw__zlib_huff2(n) stbiw__zlib_huffa(0x190 + (n)-144, 9)" + }, + "unit_kind": "macro", + "unit_name": "stbiw__zlib_huff2" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbiw__zlib_huff3' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 886, + "column": 1, + "source_line": "#define stbiw__zlib_huff3(n) stbiw__zlib_huffa(0 + (n)-256,7)" + }, + "unit_kind": "macro", + "unit_name": "stbiw__zlib_huff3" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbiw__zlib_huff4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 887, + "column": 1, + "source_line": "#define stbiw__zlib_huff4(n) stbiw__zlib_huffa(0xc0 + (n)-280,8)" + }, + "unit_kind": "macro", + "unit_name": "stbiw__zlib_huff4" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbiw__zlib_huff' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 888, + "column": 1, + "source_line": "#define stbiw__zlib_huff(n) ((n) <= 143 ? stbiw__zlib_huff1(n) : (n) <= 255 ? stbiw__zlib_huff2(n) : (n) <= 279 ? stbiw__zlib_huff3(n) : stbiw__zlib_huff4(n))" + }, + "unit_kind": "macro", + "unit_name": "stbiw__zlib_huff" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbiw__zlib_huffb' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 889, + "column": 1, + "source_line": "#define stbiw__zlib_huffb(n) ((n) <= 143 ? stbiw__zlib_huff1(n) : stbiw__zlib_huff2(n))" + }, + "unit_kind": "macro", + "unit_name": "stbiw__zlib_huffb" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbiw__wpng4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 1073, + "column": 1, + "source_line": "#define stbiw__wpng4(o,a,b,c,d) ((o)[0]=STBIW_UCHAR(a),(o)[1]=STBIW_UCHAR(b),(o)[2]=STBIW_UCHAR(c),(o)[3]=STBIW_UCHAR(d),(o)+=4)" + }, + "unit_kind": "macro", + "unit_name": "stbiw__wpng4" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbiw__wp32' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 1074, + "column": 1, + "source_line": "#define stbiw__wp32(data,v) stbiw__wpng4(data, (v)>>24,(v)>>16,(v)>>8,(v));" + }, + "unit_kind": "macro", + "unit_name": "stbiw__wp32" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbiw__wptag' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 1075, + "column": 1, + "source_line": "#define stbiw__wptag(data,s) stbiw__wpng4(data, s[0],s[1],s[2],s[3])" + }, + "unit_kind": "macro", + "unit_name": "stbiw__wptag" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIWDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 170, + "column": 1, + "source_line": "STBIWDEF int stbi_write_tga_with_rle;" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIWDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIWDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 171, + "column": 1, + "source_line": "STBIWDEF int stbi_write_png_compression_level;" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIWDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIWDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 172, + "column": 1, + "source_line": "STBIWDEF int stbi_write_force_png_filter;" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIWDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIWDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 176, + "column": 1, + "source_line": "STBIWDEF int stbi_write_png(char const *filename, int w, int h, int comp, const void *data, int stride_in_bytes);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIWDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIWDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 177, + "column": 1, + "source_line": "STBIWDEF int stbi_write_bmp(char const *filename, int w, int h, int comp, const void *data);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIWDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIWDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 178, + "column": 1, + "source_line": "STBIWDEF int stbi_write_tga(char const *filename, int w, int h, int comp, const void *data);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIWDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIWDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 179, + "column": 1, + "source_line": "STBIWDEF int stbi_write_hdr(char const *filename, int w, int h, int comp, const float *data);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIWDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIWDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 180, + "column": 1, + "source_line": "STBIWDEF int stbi_write_jpg(char const *filename, int x, int y, int comp, const void *data, int quality);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIWDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIWDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 183, + "column": 1, + "source_line": "STBIWDEF int stbiw_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIWDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIWDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 189, + "column": 1, + "source_line": "STBIWDEF int stbi_write_png_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data, int stride_in_bytes);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIWDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIWDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 190, + "column": 1, + "source_line": "STBIWDEF int stbi_write_bmp_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIWDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIWDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 191, + "column": 1, + "source_line": "STBIWDEF int stbi_write_tga_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIWDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIWDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 192, + "column": 1, + "source_line": "STBIWDEF int stbi_write_hdr_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const float *data);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIWDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIWDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 193, + "column": 1, + "source_line": "STBIWDEF int stbi_write_jpg_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int quality);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIWDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIWDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 195, + "column": 1, + "source_line": "STBIWDEF void stbi_flip_vertically_on_write(int flip_boolean);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIWDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIWDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 262, + "column": 1, + "source_line": "STBIWDEF void stbi_flip_vertically_on_write(int flag)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIWDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIW_EXTERN'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 295, + "column": 1, + "source_line": "STBIW_EXTERN __declspec(dllimport) int __stdcall MultiByteToWideChar(unsigned int cp, unsigned long flags, const char *str, int cbmb, wchar_t *widestr, int cchwide);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIW_EXTERN" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIW_EXTERN'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 296, + "column": 1, + "source_line": "STBIW_EXTERN __declspec(dllimport) int __stdcall WideCharToMultiByte(unsigned int cp, unsigned long flags, const wchar_t *widestr, int cchwide, char *str, int cbmb, const char *defchar, int *used_default);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIW_EXTERN" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIWDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 298, + "column": 1, + "source_line": "STBIWDEF int stbiw_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIWDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIWDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 512, + "column": 1, + "source_line": "STBIWDEF int stbi_write_bmp_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIWDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIWDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 520, + "column": 1, + "source_line": "STBIWDEF int stbi_write_bmp(char const *filename, int x, int y, int comp, const void *data)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIWDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIWDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 611, + "column": 1, + "source_line": "STBIWDEF int stbi_write_tga_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIWDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIWDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 619, + "column": 1, + "source_line": "STBIWDEF int stbi_write_tga(char const *filename, int x, int y, int comp, const void *data)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIWDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIWDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 787, + "column": 1, + "source_line": "STBIWDEF int stbi_write_hdr_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const float *data)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIWDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIWDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 794, + "column": 1, + "source_line": "STBIWDEF int stbi_write_hdr(char const *filename, int x, int y, int comp, const float *data)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIWDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIWDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 895, + "column": 1, + "source_line": "STBIWDEF unsigned char * stbi_zlib_compress(unsigned char *data, int data_len, int *out_len, int quality)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIWDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIWDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 1128, + "column": 1, + "source_line": "STBIWDEF unsigned char *stbi_write_png_to_mem(const unsigned char *pixels, int stride_bytes, int x, int y, int n, int *out_len)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIWDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIWDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 1215, + "column": 1, + "source_line": "STBIWDEF int stbi_write_png(char const *filename, int x, int y, int comp, const void *data, int stride_bytes)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIWDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIWDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 1231, + "column": 1, + "source_line": "STBIWDEF int stbi_write_png_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int stride_bytes)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIWDEF" + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 1250, + "column": 1, + "source_line": "static const unsigned char stbiw__jpg_ZigZag[] = { 0,1,5,6,14,15,27,28,2,4,7,13,16,26,29,42,3,8,12,17,25,30,41,43,9,11,18," + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIWDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 1607, + "column": 1, + "source_line": "STBIWDEF int stbi_write_jpg_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int quality)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIWDEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBIWDEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_image_write.h", + "line": 1616, + "column": 1, + "source_line": "STBIWDEF int stbi_write_jpg(char const *filename, int x, int y, int comp, const void *data, int quality)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBIWDEF" + }, + { + "code": "C_DUPLICATE_VARIABLE_DEFINITION", + "message": "Duplicate definition for variable 'stbi_write_png_compression_level'.", + "severity": "error", + "location": { + "filename": "stb/stb_image_write.h", + "line": 255, + "column": 1, + "source_line": "int stbi_write_png_compression_level = 8;" + }, + "unit_kind": "variable", + "unit_name": "stbi_write_png_compression_level" + }, + { + "code": "C_DUPLICATE_VARIABLE_DEFINITION", + "message": "Duplicate definition for variable 'stbi_write_tga_with_rle'.", + "severity": "error", + "location": { + "filename": "stb/stb_image_write.h", + "line": 256, + "column": 1, + "source_line": "int stbi_write_tga_with_rle = 1;" + }, + "unit_kind": "variable", + "unit_name": "stbi_write_tga_with_rle" + }, + { + "code": "C_DUPLICATE_VARIABLE_DEFINITION", + "message": "Duplicate definition for variable 'stbi_write_force_png_filter'.", + "severity": "error", + "location": { + "filename": "stb/stb_image_write.h", + "line": 257, + "column": 1, + "source_line": "int stbi_write_force_png_filter = -1;" + }, + "unit_kind": "variable", + "unit_name": "stbi_write_force_png_filter" + } + ] +} diff --git a/tests/parser/c/fixtures/stb/stb_include.json b/tests/parser/c/fixtures/stb/stb_include.json new file mode 100644 index 000000000..2c1498762 --- /dev/null +++ b/tests/parser/c/fixtures/stb/stb_include.json @@ -0,0 +1,4093 @@ +{ + "files": { + "stb/stb_include.h": { + "filename": "stb/stb_include.h", + "language": "c", + "parser_status": "partial", + "preprocessing": "raw", + "functions": [ + { + "name": "stb_include_string", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "inject", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *inject", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *inject", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "path_to_includes", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *path_to_includes", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *path_to_includes", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "filename", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *filename", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *filename", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "error", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char error[256]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char error[256]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "256", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_include.h", + "line": 184, + "column": 1, + "source_line": "char *stb_include_string(char *str, char *inject, char *path_to_includes, char *filename, char error[256])" + }, + "start": { + "filename": "stb/stb_include.h", + "line": 184, + "column": 1, + "source_line": "char *stb_include_string(char *str, char *inject, char *path_to_includes, char *filename, char error[256])" + }, + "end": { + "filename": "stb/stb_include.h", + "line": 251, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_include.h", + "line": 41, + "column": 1, + "source_line": "char *stb_include_string(char *str, char *inject, char *path_to_includes, char *filename_for_line_directive, char error[256]);" + } + ] + }, + { + "name": "stb_include_strings", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "parameters": [ + { + "name": "strs", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char **strs", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char **strs", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "count", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int count" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int count" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "inject", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *inject", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *inject", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "path_to_includes", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *path_to_includes", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *path_to_includes", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "filename", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *filename", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *filename", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "error", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char error[256]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char error[256]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "256", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_include.h", + "line": 253, + "column": 1, + "source_line": "char *stb_include_strings(char **strs, int count, char *inject, char *path_to_includes, char *filename, char error[256])" + }, + "start": { + "filename": "stb/stb_include.h", + "line": 253, + "column": 1, + "source_line": "char *stb_include_strings(char **strs, int count, char *inject, char *path_to_includes, char *filename, char error[256])" + }, + "end": { + "filename": "stb/stb_include.h", + "line": 270, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_include.h", + "line": 44, + "column": 1, + "source_line": "char *stb_include_strings(char **strs, int count, char *inject, char *path_to_includes, char *filename_for_line_directive, char error[256]);" + } + ] + }, + { + "name": "stb_include_file", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "parameters": [ + { + "name": "filename", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *filename", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *filename", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "inject", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *inject", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *inject", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "path_to_includes", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *path_to_includes", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *path_to_includes", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "error", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char error[256]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char error[256]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "256", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_include.h", + "line": 272, + "column": 1, + "source_line": "char *stb_include_file(char *filename, char *inject, char *path_to_includes, char error[256])" + }, + "start": { + "filename": "stb/stb_include.h", + "line": 272, + "column": 1, + "source_line": "char *stb_include_file(char *filename, char *inject, char *path_to_includes, char error[256])" + }, + "end": { + "filename": "stb/stb_include.h", + "line": 286, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_include.h", + "line": 48, + "column": 1, + "source_line": "char *stb_include_file(char *filename, char *inject, char *path_to_includes, char error[256]);" + } + ] + }, + { + "name": "stb_include_load_file", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "parameters": [ + { + "name": "filename", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *filename", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *filename", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "plen", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "size_t *plen", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "size_t *plen", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "size_t" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_include.h", + "line": 59, + "column": 1, + "source_line": "static char *stb_include_load_file(char *filename, size_t *plen)" + }, + "start": { + "filename": "stb/stb_include.h", + "line": 59, + "column": 1, + "source_line": "static char *stb_include_load_file(char *filename, size_t *plen)" + }, + "end": { + "filename": "stb/stb_include.h", + "line": 75, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_include_append_include", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "include_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "include_info", + "name": "include_info", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "offset", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int offset" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_include.h", + "line": 79, + "column": 4, + "source_line": " int offset;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "end", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int end" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_include.h", + "line": 80, + "column": 4, + "source_line": " int end;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "filename", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *filename", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_include.h", + "line": 81, + "column": 4, + "source_line": " char *filename;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "next_line_after", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int next_line_after" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_include.h", + "line": 82, + "column": 4, + "source_line": " int next_line_after;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_include.h:77:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_include.h", + "line": 77, + "column": 1, + "source_line": "typedef struct" + } + }, + "source_location": { + "filename": "stb/stb_include.h", + "line": 77, + "column": 1, + "source_line": "typedef struct" + }, + "declaration_locations": [] + } + ] + }, + "parameters": [ + { + "name": "array", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "include_info *array", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "include_info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "include_info *array", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "include_info" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "offset", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int offset" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int offset" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "end", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int end" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int end" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "filename", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *filename", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *filename", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "next_line", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int next_line" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int next_line" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_include.h", + "line": 85, + "column": 1, + "source_line": "static include_info *stb_include_append_include(include_info *array, int len, int offset, int end, char *filename, int next_line)" + }, + "start": { + "filename": "stb/stb_include.h", + "line": 85, + "column": 1, + "source_line": "static include_info *stb_include_append_include(include_info *array, int len, int offset, int end, char *filename, int next_line)" + }, + "end": { + "filename": "stb/stb_include.h", + "line": 93, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_include_free_includes", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "array", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "include_info *array", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "include_info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "include_info *array", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "include_info" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_include.h", + "line": 95, + "column": 1, + "source_line": "static void stb_include_free_includes(include_info *array, int len)" + }, + "start": { + "filename": "stb/stb_include.h", + "line": 95, + "column": 1, + "source_line": "static void stb_include_free_includes(include_info *array, int len)" + }, + "end": { + "filename": "stb/stb_include.h", + "line": 101, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_include_isspace", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "ch", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ch" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ch" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_include.h", + "line": 103, + "column": 1, + "source_line": "static int stb_include_isspace(int ch)" + }, + "start": { + "filename": "stb/stb_include.h", + "line": 103, + "column": 1, + "source_line": "static int stb_include_isspace(int ch)" + }, + "end": { + "filename": "stb/stb_include.h", + "line": 106, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_include_find_includes", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "text", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *text", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *text", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "plist", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "include_info **plist", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "include_info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "include_info **plist", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "include_info" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_include.h", + "line": 109, + "column": 1, + "source_line": "static int stb_include_find_includes(char *text, include_info **plist)" + }, + "start": { + "filename": "stb/stb_include.h", + "line": 109, + "column": 1, + "source_line": "static int stb_include_find_includes(char *text, include_info **plist)" + }, + "end": { + "filename": "stb/stb_include.h", + "line": 158, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_include_itoa", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char str[9]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char str[9]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "9", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_include.h", + "line": 161, + "column": 1, + "source_line": "static void stb_include_itoa(char str[9], int n)" + }, + "start": { + "filename": "stb/stb_include.h", + "line": 161, + "column": 1, + "source_line": "static void stb_include_itoa(char str[9], int n)" + }, + "end": { + "filename": "stb/stb_include.h", + "line": 174, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_include_append", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "curlen", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "size_t *curlen", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "size_t *curlen", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "size_t" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "addstr", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *addstr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *addstr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "addlen", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t addlen", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_include.h", + "line": 176, + "column": 1, + "source_line": "static char *stb_include_append(char *str, size_t *curlen, char *addstr, size_t addlen)" + }, + "start": { + "filename": "stb/stb_include.h", + "line": 176, + "column": 1, + "source_line": "static char *stb_include_append(char *str, size_t *curlen, char *addstr, size_t addlen)" + }, + "end": { + "filename": "stb/stb_include.h", + "line": 182, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_include_preloaded", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "inject", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *inject", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *inject", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "includes", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *includes[][2]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "2", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *includes[][2]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": null, + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "2", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "error", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char error[256]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char error[256]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "256", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_include.h", + "line": 289, + "column": 1, + "source_line": "char *stb_include_preloaded(char *str, char *inject, char *includes[][2], char error[256])" + }, + "start": { + "filename": "stb/stb_include.h", + "line": 289, + "column": 1, + "source_line": "char *stb_include_preloaded(char *str, char *inject, char *includes[][2], char error[256])" + }, + "end": { + "filename": "stb/stb_include.h", + "line": 292, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + } + ], + "structs": [ + { + "reference": "struct@stb/stb_include.h:77:1" + } + ], + "unions": [], + "enums": [], + "typedefs": [ + { + "reference": "include_info" + } + ], + "variables": [], + "macros": [ + { + "name": "STB_INCLUDE_STB_INCLUDE_H", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_include.h", + "line": 38, + "column": 1, + "source_line": "#define STB_INCLUDE_STB_INCLUDE_H" + } + } + ], + "includes": [ + { + "target": "stdio.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_include.h", + "line": 55, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "stdlib.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_include.h", + "line": 56, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "string.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_include.h", + "line": 57, + "column": 1, + "source_line": "#include " + } + } + ], + "raw_directives": [ + { + "directive": "ifndef", + "argument": "STB_INCLUDE_STB_INCLUDE_H", + "source_location": { + "filename": "stb/stb_include.h", + "line": 37, + "column": 1, + "source_line": "#ifndef STB_INCLUDE_STB_INCLUDE_H" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_include.h", + "line": 50, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STB_INCLUDE_IMPLEMENTATION", + "source_location": { + "filename": "stb/stb_include.h", + "line": 53, + "column": 1, + "source_line": "#ifdef STB_INCLUDE_IMPLEMENTATION" + } + }, + { + "directive": "ifndef", + "argument": "STB_INCLUDE_LINE_NONE", + "source_location": { + "filename": "stb/stb_include.h", + "line": 195, + "column": 7, + "source_line": " #ifndef STB_INCLUDE_LINE_NONE" + } + }, + { + "directive": "ifdef", + "argument": "STB_INCLUDE_LINE_GLSL", + "source_location": { + "filename": "stb/stb_include.h", + "line": 196, + "column": 7, + "source_line": " #ifdef STB_INCLUDE_LINE_GLSL" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_include.h", + "line": 198, + "column": 7, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "STB_INCLUDE_LINE_GLSL", + "source_location": { + "filename": "stb/stb_include.h", + "line": 203, + "column": 10, + "source_line": " #ifdef STB_INCLUDE_LINE_GLSL" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_include.h", + "line": 205, + "column": 10, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_include.h", + "line": 212, + "column": 10, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_include.h", + "line": 216, + "column": 7, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_INCLUDE_LINE_NONE", + "source_location": { + "filename": "stb/stb_include.h", + "line": 234, + "column": 7, + "source_line": " #ifndef STB_INCLUDE_LINE_NONE" + } + }, + { + "directive": "ifdef", + "argument": "STB_INCLUDE_LINE_GLSL", + "source_location": { + "filename": "stb/stb_include.h", + "line": 238, + "column": 7, + "source_line": " #ifdef STB_INCLUDE_LINE_GLSL" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_include.h", + "line": 240, + "column": 7, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_include.h", + "line": 242, + "column": 7, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_include.h", + "line": 245, + "column": 7, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "0", + "source_location": { + "filename": "stb/stb_include.h", + "line": 288, + "column": 1, + "source_line": "#if 0 // @TODO, GL_ARB_shader_language_include-style system that doesn't touch filesystem" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_include.h", + "line": 293, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_include.h", + "line": 295, + "column": 1, + "source_line": "#endif // STB_INCLUDE_IMPLEMENTATION" + } + } + ], + "macro_dependencies": [], + "diagnostics": [] + } + }, + "functions": { + "stb_include_string": { + "name": "stb_include_string", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "inject", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *inject", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *inject", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "path_to_includes", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *path_to_includes", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *path_to_includes", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "filename", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *filename", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *filename", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "error", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char error[256]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char error[256]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "256", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_include.h", + "line": 184, + "column": 1, + "source_line": "char *stb_include_string(char *str, char *inject, char *path_to_includes, char *filename, char error[256])" + }, + "start": { + "filename": "stb/stb_include.h", + "line": 184, + "column": 1, + "source_line": "char *stb_include_string(char *str, char *inject, char *path_to_includes, char *filename, char error[256])" + }, + "end": { + "filename": "stb/stb_include.h", + "line": 251, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_include.h", + "line": 41, + "column": 1, + "source_line": "char *stb_include_string(char *str, char *inject, char *path_to_includes, char *filename_for_line_directive, char error[256]);" + } + ] + }, + "stb_include_strings": { + "name": "stb_include_strings", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "parameters": [ + { + "name": "strs", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char **strs", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char **strs", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "count", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int count" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int count" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "inject", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *inject", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *inject", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "path_to_includes", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *path_to_includes", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *path_to_includes", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "filename", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *filename", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *filename", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "error", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char error[256]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char error[256]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "256", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_include.h", + "line": 253, + "column": 1, + "source_line": "char *stb_include_strings(char **strs, int count, char *inject, char *path_to_includes, char *filename, char error[256])" + }, + "start": { + "filename": "stb/stb_include.h", + "line": 253, + "column": 1, + "source_line": "char *stb_include_strings(char **strs, int count, char *inject, char *path_to_includes, char *filename, char error[256])" + }, + "end": { + "filename": "stb/stb_include.h", + "line": 270, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_include.h", + "line": 44, + "column": 1, + "source_line": "char *stb_include_strings(char **strs, int count, char *inject, char *path_to_includes, char *filename_for_line_directive, char error[256]);" + } + ] + }, + "stb_include_file": { + "name": "stb_include_file", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "parameters": [ + { + "name": "filename", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *filename", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *filename", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "inject", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *inject", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *inject", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "path_to_includes", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *path_to_includes", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *path_to_includes", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "error", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char error[256]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char error[256]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "256", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_include.h", + "line": 272, + "column": 1, + "source_line": "char *stb_include_file(char *filename, char *inject, char *path_to_includes, char error[256])" + }, + "start": { + "filename": "stb/stb_include.h", + "line": 272, + "column": 1, + "source_line": "char *stb_include_file(char *filename, char *inject, char *path_to_includes, char error[256])" + }, + "end": { + "filename": "stb/stb_include.h", + "line": 286, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_include.h", + "line": 48, + "column": 1, + "source_line": "char *stb_include_file(char *filename, char *inject, char *path_to_includes, char error[256]);" + } + ] + }, + "stb_include_load_file": { + "name": "stb_include_load_file", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "parameters": [ + { + "name": "filename", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *filename", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *filename", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "plen", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "size_t *plen", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "size_t" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "size_t *plen", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "size_t" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_include.h", + "line": 59, + "column": 1, + "source_line": "static char *stb_include_load_file(char *filename, size_t *plen)" + }, + "start": { + "filename": "stb/stb_include.h", + "line": 59, + "column": 1, + "source_line": "static char *stb_include_load_file(char *filename, size_t *plen)" + }, + "end": { + "filename": "stb/stb_include.h", + "line": 75, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_include_append_include": { + "name": "stb_include_append_include", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "include_info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "include_info" + } + ] + }, + "parameters": [ + { + "name": "array", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "include_info *array", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "include_info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "include_info *array", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "include_info" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "offset", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int offset" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int offset" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "end", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int end" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int end" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "filename", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *filename", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *filename", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "next_line", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int next_line" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int next_line" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_include.h", + "line": 85, + "column": 1, + "source_line": "static include_info *stb_include_append_include(include_info *array, int len, int offset, int end, char *filename, int next_line)" + }, + "start": { + "filename": "stb/stb_include.h", + "line": 85, + "column": 1, + "source_line": "static include_info *stb_include_append_include(include_info *array, int len, int offset, int end, char *filename, int next_line)" + }, + "end": { + "filename": "stb/stb_include.h", + "line": 93, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_include_free_includes": { + "name": "stb_include_free_includes", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "array", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "include_info *array", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "include_info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "include_info *array", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "include_info" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_include.h", + "line": 95, + "column": 1, + "source_line": "static void stb_include_free_includes(include_info *array, int len)" + }, + "start": { + "filename": "stb/stb_include.h", + "line": 95, + "column": 1, + "source_line": "static void stb_include_free_includes(include_info *array, int len)" + }, + "end": { + "filename": "stb/stb_include.h", + "line": 101, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_include_isspace": { + "name": "stb_include_isspace", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "ch", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ch" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ch" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_include.h", + "line": 103, + "column": 1, + "source_line": "static int stb_include_isspace(int ch)" + }, + "start": { + "filename": "stb/stb_include.h", + "line": 103, + "column": 1, + "source_line": "static int stb_include_isspace(int ch)" + }, + "end": { + "filename": "stb/stb_include.h", + "line": 106, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_include_find_includes": { + "name": "stb_include_find_includes", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "text", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *text", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *text", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "plist", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "include_info **plist", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "include_info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "include_info **plist", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "include_info" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_include.h", + "line": 109, + "column": 1, + "source_line": "static int stb_include_find_includes(char *text, include_info **plist)" + }, + "start": { + "filename": "stb/stb_include.h", + "line": 109, + "column": 1, + "source_line": "static int stb_include_find_includes(char *text, include_info **plist)" + }, + "end": { + "filename": "stb/stb_include.h", + "line": 158, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_include_itoa": { + "name": "stb_include_itoa", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char str[9]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char str[9]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "9", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_include.h", + "line": 161, + "column": 1, + "source_line": "static void stb_include_itoa(char str[9], int n)" + }, + "start": { + "filename": "stb/stb_include.h", + "line": 161, + "column": 1, + "source_line": "static void stb_include_itoa(char str[9], int n)" + }, + "end": { + "filename": "stb/stb_include.h", + "line": 174, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_include_append": { + "name": "stb_include_append", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "curlen", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "size_t *curlen", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "size_t" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "size_t *curlen", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "size_t" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "addstr", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *addstr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *addstr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "addlen", + "type": { + "reference": "size_t" + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_include.h", + "line": 176, + "column": 1, + "source_line": "static char *stb_include_append(char *str, size_t *curlen, char *addstr, size_t addlen)" + }, + "start": { + "filename": "stb/stb_include.h", + "line": 176, + "column": 1, + "source_line": "static char *stb_include_append(char *str, size_t *curlen, char *addstr, size_t addlen)" + }, + "end": { + "filename": "stb/stb_include.h", + "line": 182, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_include_preloaded": { + "name": "stb_include_preloaded", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "inject", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *inject", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *inject", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "includes", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *includes[][2]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "2", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *includes[][2]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": null, + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "2", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "error", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char error[256]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char error[256]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "256", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_include.h", + "line": 289, + "column": 1, + "source_line": "char *stb_include_preloaded(char *str, char *inject, char *includes[][2], char error[256])" + }, + "start": { + "filename": "stb/stb_include.h", + "line": 289, + "column": 1, + "source_line": "char *stb_include_preloaded(char *str, char *inject, char *includes[][2], char error[256])" + }, + "end": { + "filename": "stb/stb_include.h", + "line": 292, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + } + }, + "structs": {}, + "unions": {}, + "enums": {}, + "typedefs": { + "include_info": { + "reference": "include_info" + } + }, + "variables": {}, + "macros": { + "STB_INCLUDE_STB_INCLUDE_H": { + "name": "STB_INCLUDE_STB_INCLUDE_H", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_include.h", + "line": 38, + "column": 1, + "source_line": "#define STB_INCLUDE_STB_INCLUDE_H" + } + } + }, + "includes": { + "stb/stb_include.h:stdio.h": { + "target": "stdio.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_include.h", + "line": 55, + "column": 1, + "source_line": "#include " + } + }, + "stb/stb_include.h:stdlib.h": { + "target": "stdlib.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_include.h", + "line": 56, + "column": 1, + "source_line": "#include " + } + }, + "stb/stb_include.h:string.h": { + "target": "string.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_include.h", + "line": 57, + "column": 1, + "source_line": "#include " + } + } + }, + "functions_by_file": { + "stb/stb_include.h": [ + "stb_include_string", + "stb_include_strings", + "stb_include_file", + "stb_include_load_file", + "stb_include_append_include", + "stb_include_free_includes", + "stb_include_isspace", + "stb_include_find_includes", + "stb_include_itoa", + "stb_include_append", + "stb_include_preloaded" + ] + }, + "enum_constants": {}, + "include_graph": { + "stb/stb_include.h": [] + }, + "system_includes": { + "stb/stb_include.h": [ + "stdio.h", + "stdlib.h", + "string.h" + ] + }, + "unresolved_includes": { + "stb/stb_include.h": [] + }, + "header_source_pairs": { + "stb/stb_include.h": [] + }, + "diagnostics": [] +} diff --git a/tests/parser/c/fixtures/stb/stb_leakcheck.json b/tests/parser/c/fixtures/stb/stb_leakcheck.json new file mode 100644 index 000000000..9b219c662 --- /dev/null +++ b/tests/parser/c/fixtures/stb/stb_leakcheck.json @@ -0,0 +1,1971 @@ +{ + "files": { + "stb/stb_leakcheck.h": { + "filename": "stb/stb_leakcheck.h", + "language": "c", + "parser_status": "partial", + "preprocessing": "raw", + "functions": [ + { + "name": "stb_leakcheck_malloc", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "parameters": [ + { + "name": "sz", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t sz", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "file", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *file", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *file", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "line", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int line" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int line" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_leakcheck.h", + "line": 37, + "column": 1, + "source_line": "void *stb_leakcheck_malloc(size_t sz, const char *file, int line)" + }, + "start": { + "filename": "stb/stb_leakcheck.h", + "line": 37, + "column": 1, + "source_line": "void *stb_leakcheck_malloc(size_t sz, const char *file, int line)" + }, + "end": { + "filename": "stb/stb_leakcheck.h", + "line": 50, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_leakcheck.h", + "line": 146, + "column": 1, + "source_line": "extern void * stb_leakcheck_malloc(size_t sz, const char *file, int line);" + } + ] + }, + { + "name": "stb_leakcheck_free", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "ptr", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *ptr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *ptr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_leakcheck.h", + "line": 52, + "column": 1, + "source_line": "void stb_leakcheck_free(void *ptr)" + }, + "start": { + "filename": "stb/stb_leakcheck.h", + "line": 52, + "column": 1, + "source_line": "void stb_leakcheck_free(void *ptr)" + }, + "end": { + "filename": "stb/stb_leakcheck.h", + "line": 68, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_leakcheck.h", + "line": 148, + "column": 1, + "source_line": "extern void stb_leakcheck_free(void *ptr);" + } + ] + }, + { + "name": "stb_leakcheck_realloc", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "parameters": [ + { + "name": "ptr", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *ptr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *ptr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "sz", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t sz", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "file", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *file", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *file", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "line", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int line" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int line" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_leakcheck.h", + "line": 70, + "column": 1, + "source_line": "void *stb_leakcheck_realloc(void *ptr, size_t sz, const char *file, int line)" + }, + "start": { + "filename": "stb/stb_leakcheck.h", + "line": 70, + "column": 1, + "source_line": "void *stb_leakcheck_realloc(void *ptr, size_t sz, const char *file, int line)" + }, + "end": { + "filename": "stb/stb_leakcheck.h", + "line": 94, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_leakcheck.h", + "line": 147, + "column": 1, + "source_line": "extern void * stb_leakcheck_realloc(void *ptr, size_t sz, const char *file, int line);" + } + ] + }, + { + "name": "stblkck_internal_print", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "reason", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *reason", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *reason", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mi", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_leakcheck_malloc_info *mi", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stb_leakcheck_malloc_info", + "name": "stb_leakcheck_malloc_info", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": "malloc_info", + "members": [ + { + "name": "file", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *file", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_leakcheck.h", + "line": 29, + "column": 4, + "source_line": " const char *file;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "line", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int line" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_leakcheck.h", + "line": 30, + "column": 4, + "source_line": " int line;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "size", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t size", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_leakcheck.h", + "line": 31, + "column": 4, + "source_line": " size_t size;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "next", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_leakcheck_malloc_info *next", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_leakcheck_malloc_info" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_leakcheck.h", + "line": 32, + "column": 4, + "source_line": " stb_leakcheck_malloc_info *next,*prev;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "prev", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_leakcheck_malloc_info *prev", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_leakcheck_malloc_info" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_leakcheck.h", + "line": 32, + "column": 4, + "source_line": " stb_leakcheck_malloc_info *next,*prev;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": null, + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_leakcheck.h", + "line": 27, + "column": 1, + "source_line": "struct malloc_info" + } + }, + "source_location": { + "filename": "stb/stb_leakcheck.h", + "line": 25, + "column": 1, + "source_line": "typedef struct malloc_info stb_leakcheck_malloc_info;" + }, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_leakcheck_malloc_info *mi", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_leakcheck_malloc_info" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_leakcheck.h", + "line": 96, + "column": 1, + "source_line": "static void stblkck_internal_print(const char *reason, stb_leakcheck_malloc_info *mi)" + }, + "start": { + "filename": "stb/stb_leakcheck.h", + "line": 96, + "column": 1, + "source_line": "static void stblkck_internal_print(const char *reason, stb_leakcheck_malloc_info *mi)" + }, + "end": { + "filename": "stb/stb_leakcheck.h", + "line": 116, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_leakcheck_dumpmem", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_leakcheck.h", + "line": 118, + "column": 1, + "source_line": "void stb_leakcheck_dumpmem(void)" + }, + "start": { + "filename": "stb/stb_leakcheck.h", + "line": 118, + "column": 1, + "source_line": "void stb_leakcheck_dumpmem(void)" + }, + "end": { + "filename": "stb/stb_leakcheck.h", + "line": 134, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_leakcheck.h", + "line": 149, + "column": 1, + "source_line": "extern void stb_leakcheck_dumpmem(void);" + } + ] + } + ], + "structs": [ + { + "reference": "struct malloc_info" + } + ], + "unions": [], + "enums": [], + "typedefs": [ + { + "reference": "stb_leakcheck_malloc_info" + } + ], + "variables": [ + { + "name": "mi_head", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "static stb_leakcheck_malloc_info *mi_head", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_leakcheck_malloc_info" + } + ] + }, + "storage": [ + "static" + ], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_leakcheck.h", + "line": 35, + "column": 1, + "source_line": "static stb_leakcheck_malloc_info *mi_head;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "macros": [ + { + "name": "STB_LEAKCHECK_IMPLEMENTATION", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_leakcheck.h", + "line": 7, + "column": 1, + "source_line": "#undef STB_LEAKCHECK_IMPLEMENTATION // don't implement more than once" + } + }, + { + "name": "malloc", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_leakcheck.h", + "line": 11, + "column": 1, + "source_line": "#undef malloc" + } + }, + { + "name": "free", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_leakcheck.h", + "line": 12, + "column": 1, + "source_line": "#undef free" + } + }, + { + "name": "realloc", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_leakcheck.h", + "line": 13, + "column": 1, + "source_line": "#undef realloc" + } + }, + { + "name": "STB_LEAKCHECK_OUTPUT_PIPE", + "value": "stdout", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_leakcheck.h", + "line": 17, + "column": 1, + "source_line": "#define STB_LEAKCHECK_OUTPUT_PIPE stdout" + } + }, + { + "name": "INCLUDE_STB_LEAKCHECK_H", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_leakcheck.h", + "line": 138, + "column": 1, + "source_line": "#define INCLUDE_STB_LEAKCHECK_H" + } + }, + { + "name": "malloc", + "value": "stb_leakcheck_malloc(sz, __FILE__, __LINE__)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_leakcheck.h", + "line": 142, + "column": 1, + "source_line": "#define malloc(sz) stb_leakcheck_malloc(sz, __FILE__, __LINE__)" + } + }, + { + "name": "free", + "value": "stb_leakcheck_free(p)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_leakcheck.h", + "line": 143, + "column": 1, + "source_line": "#define free(p) stb_leakcheck_free(p)" + } + }, + { + "name": "realloc", + "value": "stb_leakcheck_realloc(p,sz, __FILE__, __LINE__)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_leakcheck.h", + "line": 144, + "column": 1, + "source_line": "#define realloc(p,sz) stb_leakcheck_realloc(p,sz, __FILE__, __LINE__)" + } + } + ], + "includes": [ + { + "target": "assert.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_leakcheck.h", + "line": 20, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "string.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_leakcheck.h", + "line": 21, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "stdlib.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_leakcheck.h", + "line": 22, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "stdio.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_leakcheck.h", + "line": 23, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "stddef.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_leakcheck.h", + "line": 24, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "stdlib.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_leakcheck.h", + "line": 140, + "column": 1, + "source_line": "#include // we want to define the macros *after* stdlib to avoid a slew of errors" + } + } + ], + "raw_directives": [ + { + "directive": "ifdef", + "argument": "STB_LEAKCHECK_IMPLEMENTATION", + "source_location": { + "filename": "stb/stb_leakcheck.h", + "line": 6, + "column": 1, + "source_line": "#ifdef STB_LEAKCHECK_IMPLEMENTATION" + } + }, + { + "directive": "ifdef", + "argument": "malloc", + "source_location": { + "filename": "stb/stb_leakcheck.h", + "line": 10, + "column": 1, + "source_line": "#ifdef malloc" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_leakcheck.h", + "line": 14, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_LEAKCHECK_OUTPUT_PIPE", + "source_location": { + "filename": "stb/stb_leakcheck.h", + "line": 16, + "column": 1, + "source_line": "#ifndef STB_LEAKCHECK_OUTPUT_PIPE" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_leakcheck.h", + "line": 18, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_LEAKCHECK_SHOWALL", + "source_location": { + "filename": "stb/stb_leakcheck.h", + "line": 57, + "column": 7, + "source_line": " #ifndef STB_LEAKCHECK_SHOWALL" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_leakcheck.h", + "line": 66, + "column": 7, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "STB_LEAKCHECK_REALLOC_PRESERVE_MALLOC_FILELINE", + "source_location": { + "filename": "stb/stb_leakcheck.h", + "line": 82, + "column": 10, + "source_line": " #ifdef STB_LEAKCHECK_REALLOC_PRESERVE_MALLOC_FILELINE" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_leakcheck.h", + "line": 84, + "column": 10, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_leakcheck.h", + "line": 86, + "column": 10, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "defined(_MSC_VER) && _MSC_VER < 1900", + "source_location": { + "filename": "stb/stb_leakcheck.h", + "line": 98, + "column": 1, + "source_line": "#if defined(_MSC_VER) && _MSC_VER < 1900 // 1900=VS 2015" + } + }, + { + "directive": "if", + "argument": "_MSC_VER < 1400", + "source_location": { + "filename": "stb/stb_leakcheck.h", + "line": 103, + "column": 4, + "source_line": " #if _MSC_VER < 1400 // before VS 2005" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_leakcheck.h", + "line": 105, + "column": 4, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_leakcheck.h", + "line": 107, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_leakcheck.h", + "line": 108, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "ifdef", + "argument": "__MINGW32__", + "source_location": { + "filename": "stb/stb_leakcheck.h", + "line": 110, + "column": 4, + "source_line": " #ifdef __MINGW32__" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_leakcheck.h", + "line": 112, + "column": 4, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_leakcheck.h", + "line": 114, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_leakcheck.h", + "line": 115, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STB_LEAKCHECK_SHOWALL", + "source_location": { + "filename": "stb/stb_leakcheck.h", + "line": 126, + "column": 4, + "source_line": " #ifdef STB_LEAKCHECK_SHOWALL" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_leakcheck.h", + "line": 133, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_leakcheck.h", + "line": 135, + "column": 1, + "source_line": "#endif // STB_LEAKCHECK_IMPLEMENTATION" + } + }, + { + "directive": "if", + "argument": "!defined(INCLUDE_STB_LEAKCHECK_H) || !defined(malloc)", + "source_location": { + "filename": "stb/stb_leakcheck.h", + "line": 137, + "column": 1, + "source_line": "#if !defined(INCLUDE_STB_LEAKCHECK_H) || !defined(malloc)" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_leakcheck.h", + "line": 151, + "column": 1, + "source_line": "#endif // INCLUDE_STB_LEAKCHECK_H" + } + } + ], + "macro_dependencies": [], + "diagnostics": [ + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'malloc' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_leakcheck.h", + "line": 142, + "column": 1, + "source_line": "#define malloc(sz) stb_leakcheck_malloc(sz, __FILE__, __LINE__)" + }, + "unit_kind": "macro", + "unit_name": "malloc" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'free' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_leakcheck.h", + "line": 143, + "column": 1, + "source_line": "#define free(p) stb_leakcheck_free(p)" + }, + "unit_kind": "macro", + "unit_name": "free" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'realloc' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_leakcheck.h", + "line": 144, + "column": 1, + "source_line": "#define realloc(p,sz) stb_leakcheck_realloc(p,sz, __FILE__, __LINE__)" + }, + "unit_kind": "macro", + "unit_name": "realloc" + } + ] + } + }, + "functions": { + "stb_leakcheck_malloc": { + "name": "stb_leakcheck_malloc", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "parameters": [ + { + "name": "sz", + "type": { + "reference": "size_t" + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "file", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *file", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *file", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "line", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int line" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int line" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_leakcheck.h", + "line": 37, + "column": 1, + "source_line": "void *stb_leakcheck_malloc(size_t sz, const char *file, int line)" + }, + "start": { + "filename": "stb/stb_leakcheck.h", + "line": 37, + "column": 1, + "source_line": "void *stb_leakcheck_malloc(size_t sz, const char *file, int line)" + }, + "end": { + "filename": "stb/stb_leakcheck.h", + "line": 50, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_leakcheck.h", + "line": 146, + "column": 1, + "source_line": "extern void * stb_leakcheck_malloc(size_t sz, const char *file, int line);" + } + ] + }, + "stb_leakcheck_free": { + "name": "stb_leakcheck_free", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "ptr", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *ptr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *ptr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_leakcheck.h", + "line": 52, + "column": 1, + "source_line": "void stb_leakcheck_free(void *ptr)" + }, + "start": { + "filename": "stb/stb_leakcheck.h", + "line": 52, + "column": 1, + "source_line": "void stb_leakcheck_free(void *ptr)" + }, + "end": { + "filename": "stb/stb_leakcheck.h", + "line": 68, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_leakcheck.h", + "line": 148, + "column": 1, + "source_line": "extern void stb_leakcheck_free(void *ptr);" + } + ] + }, + "stb_leakcheck_realloc": { + "name": "stb_leakcheck_realloc", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "parameters": [ + { + "name": "ptr", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *ptr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *ptr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "sz", + "type": { + "reference": "size_t" + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "file", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *file", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *file", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "line", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int line" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int line" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_leakcheck.h", + "line": 70, + "column": 1, + "source_line": "void *stb_leakcheck_realloc(void *ptr, size_t sz, const char *file, int line)" + }, + "start": { + "filename": "stb/stb_leakcheck.h", + "line": 70, + "column": 1, + "source_line": "void *stb_leakcheck_realloc(void *ptr, size_t sz, const char *file, int line)" + }, + "end": { + "filename": "stb/stb_leakcheck.h", + "line": 94, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_leakcheck.h", + "line": 147, + "column": 1, + "source_line": "extern void * stb_leakcheck_realloc(void *ptr, size_t sz, const char *file, int line);" + } + ] + }, + "stblkck_internal_print": { + "name": "stblkck_internal_print", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "reason", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *reason", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *reason", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mi", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_leakcheck_malloc_info *mi", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_leakcheck_malloc_info" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_leakcheck_malloc_info *mi", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_leakcheck_malloc_info" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_leakcheck.h", + "line": 96, + "column": 1, + "source_line": "static void stblkck_internal_print(const char *reason, stb_leakcheck_malloc_info *mi)" + }, + "start": { + "filename": "stb/stb_leakcheck.h", + "line": 96, + "column": 1, + "source_line": "static void stblkck_internal_print(const char *reason, stb_leakcheck_malloc_info *mi)" + }, + "end": { + "filename": "stb/stb_leakcheck.h", + "line": 116, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_leakcheck_dumpmem": { + "name": "stb_leakcheck_dumpmem", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_leakcheck.h", + "line": 118, + "column": 1, + "source_line": "void stb_leakcheck_dumpmem(void)" + }, + "start": { + "filename": "stb/stb_leakcheck.h", + "line": 118, + "column": 1, + "source_line": "void stb_leakcheck_dumpmem(void)" + }, + "end": { + "filename": "stb/stb_leakcheck.h", + "line": 134, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_leakcheck.h", + "line": 149, + "column": 1, + "source_line": "extern void stb_leakcheck_dumpmem(void);" + } + ] + } + }, + "structs": { + "malloc_info": { + "reference": "struct malloc_info" + } + }, + "unions": {}, + "enums": {}, + "typedefs": { + "stb_leakcheck_malloc_info": { + "reference": "stb_leakcheck_malloc_info" + } + }, + "variables": { + "mi_head": { + "name": "mi_head", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "static stb_leakcheck_malloc_info *mi_head", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_leakcheck_malloc_info" + } + ] + }, + "storage": [ + "static" + ], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_leakcheck.h", + "line": 35, + "column": 1, + "source_line": "static stb_leakcheck_malloc_info *mi_head;" + }, + "callback_policy": null, + "declaration_locations": [] + } + }, + "macros": { + "STB_LEAKCHECK_IMPLEMENTATION": { + "name": "STB_LEAKCHECK_IMPLEMENTATION", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_leakcheck.h", + "line": 7, + "column": 1, + "source_line": "#undef STB_LEAKCHECK_IMPLEMENTATION // don't implement more than once" + } + }, + "malloc": { + "name": "malloc", + "value": "stb_leakcheck_malloc(sz, __FILE__, __LINE__)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_leakcheck.h", + "line": 142, + "column": 1, + "source_line": "#define malloc(sz) stb_leakcheck_malloc(sz, __FILE__, __LINE__)" + } + }, + "free": { + "name": "free", + "value": "stb_leakcheck_free(p)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_leakcheck.h", + "line": 143, + "column": 1, + "source_line": "#define free(p) stb_leakcheck_free(p)" + } + }, + "realloc": { + "name": "realloc", + "value": "stb_leakcheck_realloc(p,sz, __FILE__, __LINE__)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_leakcheck.h", + "line": 144, + "column": 1, + "source_line": "#define realloc(p,sz) stb_leakcheck_realloc(p,sz, __FILE__, __LINE__)" + } + }, + "STB_LEAKCHECK_OUTPUT_PIPE": { + "name": "STB_LEAKCHECK_OUTPUT_PIPE", + "value": "stdout", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_leakcheck.h", + "line": 17, + "column": 1, + "source_line": "#define STB_LEAKCHECK_OUTPUT_PIPE stdout" + } + }, + "INCLUDE_STB_LEAKCHECK_H": { + "name": "INCLUDE_STB_LEAKCHECK_H", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_leakcheck.h", + "line": 138, + "column": 1, + "source_line": "#define INCLUDE_STB_LEAKCHECK_H" + } + } + }, + "includes": { + "stb/stb_leakcheck.h:assert.h": { + "target": "assert.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_leakcheck.h", + "line": 20, + "column": 1, + "source_line": "#include " + } + }, + "stb/stb_leakcheck.h:string.h": { + "target": "string.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_leakcheck.h", + "line": 21, + "column": 1, + "source_line": "#include " + } + }, + "stb/stb_leakcheck.h:stdlib.h": { + "target": "stdlib.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_leakcheck.h", + "line": 140, + "column": 1, + "source_line": "#include // we want to define the macros *after* stdlib to avoid a slew of errors" + } + }, + "stb/stb_leakcheck.h:stdio.h": { + "target": "stdio.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_leakcheck.h", + "line": 23, + "column": 1, + "source_line": "#include " + } + }, + "stb/stb_leakcheck.h:stddef.h": { + "target": "stddef.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_leakcheck.h", + "line": 24, + "column": 1, + "source_line": "#include " + } + } + }, + "functions_by_file": { + "stb/stb_leakcheck.h": [ + "stb_leakcheck_malloc", + "stb_leakcheck_free", + "stb_leakcheck_realloc", + "stblkck_internal_print", + "stb_leakcheck_dumpmem" + ] + }, + "enum_constants": {}, + "include_graph": { + "stb/stb_leakcheck.h": [] + }, + "system_includes": { + "stb/stb_leakcheck.h": [ + "assert.h", + "stddef.h", + "stdio.h", + "stdlib.h", + "string.h" + ] + }, + "unresolved_includes": { + "stb/stb_leakcheck.h": [] + }, + "header_source_pairs": { + "stb/stb_leakcheck.h": [] + }, + "diagnostics": [ + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'malloc' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_leakcheck.h", + "line": 142, + "column": 1, + "source_line": "#define malloc(sz) stb_leakcheck_malloc(sz, __FILE__, __LINE__)" + }, + "unit_kind": "macro", + "unit_name": "malloc" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'free' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_leakcheck.h", + "line": 143, + "column": 1, + "source_line": "#define free(p) stb_leakcheck_free(p)" + }, + "unit_kind": "macro", + "unit_name": "free" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'realloc' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_leakcheck.h", + "line": 144, + "column": 1, + "source_line": "#define realloc(p,sz) stb_leakcheck_realloc(p,sz, __FILE__, __LINE__)" + }, + "unit_kind": "macro", + "unit_name": "realloc" + } + ] +} diff --git a/tests/parser/c/fixtures/stb/stb_perlin.json b/tests/parser/c/fixtures/stb/stb_perlin.json new file mode 100644 index 000000000..f70863ac5 --- /dev/null +++ b/tests/parser/c/fixtures/stb/stb_perlin.json @@ -0,0 +1,2628 @@ +{ + "files": { + "stb/stb_perlin.h": { + "filename": "stb/stb_perlin.h", + "language": "c", + "parser_status": "partial", + "preprocessing": "raw", + "functions": [ + { + "name": "stb__perlin_lerp", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float a" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float a" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float b" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float b" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "t", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float t" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float t" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_perlin.h", + "line": 179, + "column": 1, + "source_line": "static float stb__perlin_lerp(float a, float b, float t)" + }, + "start": { + "filename": "stb/stb_perlin.h", + "line": 179, + "column": 1, + "source_line": "static float stb__perlin_lerp(float a, float b, float t)" + }, + "end": { + "filename": "stb/stb_perlin.h", + "line": 182, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb__perlin_fastfloor", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float a" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float a" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_perlin.h", + "line": 184, + "column": 1, + "source_line": "static int stb__perlin_fastfloor(float a)" + }, + "start": { + "filename": "stb/stb_perlin.h", + "line": 184, + "column": 1, + "source_line": "static int stb__perlin_fastfloor(float a)" + }, + "end": { + "filename": "stb/stb_perlin.h", + "line": 188, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb__perlin_grad", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "grad_idx", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int grad_idx" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int grad_idx" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "z", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float z" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float z" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_perlin.h", + "line": 191, + "column": 1, + "source_line": "static float stb__perlin_grad(int grad_idx, float x, float y, float z)" + }, + "start": { + "filename": "stb/stb_perlin.h", + "line": 191, + "column": 1, + "source_line": "static float stb__perlin_grad(int grad_idx, float x, float y, float z)" + }, + "end": { + "filename": "stb/stb_perlin.h", + "line": 211, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_perlin_noise3_internal", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "z", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float z" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float z" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x_wrap", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x_wrap" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x_wrap" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y_wrap", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y_wrap" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y_wrap" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "z_wrap", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int z_wrap" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int z_wrap" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "seed", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char seed" + }, + "declared_type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char seed" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_perlin.h", + "line": 213, + "column": 1, + "source_line": "float stb_perlin_noise3_internal(float x, float y, float z, int x_wrap, int y_wrap, int z_wrap, unsigned char seed)" + }, + "start": { + "filename": "stb/stb_perlin.h", + "line": 213, + "column": 1, + "source_line": "float stb_perlin_noise3_internal(float x, float y, float z, int x_wrap, int y_wrap, int z_wrap, unsigned char seed)" + }, + "end": { + "filename": "stb/stb_perlin.h", + "line": 263, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_perlin_noise3", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "z", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float z" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float z" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x_wrap", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x_wrap" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x_wrap" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y_wrap", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y_wrap" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y_wrap" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "z_wrap", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int z_wrap" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int z_wrap" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_perlin.h", + "line": 265, + "column": 1, + "source_line": "float stb_perlin_noise3(float x, float y, float z, int x_wrap, int y_wrap, int z_wrap)" + }, + "start": { + "filename": "stb/stb_perlin.h", + "line": 265, + "column": 1, + "source_line": "float stb_perlin_noise3(float x, float y, float z, int x_wrap, int y_wrap, int z_wrap)" + }, + "end": { + "filename": "stb/stb_perlin.h", + "line": 268, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_perlin_noise3_seed", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "z", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float z" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float z" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x_wrap", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x_wrap" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x_wrap" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y_wrap", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y_wrap" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y_wrap" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "z_wrap", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int z_wrap" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int z_wrap" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "seed", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int seed" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int seed" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_perlin.h", + "line": 270, + "column": 1, + "source_line": "float stb_perlin_noise3_seed(float x, float y, float z, int x_wrap, int y_wrap, int z_wrap, int seed)" + }, + "start": { + "filename": "stb/stb_perlin.h", + "line": 270, + "column": 1, + "source_line": "float stb_perlin_noise3_seed(float x, float y, float z, int x_wrap, int y_wrap, int z_wrap, int seed)" + }, + "end": { + "filename": "stb/stb_perlin.h", + "line": 273, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_perlin_ridge_noise3", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "z", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float z" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float z" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "lacunarity", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float lacunarity" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float lacunarity" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "gain", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float gain" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float gain" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "offset", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float offset" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float offset" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "octaves", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int octaves" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int octaves" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_perlin.h", + "line": 275, + "column": 1, + "source_line": "float stb_perlin_ridge_noise3(float x, float y, float z, float lacunarity, float gain, float offset, int octaves)" + }, + "start": { + "filename": "stb/stb_perlin.h", + "line": 275, + "column": 1, + "source_line": "float stb_perlin_ridge_noise3(float x, float y, float z, float lacunarity, float gain, float offset, int octaves)" + }, + "end": { + "filename": "stb/stb_perlin.h", + "line": 293, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_perlin_fbm_noise3", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "z", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float z" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float z" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "lacunarity", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float lacunarity" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float lacunarity" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "gain", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float gain" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float gain" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "octaves", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int octaves" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int octaves" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_perlin.h", + "line": 295, + "column": 1, + "source_line": "float stb_perlin_fbm_noise3(float x, float y, float z, float lacunarity, float gain, int octaves)" + }, + "start": { + "filename": "stb/stb_perlin.h", + "line": 295, + "column": 1, + "source_line": "float stb_perlin_fbm_noise3(float x, float y, float z, float lacunarity, float gain, int octaves)" + }, + "end": { + "filename": "stb/stb_perlin.h", + "line": 308, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_perlin_turbulence_noise3", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "z", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float z" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float z" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "lacunarity", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float lacunarity" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float lacunarity" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "gain", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float gain" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float gain" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "octaves", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int octaves" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int octaves" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_perlin.h", + "line": 310, + "column": 1, + "source_line": "float stb_perlin_turbulence_noise3(float x, float y, float z, float lacunarity, float gain, int octaves)" + }, + "start": { + "filename": "stb/stb_perlin.h", + "line": 310, + "column": 1, + "source_line": "float stb_perlin_turbulence_noise3(float x, float y, float z, float lacunarity, float gain, int octaves)" + }, + "end": { + "filename": "stb/stb_perlin.h", + "line": 324, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_perlin_noise3_wrap_nonpow2", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "z", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float z" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float z" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x_wrap", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x_wrap" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x_wrap" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y_wrap", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y_wrap" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y_wrap" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "z_wrap", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int z_wrap" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int z_wrap" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "seed", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char seed" + }, + "declared_type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char seed" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_perlin.h", + "line": 326, + "column": 1, + "source_line": "float stb_perlin_noise3_wrap_nonpow2(float x, float y, float z, int x_wrap, int y_wrap, int z_wrap, unsigned char seed)" + }, + "start": { + "filename": "stb/stb_perlin.h", + "line": 326, + "column": 1, + "source_line": "float stb_perlin_noise3_wrap_nonpow2(float x, float y, float z, int x_wrap, int y_wrap, int z_wrap, unsigned char seed)" + }, + "end": { + "filename": "stb/stb_perlin.h", + "line": 385, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + } + ], + "structs": [], + "unions": [], + "enums": [], + "typedefs": [], + "variables": [], + "macros": [ + { + "name": "stb__perlin_ease", + "value": "(((a*6-15)*a + 10) * a * a * a)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_perlin.h", + "line": 231, + "column": 4, + "source_line": " #define stb__perlin_ease(a) (((a*6-15)*a + 10) * a * a * a)" + } + }, + { + "name": "stb__perlin_ease", + "value": "(((a*6-15)*a + 10) * a * a * a)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_perlin.h", + "line": 351, + "column": 4, + "source_line": " #define stb__perlin_ease(a) (((a*6-15)*a + 10) * a * a * a)" + } + } + ], + "includes": [ + { + "target": "math.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_perlin.h", + "line": 92, + "column": 1, + "source_line": "#include // fabs()" + } + } + ], + "raw_directives": [ + { + "directive": "ifdef", + "argument": "__cplusplus", + "source_location": { + "filename": "stb/stb_perlin.h", + "line": 77, + "column": 1, + "source_line": "#ifdef __cplusplus" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_perlin.h", + "line": 79, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "__cplusplus", + "source_location": { + "filename": "stb/stb_perlin.h", + "line": 86, + "column": 1, + "source_line": "#ifdef __cplusplus" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_perlin.h", + "line": 88, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STB_PERLIN_IMPLEMENTATION", + "source_location": { + "filename": "stb/stb_perlin.h", + "line": 90, + "column": 1, + "source_line": "#ifdef STB_PERLIN_IMPLEMENTATION" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_perlin.h", + "line": 386, + "column": 1, + "source_line": "#endif // STB_PERLIN_IMPLEMENTATION" + } + } + ], + "macro_dependencies": [], + "diagnostics": [ + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stb__perlin_ease' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_perlin.h", + "line": 231, + "column": 4, + "source_line": " #define stb__perlin_ease(a) (((a*6-15)*a + 10) * a * a * a)" + }, + "unit_kind": "macro", + "unit_name": "stb__perlin_ease" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stb__perlin_ease' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_perlin.h", + "line": 351, + "column": 4, + "source_line": " #define stb__perlin_ease(a) (((a*6-15)*a + 10) * a * a * a)" + }, + "unit_kind": "macro", + "unit_name": "stb__perlin_ease" + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '\"C\"'.", + "severity": "warning", + "location": { + "filename": "stb/stb_perlin.h", + "line": 78, + "column": 1, + "source_line": "extern \"C\" {" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_perlin.h", + "line": 96, + "column": 1, + "source_line": "static unsigned char stb__perlin_randtab[512] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_perlin.h", + "line": 141, + "column": 1, + "source_line": "static unsigned char stb__perlin_randtab_grad_idx[512] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + } + ] + } + }, + "functions": { + "stb__perlin_lerp": { + "name": "stb__perlin_lerp", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float a" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float a" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float b" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float b" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "t", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float t" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float t" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_perlin.h", + "line": 179, + "column": 1, + "source_line": "static float stb__perlin_lerp(float a, float b, float t)" + }, + "start": { + "filename": "stb/stb_perlin.h", + "line": 179, + "column": 1, + "source_line": "static float stb__perlin_lerp(float a, float b, float t)" + }, + "end": { + "filename": "stb/stb_perlin.h", + "line": 182, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb__perlin_fastfloor": { + "name": "stb__perlin_fastfloor", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float a" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float a" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_perlin.h", + "line": 184, + "column": 1, + "source_line": "static int stb__perlin_fastfloor(float a)" + }, + "start": { + "filename": "stb/stb_perlin.h", + "line": 184, + "column": 1, + "source_line": "static int stb__perlin_fastfloor(float a)" + }, + "end": { + "filename": "stb/stb_perlin.h", + "line": 188, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb__perlin_grad": { + "name": "stb__perlin_grad", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "grad_idx", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int grad_idx" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int grad_idx" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "z", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float z" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float z" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_perlin.h", + "line": 191, + "column": 1, + "source_line": "static float stb__perlin_grad(int grad_idx, float x, float y, float z)" + }, + "start": { + "filename": "stb/stb_perlin.h", + "line": 191, + "column": 1, + "source_line": "static float stb__perlin_grad(int grad_idx, float x, float y, float z)" + }, + "end": { + "filename": "stb/stb_perlin.h", + "line": 211, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_perlin_noise3_internal": { + "name": "stb_perlin_noise3_internal", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "z", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float z" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float z" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x_wrap", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x_wrap" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x_wrap" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y_wrap", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y_wrap" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y_wrap" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "z_wrap", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int z_wrap" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int z_wrap" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "seed", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char seed" + }, + "declared_type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char seed" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_perlin.h", + "line": 213, + "column": 1, + "source_line": "float stb_perlin_noise3_internal(float x, float y, float z, int x_wrap, int y_wrap, int z_wrap, unsigned char seed)" + }, + "start": { + "filename": "stb/stb_perlin.h", + "line": 213, + "column": 1, + "source_line": "float stb_perlin_noise3_internal(float x, float y, float z, int x_wrap, int y_wrap, int z_wrap, unsigned char seed)" + }, + "end": { + "filename": "stb/stb_perlin.h", + "line": 263, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_perlin_noise3": { + "name": "stb_perlin_noise3", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "z", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float z" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float z" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x_wrap", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x_wrap" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x_wrap" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y_wrap", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y_wrap" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y_wrap" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "z_wrap", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int z_wrap" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int z_wrap" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_perlin.h", + "line": 265, + "column": 1, + "source_line": "float stb_perlin_noise3(float x, float y, float z, int x_wrap, int y_wrap, int z_wrap)" + }, + "start": { + "filename": "stb/stb_perlin.h", + "line": 265, + "column": 1, + "source_line": "float stb_perlin_noise3(float x, float y, float z, int x_wrap, int y_wrap, int z_wrap)" + }, + "end": { + "filename": "stb/stb_perlin.h", + "line": 268, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_perlin_noise3_seed": { + "name": "stb_perlin_noise3_seed", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "z", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float z" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float z" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x_wrap", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x_wrap" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x_wrap" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y_wrap", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y_wrap" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y_wrap" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "z_wrap", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int z_wrap" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int z_wrap" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "seed", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int seed" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int seed" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_perlin.h", + "line": 270, + "column": 1, + "source_line": "float stb_perlin_noise3_seed(float x, float y, float z, int x_wrap, int y_wrap, int z_wrap, int seed)" + }, + "start": { + "filename": "stb/stb_perlin.h", + "line": 270, + "column": 1, + "source_line": "float stb_perlin_noise3_seed(float x, float y, float z, int x_wrap, int y_wrap, int z_wrap, int seed)" + }, + "end": { + "filename": "stb/stb_perlin.h", + "line": 273, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_perlin_ridge_noise3": { + "name": "stb_perlin_ridge_noise3", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "z", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float z" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float z" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "lacunarity", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float lacunarity" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float lacunarity" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "gain", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float gain" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float gain" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "offset", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float offset" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float offset" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "octaves", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int octaves" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int octaves" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_perlin.h", + "line": 275, + "column": 1, + "source_line": "float stb_perlin_ridge_noise3(float x, float y, float z, float lacunarity, float gain, float offset, int octaves)" + }, + "start": { + "filename": "stb/stb_perlin.h", + "line": 275, + "column": 1, + "source_line": "float stb_perlin_ridge_noise3(float x, float y, float z, float lacunarity, float gain, float offset, int octaves)" + }, + "end": { + "filename": "stb/stb_perlin.h", + "line": 293, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_perlin_fbm_noise3": { + "name": "stb_perlin_fbm_noise3", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "z", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float z" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float z" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "lacunarity", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float lacunarity" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float lacunarity" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "gain", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float gain" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float gain" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "octaves", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int octaves" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int octaves" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_perlin.h", + "line": 295, + "column": 1, + "source_line": "float stb_perlin_fbm_noise3(float x, float y, float z, float lacunarity, float gain, int octaves)" + }, + "start": { + "filename": "stb/stb_perlin.h", + "line": 295, + "column": 1, + "source_line": "float stb_perlin_fbm_noise3(float x, float y, float z, float lacunarity, float gain, int octaves)" + }, + "end": { + "filename": "stb/stb_perlin.h", + "line": 308, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_perlin_turbulence_noise3": { + "name": "stb_perlin_turbulence_noise3", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "z", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float z" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float z" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "lacunarity", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float lacunarity" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float lacunarity" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "gain", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float gain" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float gain" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "octaves", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int octaves" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int octaves" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_perlin.h", + "line": 310, + "column": 1, + "source_line": "float stb_perlin_turbulence_noise3(float x, float y, float z, float lacunarity, float gain, int octaves)" + }, + "start": { + "filename": "stb/stb_perlin.h", + "line": 310, + "column": 1, + "source_line": "float stb_perlin_turbulence_noise3(float x, float y, float z, float lacunarity, float gain, int octaves)" + }, + "end": { + "filename": "stb/stb_perlin.h", + "line": 324, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_perlin_noise3_wrap_nonpow2": { + "name": "stb_perlin_noise3_wrap_nonpow2", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "z", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float z" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float z" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x_wrap", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x_wrap" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x_wrap" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y_wrap", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y_wrap" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y_wrap" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "z_wrap", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int z_wrap" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int z_wrap" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "seed", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char seed" + }, + "declared_type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char seed" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_perlin.h", + "line": 326, + "column": 1, + "source_line": "float stb_perlin_noise3_wrap_nonpow2(float x, float y, float z, int x_wrap, int y_wrap, int z_wrap, unsigned char seed)" + }, + "start": { + "filename": "stb/stb_perlin.h", + "line": 326, + "column": 1, + "source_line": "float stb_perlin_noise3_wrap_nonpow2(float x, float y, float z, int x_wrap, int y_wrap, int z_wrap, unsigned char seed)" + }, + "end": { + "filename": "stb/stb_perlin.h", + "line": 385, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + } + }, + "structs": {}, + "unions": {}, + "enums": {}, + "typedefs": {}, + "variables": {}, + "macros": { + "stb__perlin_ease": { + "name": "stb__perlin_ease", + "value": "(((a*6-15)*a + 10) * a * a * a)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_perlin.h", + "line": 351, + "column": 4, + "source_line": " #define stb__perlin_ease(a) (((a*6-15)*a + 10) * a * a * a)" + } + } + }, + "includes": { + "stb/stb_perlin.h:math.h": { + "target": "math.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_perlin.h", + "line": 92, + "column": 1, + "source_line": "#include // fabs()" + } + } + }, + "functions_by_file": { + "stb/stb_perlin.h": [ + "stb__perlin_lerp", + "stb__perlin_fastfloor", + "stb__perlin_grad", + "stb_perlin_noise3_internal", + "stb_perlin_noise3", + "stb_perlin_noise3_seed", + "stb_perlin_ridge_noise3", + "stb_perlin_fbm_noise3", + "stb_perlin_turbulence_noise3", + "stb_perlin_noise3_wrap_nonpow2" + ] + }, + "enum_constants": {}, + "include_graph": { + "stb/stb_perlin.h": [] + }, + "system_includes": { + "stb/stb_perlin.h": [ + "math.h" + ] + }, + "unresolved_includes": { + "stb/stb_perlin.h": [] + }, + "header_source_pairs": { + "stb/stb_perlin.h": [] + }, + "diagnostics": [ + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stb__perlin_ease' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_perlin.h", + "line": 231, + "column": 4, + "source_line": " #define stb__perlin_ease(a) (((a*6-15)*a + 10) * a * a * a)" + }, + "unit_kind": "macro", + "unit_name": "stb__perlin_ease" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stb__perlin_ease' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_perlin.h", + "line": 351, + "column": 4, + "source_line": " #define stb__perlin_ease(a) (((a*6-15)*a + 10) * a * a * a)" + }, + "unit_kind": "macro", + "unit_name": "stb__perlin_ease" + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '\"C\"'.", + "severity": "warning", + "location": { + "filename": "stb/stb_perlin.h", + "line": 78, + "column": 1, + "source_line": "extern \"C\" {" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_perlin.h", + "line": 96, + "column": 1, + "source_line": "static unsigned char stb__perlin_randtab[512] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_perlin.h", + "line": 141, + "column": 1, + "source_line": "static unsigned char stb__perlin_randtab_grad_idx[512] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + } + ] +} diff --git a/tests/parser/c/fixtures/stb/stb_rect_pack.json b/tests/parser/c/fixtures/stb/stb_rect_pack.json new file mode 100644 index 000000000..4592d3d03 --- /dev/null +++ b/tests/parser/c/fixtures/stb/stb_rect_pack.json @@ -0,0 +1,1766 @@ +{ + "files": { + "stb/stb_rect_pack.h": { + "filename": "stb/stb_rect_pack.h", + "language": "c", + "parser_status": "partial", + "preprocessing": "raw", + "functions": [ + { + "name": "stbrp__skyline_find_min_y", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "c", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbrp_context *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbrp_context", + "name": "stbrp_context", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbrp_context *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbrp_context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "first", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbrp_node *first", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbrp_node", + "name": "stbrp_node", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbrp_node *first", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbrp_node" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "width", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "pwaste", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *pwaste", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *pwaste", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_rect_pack.h", + "line": 287, + "column": 1, + "source_line": "static int stbrp__skyline_find_min_y(stbrp_context *c, stbrp_node *first, int x0, int width, int *pwaste)" + }, + "start": { + "filename": "stb/stb_rect_pack.h", + "line": 287, + "column": 1, + "source_line": "static int stbrp__skyline_find_min_y(stbrp_context *c, stbrp_node *first, int x0, int width, int *pwaste)" + }, + "end": { + "filename": "stb/stb_rect_pack.h", + "line": 335, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbrp__skyline_find_best_pos", + "result_type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbrp__findresult", + "name": "stbrp__findresult", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_rect_pack.h", + "line": 339, + "column": 4, + "source_line": " int x,y;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_rect_pack.h", + "line": 339, + "column": 4, + "source_line": " int x,y;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "prev_link", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbrp_node **prev_link", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbrp_node", + "name": "stbrp_node", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_rect_pack.h", + "line": 340, + "column": 4, + "source_line": " stbrp_node **prev_link;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_rect_pack.h:337:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_rect_pack.h", + "line": 337, + "column": 1, + "source_line": "typedef struct" + } + }, + "source_location": { + "filename": "stb/stb_rect_pack.h", + "line": 337, + "column": 1, + "source_line": "typedef struct" + }, + "declaration_locations": [] + }, + "parameters": [ + { + "name": "c", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbrp_context *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbrp_context", + "name": "stbrp_context", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbrp_context *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbrp_context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "width", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "height", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int height" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int height" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_rect_pack.h", + "line": 343, + "column": 1, + "source_line": "static stbrp__findresult stbrp__skyline_find_best_pos(stbrp_context *c, int width, int height)" + }, + "start": { + "filename": "stb/stb_rect_pack.h", + "line": 343, + "column": 1, + "source_line": "static stbrp__findresult stbrp__skyline_find_best_pos(stbrp_context *c, int width, int height)" + }, + "end": { + "filename": "stb/stb_rect_pack.h", + "line": 443, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbrp__skyline_pack_rectangle", + "result_type": { + "reference": "stbrp__findresult" + }, + "parameters": [ + { + "name": "context", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbrp_context *context", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbrp_context", + "name": "stbrp_context", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbrp_context *context", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbrp_context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "width", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "height", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int height" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int height" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_rect_pack.h", + "line": 445, + "column": 1, + "source_line": "static stbrp__findresult stbrp__skyline_pack_rectangle(stbrp_context *context, int width, int height)" + }, + "start": { + "filename": "stb/stb_rect_pack.h", + "line": 445, + "column": 1, + "source_line": "static stbrp__findresult stbrp__skyline_pack_rectangle(stbrp_context *context, int width, int height)" + }, + "end": { + "filename": "stb/stb_rect_pack.h", + "line": 522, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + } + ], + "structs": [ + { + "reference": "struct@stb/stb_rect_pack.h:337:1" + } + ], + "unions": [], + "enums": [ + { + "model": "CEnum", + "qualifiers": [], + "source_text": "", + "name": null, + "constants": [ + { + "name": "STBRP__INIT_skyline", + "value": "1", + "source_location": { + "filename": "stb/stb_rect_pack.h", + "line": 224, + "column": 1, + "source_line": "enum" + } + } + ], + "anonymous_id": "enum@stb/stb_rect_pack.h:224:1", + "source_location": { + "filename": "stb/stb_rect_pack.h", + "line": 224, + "column": 1, + "source_line": "enum" + } + } + ], + "typedefs": [ + { + "reference": "stbrp__findresult" + } + ], + "variables": [], + "macros": [ + { + "name": "STB_INCLUDE_STB_RECT_PACK_H", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_rect_pack.h", + "line": 67, + "column": 1, + "source_line": "#define STB_INCLUDE_STB_RECT_PACK_H" + } + }, + { + "name": "STB_RECT_PACK_VERSION", + "value": "1", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_rect_pack.h", + "line": 69, + "column": 1, + "source_line": "#define STB_RECT_PACK_VERSION 1" + } + }, + { + "name": "STBRP_DEF", + "value": "static", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_rect_pack.h", + "line": 72, + "column": 1, + "source_line": "#define STBRP_DEF static" + } + }, + { + "name": "STBRP_DEF", + "value": "extern", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_rect_pack.h", + "line": 74, + "column": 1, + "source_line": "#define STBRP_DEF extern" + } + }, + { + "name": "STBRP__MAXVAL", + "value": "0x7fffffff", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_rect_pack.h", + "line": 87, + "column": 1, + "source_line": "#define STBRP__MAXVAL 0x7fffffff" + } + }, + { + "name": "STBRP_SORT", + "value": "qsort", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_rect_pack.h", + "line": 208, + "column": 1, + "source_line": "#define STBRP_SORT qsort" + } + }, + { + "name": "STBRP_ASSERT", + "value": "assert", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_rect_pack.h", + "line": 213, + "column": 1, + "source_line": "#define STBRP_ASSERT assert" + } + }, + { + "name": "STBRP__NOTUSED", + "value": "(void)(v)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_rect_pack.h", + "line": 217, + "column": 1, + "source_line": "#define STBRP__NOTUSED(v) (void)(v)" + } + }, + { + "name": "STBRP__CDECL", + "value": "__cdecl", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_rect_pack.h", + "line": 218, + "column": 1, + "source_line": "#define STBRP__CDECL __cdecl" + } + }, + { + "name": "STBRP__NOTUSED", + "value": "(void)sizeof(v)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_rect_pack.h", + "line": 220, + "column": 1, + "source_line": "#define STBRP__NOTUSED(v) (void)sizeof(v)" + } + }, + { + "name": "STBRP__CDECL", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_rect_pack.h", + "line": 221, + "column": 1, + "source_line": "#define STBRP__CDECL" + } + } + ], + "includes": [ + { + "target": "stdlib.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_rect_pack.h", + "line": 207, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "assert.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_rect_pack.h", + "line": 212, + "column": 1, + "source_line": "#include " + } + } + ], + "raw_directives": [ + { + "directive": "ifndef", + "argument": "STB_INCLUDE_STB_RECT_PACK_H", + "source_location": { + "filename": "stb/stb_rect_pack.h", + "line": 66, + "column": 1, + "source_line": "#ifndef STB_INCLUDE_STB_RECT_PACK_H" + } + }, + { + "directive": "ifdef", + "argument": "STBRP_STATIC", + "source_location": { + "filename": "stb/stb_rect_pack.h", + "line": 71, + "column": 1, + "source_line": "#ifdef STBRP_STATIC" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_rect_pack.h", + "line": 73, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_rect_pack.h", + "line": 75, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "__cplusplus", + "source_location": { + "filename": "stb/stb_rect_pack.h", + "line": 77, + "column": 1, + "source_line": "#ifdef __cplusplus" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_rect_pack.h", + "line": 79, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "__cplusplus", + "source_location": { + "filename": "stb/stb_rect_pack.h", + "line": 194, + "column": 1, + "source_line": "#ifdef __cplusplus" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_rect_pack.h", + "line": 196, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_rect_pack.h", + "line": 198, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STB_RECT_PACK_IMPLEMENTATION", + "source_location": { + "filename": "stb/stb_rect_pack.h", + "line": 205, + "column": 1, + "source_line": "#ifdef STB_RECT_PACK_IMPLEMENTATION" + } + }, + { + "directive": "ifndef", + "argument": "STBRP_SORT", + "source_location": { + "filename": "stb/stb_rect_pack.h", + "line": 206, + "column": 1, + "source_line": "#ifndef STBRP_SORT" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_rect_pack.h", + "line": 209, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBRP_ASSERT", + "source_location": { + "filename": "stb/stb_rect_pack.h", + "line": 211, + "column": 1, + "source_line": "#ifndef STBRP_ASSERT" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_rect_pack.h", + "line": 214, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "_MSC_VER", + "source_location": { + "filename": "stb/stb_rect_pack.h", + "line": 216, + "column": 1, + "source_line": "#ifdef _MSC_VER" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_rect_pack.h", + "line": 219, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_rect_pack.h", + "line": 222, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "0", + "source_location": { + "filename": "stb/stb_rect_pack.h", + "line": 297, + "column": 4, + "source_line": " #if 0" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_rect_pack.h", + "line": 301, + "column": 4, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_rect_pack.h", + "line": 303, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "_DEBUG", + "source_location": { + "filename": "stb/stb_rect_pack.h", + "line": 497, + "column": 1, + "source_line": "#ifdef _DEBUG" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_rect_pack.h", + "line": 519, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_rect_pack.h", + "line": 581, + "column": 1, + "source_line": "#endif" + } + } + ], + "macro_dependencies": [ + { + "name": "STBRP_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_rect_pack.h", + "line": 229, + "column": 1, + "source_line": "STBRP_DEF void stbrp_setup_heuristic(stbrp_context *context, int heuristic)" + }, + "source_text": "STBRP_DEF void stbrp_setup_heuristic(stbrp_context *context, int heuristic)" + }, + { + "name": "STBRP_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_rect_pack.h", + "line": 241, + "column": 1, + "source_line": "STBRP_DEF void stbrp_setup_allow_out_of_mem(stbrp_context *context, int allow_out_of_mem)" + }, + "source_text": "STBRP_DEF void stbrp_setup_allow_out_of_mem(stbrp_context *context, int allow_out_of_mem)" + }, + { + "name": "STBRP_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_rect_pack.h", + "line": 261, + "column": 1, + "source_line": "STBRP_DEF void stbrp_init_target(stbrp_context *context, int width, int height, stbrp_node *nodes, int num_nodes)" + }, + "source_text": "STBRP_DEF void stbrp_init_target(stbrp_context *context, int width, int height, stbrp_node *nodes, int num_nodes)" + }, + { + "name": "STBRP_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_rect_pack.h", + "line": 542, + "column": 1, + "source_line": "STBRP_DEF int stbrp_pack_rects(stbrp_context *context, stbrp_rect *rects, int num_rects)" + }, + "source_text": "STBRP_DEF int stbrp_pack_rects(stbrp_context *context, stbrp_rect *rects, int num_rects)" + } + ], + "diagnostics": [ + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBRP__NOTUSED' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_rect_pack.h", + "line": 217, + "column": 1, + "source_line": "#define STBRP__NOTUSED(v) (void)(v)" + }, + "unit_kind": "macro", + "unit_name": "STBRP__NOTUSED" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBRP__NOTUSED' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_rect_pack.h", + "line": 220, + "column": 1, + "source_line": "#define STBRP__NOTUSED(v) (void)sizeof(v)" + }, + "unit_kind": "macro", + "unit_name": "STBRP__NOTUSED" + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '\"C\"'.", + "severity": "warning", + "location": { + "filename": "stb/stb_rect_pack.h", + "line": 78, + "column": 1, + "source_line": "extern \"C\" {" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBRP_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_rect_pack.h", + "line": 229, + "column": 1, + "source_line": "STBRP_DEF void stbrp_setup_heuristic(stbrp_context *context, int heuristic)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBRP_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBRP_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_rect_pack.h", + "line": 241, + "column": 1, + "source_line": "STBRP_DEF void stbrp_setup_allow_out_of_mem(stbrp_context *context, int allow_out_of_mem)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBRP_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBRP_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_rect_pack.h", + "line": 261, + "column": 1, + "source_line": "STBRP_DEF void stbrp_init_target(stbrp_context *context, int width, int height, stbrp_node *nodes, int num_nodes)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBRP_DEF" + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'rect_height_compare(const void *a, const void *b)'.", + "severity": "warning", + "location": { + "filename": "stb/stb_rect_pack.h", + "line": 524, + "column": 1, + "source_line": "static int STBRP__CDECL rect_height_compare(const void *a, const void *b)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'rect_original_order(const void *a, const void *b)'.", + "severity": "warning", + "location": { + "filename": "stb/stb_rect_pack.h", + "line": 535, + "column": 1, + "source_line": "static int STBRP__CDECL rect_original_order(const void *a, const void *b)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBRP_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_rect_pack.h", + "line": 542, + "column": 1, + "source_line": "STBRP_DEF int stbrp_pack_rects(stbrp_context *context, stbrp_rect *rects, int num_rects)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBRP_DEF" + } + ] + } + }, + "functions": { + "stbrp__skyline_find_min_y": { + "name": "stbrp__skyline_find_min_y", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "c", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbrp_context *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbrp_context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbrp_context *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbrp_context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "first", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbrp_node *first", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbrp_node" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbrp_node *first", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbrp_node" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "width", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "pwaste", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *pwaste", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *pwaste", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_rect_pack.h", + "line": 287, + "column": 1, + "source_line": "static int stbrp__skyline_find_min_y(stbrp_context *c, stbrp_node *first, int x0, int width, int *pwaste)" + }, + "start": { + "filename": "stb/stb_rect_pack.h", + "line": 287, + "column": 1, + "source_line": "static int stbrp__skyline_find_min_y(stbrp_context *c, stbrp_node *first, int x0, int width, int *pwaste)" + }, + "end": { + "filename": "stb/stb_rect_pack.h", + "line": 335, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbrp__skyline_find_best_pos": { + "name": "stbrp__skyline_find_best_pos", + "result_type": { + "reference": "stbrp__findresult" + }, + "parameters": [ + { + "name": "c", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbrp_context *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbrp_context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbrp_context *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbrp_context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "width", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "height", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int height" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int height" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_rect_pack.h", + "line": 343, + "column": 1, + "source_line": "static stbrp__findresult stbrp__skyline_find_best_pos(stbrp_context *c, int width, int height)" + }, + "start": { + "filename": "stb/stb_rect_pack.h", + "line": 343, + "column": 1, + "source_line": "static stbrp__findresult stbrp__skyline_find_best_pos(stbrp_context *c, int width, int height)" + }, + "end": { + "filename": "stb/stb_rect_pack.h", + "line": 443, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbrp__skyline_pack_rectangle": { + "name": "stbrp__skyline_pack_rectangle", + "result_type": { + "reference": "stbrp__findresult" + }, + "parameters": [ + { + "name": "context", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbrp_context *context", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbrp_context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbrp_context *context", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbrp_context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "width", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "height", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int height" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int height" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_rect_pack.h", + "line": 445, + "column": 1, + "source_line": "static stbrp__findresult stbrp__skyline_pack_rectangle(stbrp_context *context, int width, int height)" + }, + "start": { + "filename": "stb/stb_rect_pack.h", + "line": 445, + "column": 1, + "source_line": "static stbrp__findresult stbrp__skyline_pack_rectangle(stbrp_context *context, int width, int height)" + }, + "end": { + "filename": "stb/stb_rect_pack.h", + "line": 522, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + } + }, + "structs": {}, + "unions": {}, + "enums": {}, + "typedefs": { + "stbrp__findresult": { + "reference": "stbrp__findresult" + } + }, + "variables": {}, + "macros": { + "STB_INCLUDE_STB_RECT_PACK_H": { + "name": "STB_INCLUDE_STB_RECT_PACK_H", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_rect_pack.h", + "line": 67, + "column": 1, + "source_line": "#define STB_INCLUDE_STB_RECT_PACK_H" + } + }, + "STB_RECT_PACK_VERSION": { + "name": "STB_RECT_PACK_VERSION", + "value": "1", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_rect_pack.h", + "line": 69, + "column": 1, + "source_line": "#define STB_RECT_PACK_VERSION 1" + } + }, + "STBRP_DEF": { + "name": "STBRP_DEF", + "value": "extern", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_rect_pack.h", + "line": 74, + "column": 1, + "source_line": "#define STBRP_DEF extern" + } + }, + "STBRP__MAXVAL": { + "name": "STBRP__MAXVAL", + "value": "0x7fffffff", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_rect_pack.h", + "line": 87, + "column": 1, + "source_line": "#define STBRP__MAXVAL 0x7fffffff" + } + }, + "STBRP_SORT": { + "name": "STBRP_SORT", + "value": "qsort", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_rect_pack.h", + "line": 208, + "column": 1, + "source_line": "#define STBRP_SORT qsort" + } + }, + "STBRP_ASSERT": { + "name": "STBRP_ASSERT", + "value": "assert", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_rect_pack.h", + "line": 213, + "column": 1, + "source_line": "#define STBRP_ASSERT assert" + } + }, + "STBRP__NOTUSED": { + "name": "STBRP__NOTUSED", + "value": "(void)sizeof(v)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_rect_pack.h", + "line": 220, + "column": 1, + "source_line": "#define STBRP__NOTUSED(v) (void)sizeof(v)" + } + }, + "STBRP__CDECL": { + "name": "STBRP__CDECL", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_rect_pack.h", + "line": 221, + "column": 1, + "source_line": "#define STBRP__CDECL" + } + } + }, + "includes": { + "stb/stb_rect_pack.h:stdlib.h": { + "target": "stdlib.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_rect_pack.h", + "line": 207, + "column": 1, + "source_line": "#include " + } + }, + "stb/stb_rect_pack.h:assert.h": { + "target": "assert.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_rect_pack.h", + "line": 212, + "column": 1, + "source_line": "#include " + } + } + }, + "functions_by_file": { + "stb/stb_rect_pack.h": [ + "stbrp__skyline_find_min_y", + "stbrp__skyline_find_best_pos", + "stbrp__skyline_pack_rectangle" + ] + }, + "enum_constants": { + "STBRP__INIT_skyline": { + "name": "STBRP__INIT_skyline", + "value": "1", + "source_location": { + "filename": "stb/stb_rect_pack.h", + "line": 224, + "column": 1, + "source_line": "enum" + } + } + }, + "include_graph": { + "stb/stb_rect_pack.h": [] + }, + "system_includes": { + "stb/stb_rect_pack.h": [ + "assert.h", + "stdlib.h" + ] + }, + "unresolved_includes": { + "stb/stb_rect_pack.h": [] + }, + "header_source_pairs": { + "stb/stb_rect_pack.h": [] + }, + "diagnostics": [ + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBRP__NOTUSED' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_rect_pack.h", + "line": 217, + "column": 1, + "source_line": "#define STBRP__NOTUSED(v) (void)(v)" + }, + "unit_kind": "macro", + "unit_name": "STBRP__NOTUSED" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBRP__NOTUSED' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_rect_pack.h", + "line": 220, + "column": 1, + "source_line": "#define STBRP__NOTUSED(v) (void)sizeof(v)" + }, + "unit_kind": "macro", + "unit_name": "STBRP__NOTUSED" + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '\"C\"'.", + "severity": "warning", + "location": { + "filename": "stb/stb_rect_pack.h", + "line": 78, + "column": 1, + "source_line": "extern \"C\" {" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBRP_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_rect_pack.h", + "line": 229, + "column": 1, + "source_line": "STBRP_DEF void stbrp_setup_heuristic(stbrp_context *context, int heuristic)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBRP_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBRP_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_rect_pack.h", + "line": 241, + "column": 1, + "source_line": "STBRP_DEF void stbrp_setup_allow_out_of_mem(stbrp_context *context, int allow_out_of_mem)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBRP_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBRP_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_rect_pack.h", + "line": 261, + "column": 1, + "source_line": "STBRP_DEF void stbrp_init_target(stbrp_context *context, int width, int height, stbrp_node *nodes, int num_nodes)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBRP_DEF" + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'rect_height_compare(const void *a, const void *b)'.", + "severity": "warning", + "location": { + "filename": "stb/stb_rect_pack.h", + "line": 524, + "column": 1, + "source_line": "static int STBRP__CDECL rect_height_compare(const void *a, const void *b)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'rect_original_order(const void *a, const void *b)'.", + "severity": "warning", + "location": { + "filename": "stb/stb_rect_pack.h", + "line": 535, + "column": 1, + "source_line": "static int STBRP__CDECL rect_original_order(const void *a, const void *b)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBRP_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_rect_pack.h", + "line": 542, + "column": 1, + "source_line": "STBRP_DEF int stbrp_pack_rects(stbrp_context *context, stbrp_rect *rects, int num_rects)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBRP_DEF" + } + ] +} diff --git a/tests/parser/c/fixtures/stb/stb_sprintf.json b/tests/parser/c/fixtures/stb/stb_sprintf.json new file mode 100644 index 000000000..ee2a7f095 --- /dev/null +++ b/tests/parser/c/fixtures/stb/stb_sprintf.json @@ -0,0 +1,5164 @@ +{ + "files": { + "stb/stb_sprintf.h": { + "filename": "stb/stb_sprintf.h", + "language": "c", + "parser_status": "partial", + "preprocessing": "raw", + "functions": [ + { + "name": "stbsp__lead_sign", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "fl", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbsp__uint32 fl", + "name": "stbsp__uint32", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "declared_type": { + "reference": "stbsp__uint32" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "sign", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *sign", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *sign", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 294, + "column": 1, + "source_line": "static void stbsp__lead_sign(stbsp__uint32 fl, char *sign)" + }, + "start": { + "filename": "stb/stb_sprintf.h", + "line": 294, + "column": 1, + "source_line": "static void stbsp__lead_sign(stbsp__uint32 fl, char *sign)" + }, + "end": { + "filename": "stb/stb_sprintf.h", + "line": 307, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbsp__clamp_callback", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "parameters": [ + { + "name": "buf", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *buf", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *buf", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "user", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *user", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *user", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1393, + "column": 1, + "source_line": "static char *stbsp__clamp_callback(const char *buf, void *user, int len)" + }, + "start": { + "filename": "stb/stb_sprintf.h", + "line": 1393, + "column": 1, + "source_line": "static char *stbsp__clamp_callback(const char *buf, void *user, int len)" + }, + "end": { + "filename": "stb/stb_sprintf.h", + "line": 1419, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbsp__count_clamp_callback", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "parameters": [ + { + "name": "buf", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * buf", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * buf", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "user", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1421, + "column": 1, + "source_line": "static char * stbsp__count_clamp_callback( const char * buf, void * user, int len )" + }, + "start": { + "filename": "stb/stb_sprintf.h", + "line": 1421, + "column": 1, + "source_line": "static char * stbsp__count_clamp_callback( const char * buf, void * user, int len )" + }, + "end": { + "filename": "stb/stb_sprintf.h", + "line": 1428, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbsp__raise_to_power10", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "ohi", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "double *ohi", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "double *ohi", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "olo", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "double *olo", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "double *olo", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "d", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double d" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double d" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "power", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbsp__int32 power", + "name": "stbsp__int32", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "declared_type": { + "reference": "stbsp__int32" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1638, + "column": 1, + "source_line": "static void stbsp__raise_to_power10(double *ohi, double *olo, double d, stbsp__int32 power) // power can be -323 to +350" + }, + "start": { + "filename": "stb/stb_sprintf.h", + "line": 1638, + "column": 1, + "source_line": "static void stbsp__raise_to_power10(double *ohi, double *olo, double d, stbsp__int32 power) // power can be -323 to +350" + }, + "end": { + "filename": "stb/stb_sprintf.h", + "line": 1699, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + } + ], + "structs": [ + { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "temp", + "type": { + "model": "CShort", + "qualifiers": [], + "source_text": "short temp" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 263, + "column": 4, + "source_line": " short temp; // force next field to be 2-byte aligned" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "pair", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char pair[201]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "201", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 264, + "column": 4, + "source_line": " char pair[201];" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_sprintf.h:261:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 261, + "column": 1, + "source_line": "static struct" + } + }, + { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": "stbsp__context", + "members": [ + { + "name": "buf", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *buf", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1387, + "column": 4, + "source_line": " char *buf;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "count", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int count" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1388, + "column": 4, + "source_line": " int count;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "length", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int length" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1389, + "column": 4, + "source_line": " int length;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "tmp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char tmp[STB_SPRINTF_MIN]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STB_SPRINTF_MIN", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1390, + "column": 4, + "source_line": " char tmp[STB_SPRINTF_MIN];" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": null, + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1386, + "column": 1, + "source_line": "typedef struct stbsp__context {" + } + } + ], + "unions": [], + "enums": [], + "typedefs": [ + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "STBSP_SPRINTFCB", + "name": "STBSP_SPRINTFCB", + "type": { + "model": "CFunctionType", + "qualifiers": [], + "source_text": "typedef char *STBSP_SPRINTFCB(const char *buf, void *user, int len)", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "parameter_types": [ + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *buf", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *user", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + } + ], + "is_variadic": false, + "prototype_style": "prototype" + }, + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 202, + "column": 1, + "source_line": "typedef char *STBSP_SPRINTFCB(const char *buf, void *user, int len);" + }, + "declaration_locations": [] + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbsp__context", + "name": "stbsp__context", + "type": { + "reference": "struct stbsp__context" + }, + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1386, + "column": 1, + "source_line": "typedef struct stbsp__context {" + }, + "declaration_locations": [] + } + ], + "variables": [ + { + "name": "stbsp__period", + "type": { + "model": "CChar", + "qualifiers": [], + "source_text": "static char stbsp__period" + }, + "storage": [ + "static" + ], + "initializer": { + "source_text": "'.'" + }, + "bit_width": null, + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 259, + "column": 1, + "source_line": "static char stbsp__period = '.';" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "stbsp__comma", + "type": { + "model": "CChar", + "qualifiers": [], + "source_text": "static char stbsp__comma" + }, + "storage": [ + "static" + ], + "initializer": { + "source_text": "','" + }, + "bit_width": null, + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 260, + "column": 1, + "source_line": "static char stbsp__comma = ',';" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "stbsp__digitpair", + "type": { + "reference": "struct@stb/stb_sprintf.h:261:1" + }, + "storage": [ + "static" + ], + "initializer": { + "source_text": "" + }, + "bit_width": null, + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 261, + "column": 1, + "source_line": "static struct" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "macros": [ + { + "name": "STB_SPRINTF_H_INCLUDE", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 30, + "column": 1, + "source_line": "#define STB_SPRINTF_H_INCLUDE" + } + }, + { + "name": "STBSP__ASAN", + "value": "__attribute__((__no_sanitize__(\"address\")))", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 149, + "column": 5, + "source_line": " #define STBSP__ASAN __attribute__((__no_sanitize__(\"address\")))" + } + }, + { + "name": "STBSP__ASAN", + "value": "__attribute__((__no_sanitize_address__))", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 151, + "column": 5, + "source_line": " #define STBSP__ASAN __attribute__((__no_sanitize_address__))" + } + }, + { + "name": "STBSP__ASAN", + "value": "__attribute__((__no_address_safety_analysis__))", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 153, + "column": 5, + "source_line": " #define STBSP__ASAN __attribute__((__no_address_safety_analysis__))" + } + }, + { + "name": "STBSP__ASAN", + "value": "__attribute__((__no_sanitize_address__))", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 159, + "column": 3, + "source_line": " #define STBSP__ASAN __attribute__((__no_sanitize_address__))" + } + }, + { + "name": "STBSP__ASAN", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 164, + "column": 1, + "source_line": "#define STBSP__ASAN" + } + }, + { + "name": "STBSP__PUBLICDEC", + "value": "static", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 168, + "column": 1, + "source_line": "#define STBSP__PUBLICDEC static" + } + }, + { + "name": "STBSP__PUBLICDEF", + "value": "static STBSP__ASAN", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 169, + "column": 1, + "source_line": "#define STBSP__PUBLICDEF static STBSP__ASAN" + } + }, + { + "name": "STBSP__PUBLICDEC", + "value": "extern \"C\"", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 172, + "column": 1, + "source_line": "#define STBSP__PUBLICDEC extern \"C\"" + } + }, + { + "name": "STBSP__PUBLICDEF", + "value": "extern \"C\" STBSP__ASAN", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 173, + "column": 1, + "source_line": "#define STBSP__PUBLICDEF extern \"C\" STBSP__ASAN" + } + }, + { + "name": "STBSP__PUBLICDEC", + "value": "extern", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 175, + "column": 1, + "source_line": "#define STBSP__PUBLICDEC extern" + } + }, + { + "name": "STBSP__PUBLICDEF", + "value": "STBSP__ASAN", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 176, + "column": 1, + "source_line": "#define STBSP__PUBLICDEF STBSP__ASAN" + } + }, + { + "name": "STBSP__ATTRIBUTE_FORMAT", + "value": "__attribute__((format(printf,fmt,va)))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 182, + "column": 4, + "source_line": " #define STBSP__ATTRIBUTE_FORMAT(fmt,va) __attribute__((format(printf,fmt,va)))" + } + }, + { + "name": "STBSP__ATTRIBUTE_FORMAT", + "value": null, + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 187, + "column": 1, + "source_line": "#define STBSP__ATTRIBUTE_FORMAT(fmt,va)" + } + }, + { + "name": "STBSP__NOTUSED", + "value": "(void)(v)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 191, + "column": 1, + "source_line": "#define STBSP__NOTUSED(v) (void)(v)" + } + }, + { + "name": "STBSP__NOTUSED", + "value": "(void)sizeof(v)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 193, + "column": 1, + "source_line": "#define STBSP__NOTUSED(v) (void)sizeof(v)" + } + }, + { + "name": "STB_SPRINTF_MIN", + "value": "512", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 200, + "column": 1, + "source_line": "#define STB_SPRINTF_MIN 512 // how many characters per callback" + } + }, + { + "name": "STB_SPRINTF_DECORATE", + "value": "stbsp_##name", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 205, + "column": 1, + "source_line": "#define STB_SPRINTF_DECORATE(name) stbsp_##name // define this before including if you want to change the names" + } + }, + { + "name": "stbsp__uint32", + "value": "unsigned int", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 220, + "column": 1, + "source_line": "#define stbsp__uint32 unsigned int" + } + }, + { + "name": "stbsp__int32", + "value": "signed int", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 221, + "column": 1, + "source_line": "#define stbsp__int32 signed int" + } + }, + { + "name": "stbsp__uint64", + "value": "unsigned __int64", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 224, + "column": 1, + "source_line": "#define stbsp__uint64 unsigned __int64" + } + }, + { + "name": "stbsp__int64", + "value": "signed __int64", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 225, + "column": 1, + "source_line": "#define stbsp__int64 signed __int64" + } + }, + { + "name": "stbsp__uint64", + "value": "unsigned long long", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 227, + "column": 1, + "source_line": "#define stbsp__uint64 unsigned long long" + } + }, + { + "name": "stbsp__int64", + "value": "signed long long", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 228, + "column": 1, + "source_line": "#define stbsp__int64 signed long long" + } + }, + { + "name": "stbsp__uint16", + "value": "unsigned short", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 230, + "column": 1, + "source_line": "#define stbsp__uint16 unsigned short" + } + }, + { + "name": "stbsp__uintptr", + "value": "stbsp__uint64", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 234, + "column": 1, + "source_line": "#define stbsp__uintptr stbsp__uint64" + } + }, + { + "name": "stbsp__uintptr", + "value": "stbsp__uint32", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 236, + "column": 1, + "source_line": "#define stbsp__uintptr stbsp__uint32" + } + }, + { + "name": "STB_SPRINTF_MSVC_MODE", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 242, + "column": 1, + "source_line": "#define STB_SPRINTF_MSVC_MODE" + } + }, + { + "name": "STBSP__UNALIGNED", + "value": null, + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 247, + "column": 1, + "source_line": "#define STBSP__UNALIGNED(code)" + } + }, + { + "name": "STBSP__UNALIGNED", + "value": "code", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 249, + "column": 1, + "source_line": "#define STBSP__UNALIGNED(code) code" + } + }, + { + "name": "STBSP__SPECIAL", + "value": "0x7000", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 256, + "column": 1, + "source_line": "#define STBSP__SPECIAL 0x7000" + } + }, + { + "name": "STBSP__LEFTJUST", + "value": "1", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 280, + "column": 1, + "source_line": "#define STBSP__LEFTJUST 1" + } + }, + { + "name": "STBSP__LEADINGPLUS", + "value": "2", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 281, + "column": 1, + "source_line": "#define STBSP__LEADINGPLUS 2" + } + }, + { + "name": "STBSP__LEADINGSPACE", + "value": "4", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 282, + "column": 1, + "source_line": "#define STBSP__LEADINGSPACE 4" + } + }, + { + "name": "STBSP__LEADING_0X", + "value": "8", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 283, + "column": 1, + "source_line": "#define STBSP__LEADING_0X 8" + } + }, + { + "name": "STBSP__LEADINGZERO", + "value": "16", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 284, + "column": 1, + "source_line": "#define STBSP__LEADINGZERO 16" + } + }, + { + "name": "STBSP__INTMAX", + "value": "32", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 285, + "column": 1, + "source_line": "#define STBSP__INTMAX 32" + } + }, + { + "name": "STBSP__TRIPLET_COMMA", + "value": "64", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 286, + "column": 1, + "source_line": "#define STBSP__TRIPLET_COMMA 64" + } + }, + { + "name": "STBSP__NEGATIVE", + "value": "128", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 287, + "column": 1, + "source_line": "#define STBSP__NEGATIVE 128" + } + }, + { + "name": "STBSP__METRIC_SUFFIX", + "value": "256", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 288, + "column": 1, + "source_line": "#define STBSP__METRIC_SUFFIX 256" + } + }, + { + "name": "STBSP__HALFWIDTH", + "value": "512", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 289, + "column": 1, + "source_line": "#define STBSP__HALFWIDTH 512" + } + }, + { + "name": "STBSP__METRIC_NOSPACE", + "value": "1024", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 290, + "column": 1, + "source_line": "#define STBSP__METRIC_NOSPACE 1024" + } + }, + { + "name": "STBSP__METRIC_1024", + "value": "2048", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 291, + "column": 1, + "source_line": "#define STBSP__METRIC_1024 2048" + } + }, + { + "name": "STBSP__METRIC_JEDEC", + "value": "4096", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 292, + "column": 1, + "source_line": "#define STBSP__METRIC_JEDEC 4096" + } + }, + { + "name": "stbsp__chk_cb_bufL", + "value": "{ int len = (int)(bf - buf); if ((len + (bytes)) >= STB_SPRINTF_MIN) { tlen += len; if (0 == (bf = buf = callback(buf, user, len))) goto done; } }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 364, + "column": 7, + "source_line": " #define stbsp__chk_cb_bufL(bytes) \\" + } + }, + { + "name": "stbsp__chk_cb_buf", + "value": "{ if (callback) { stbsp__chk_cb_bufL(bytes); } }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 373, + "column": 7, + "source_line": " #define stbsp__chk_cb_buf(bytes) \\" + } + }, + { + "name": "stbsp__flush_cb", + "value": "{ stbsp__chk_cb_bufL(STB_SPRINTF_MIN - 1); }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 379, + "column": 7, + "source_line": " #define stbsp__flush_cb() \\" + } + }, + { + "name": "stbsp__cb_buf_clamp", + "value": "cl = v; if (callback) { int lg = STB_SPRINTF_MIN - (int)(bf - buf); if (cl > lg) cl = lg; }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 383, + "column": 7, + "source_line": " #define stbsp__cb_buf_clamp(cl, v) \\" + } + }, + { + "name": "STBSP__NUMSZ", + "value": "512", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 573, + "column": 10, + "source_line": " #define STBSP__NUMSZ 512 // big enough for e308 (with commas) or e-307" + } + }, + { + "name": "STBSP__LEFTJUST", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1358, + "column": 1, + "source_line": "#undef STBSP__LEFTJUST" + } + }, + { + "name": "STBSP__LEADINGPLUS", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1359, + "column": 1, + "source_line": "#undef STBSP__LEADINGPLUS" + } + }, + { + "name": "STBSP__LEADINGSPACE", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1360, + "column": 1, + "source_line": "#undef STBSP__LEADINGSPACE" + } + }, + { + "name": "STBSP__LEADING_0X", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1361, + "column": 1, + "source_line": "#undef STBSP__LEADING_0X" + } + }, + { + "name": "STBSP__LEADINGZERO", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1362, + "column": 1, + "source_line": "#undef STBSP__LEADINGZERO" + } + }, + { + "name": "STBSP__INTMAX", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1363, + "column": 1, + "source_line": "#undef STBSP__INTMAX" + } + }, + { + "name": "STBSP__TRIPLET_COMMA", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1364, + "column": 1, + "source_line": "#undef STBSP__TRIPLET_COMMA" + } + }, + { + "name": "STBSP__NEGATIVE", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1365, + "column": 1, + "source_line": "#undef STBSP__NEGATIVE" + } + }, + { + "name": "STBSP__METRIC_SUFFIX", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1366, + "column": 1, + "source_line": "#undef STBSP__METRIC_SUFFIX" + } + }, + { + "name": "STBSP__NUMSZ", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1367, + "column": 1, + "source_line": "#undef STBSP__NUMSZ" + } + }, + { + "name": "stbsp__chk_cb_bufL", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1368, + "column": 1, + "source_line": "#undef stbsp__chk_cb_bufL" + } + }, + { + "name": "stbsp__chk_cb_buf", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1369, + "column": 1, + "source_line": "#undef stbsp__chk_cb_buf" + } + }, + { + "name": "stbsp__flush_cb", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1370, + "column": 1, + "source_line": "#undef stbsp__flush_cb" + } + }, + { + "name": "stbsp__cb_buf_clamp", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1371, + "column": 1, + "source_line": "#undef stbsp__cb_buf_clamp" + } + }, + { + "name": "STBSP__COPYFP", + "value": "{ int cn; for (cn = 0; cn < 8; cn++) ((char *)&dest)[cn] = ((char *)&src)[cn]; }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1483, + "column": 1, + "source_line": "#define STBSP__COPYFP(dest, src) \\" + } + }, + { + "name": "stbsp__tento19th", + "value": "((stbsp__uint64)1000000000000000000)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1572, + "column": 1, + "source_line": "#define stbsp__tento19th ((stbsp__uint64)1000000000000000000)" + } + }, + { + "name": "stbsp__tento19th", + "value": "(1000000000000000000ULL)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1596, + "column": 1, + "source_line": "#define stbsp__tento19th (1000000000000000000ULL)" + } + }, + { + "name": "stbsp__ddmulthi", + "value": "{ double ahi = 0, alo, bhi = 0, blo; stbsp__int64 bt; oh = xh * yh; STBSP__COPYFP(bt, xh); bt &= ((~(stbsp__uint64)0) << 27); STBSP__COPYFP(ahi, bt); alo = xh - ahi; STBSP__COPYFP(bt, yh); bt &= ((~(stbsp__uint64)0) << 27); STBSP__COPYFP(bhi, bt); blo = yh - bhi; ol = ((ahi * bhi - oh) + ahi * blo + alo * bhi) + alo * blo; }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1599, + "column": 1, + "source_line": "#define stbsp__ddmulthi(oh, ol, xh, yh) \\" + } + }, + { + "name": "stbsp__ddtoS64", + "value": "{ double ahi = 0, alo, vh, t; ob = (stbsp__int64)xh; vh = (double)ob; ahi = (xh - vh); t = (ahi - xh); alo = (xh - (ahi - t)) - (vh + t); ob += (stbsp__int64)(ahi + alo + xl); }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1615, + "column": 1, + "source_line": "#define stbsp__ddtoS64(ob, xh, xl) \\" + } + }, + { + "name": "stbsp__ddrenorm", + "value": "{ double s; s = oh + ol; ol = ol - (s - oh); oh = s; }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1626, + "column": 1, + "source_line": "#define stbsp__ddrenorm(oh, ol) \\" + } + }, + { + "name": "stbsp__ddmultlo", + "value": "ol = ol + (xh * yl + xl * yh);", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1634, + "column": 1, + "source_line": "#define stbsp__ddmultlo(oh, ol, xh, xl, yh, yl) ol = ol + (xh * yl + xl * yh);" + } + }, + { + "name": "stbsp__ddmultlos", + "value": "ol = ol + (xh * yl);", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1636, + "column": 1, + "source_line": "#define stbsp__ddmultlos(oh, ol, xh, yl) ol = ol + (xh * yl);" + } + }, + { + "name": "stbsp__ddmulthi", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1847, + "column": 1, + "source_line": "#undef stbsp__ddmulthi" + } + }, + { + "name": "stbsp__ddrenorm", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1848, + "column": 1, + "source_line": "#undef stbsp__ddrenorm" + } + }, + { + "name": "stbsp__ddmultlo", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1849, + "column": 1, + "source_line": "#undef stbsp__ddmultlo" + } + }, + { + "name": "stbsp__ddmultlos", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1850, + "column": 1, + "source_line": "#undef stbsp__ddmultlos" + } + }, + { + "name": "STBSP__SPECIAL", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1851, + "column": 1, + "source_line": "#undef STBSP__SPECIAL" + } + }, + { + "name": "STBSP__COPYFP", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1852, + "column": 1, + "source_line": "#undef STBSP__COPYFP" + } + }, + { + "name": "stbsp__uint16", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1857, + "column": 1, + "source_line": "#undef stbsp__uint16" + } + }, + { + "name": "stbsp__uint32", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1858, + "column": 1, + "source_line": "#undef stbsp__uint32" + } + }, + { + "name": "stbsp__int32", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1859, + "column": 1, + "source_line": "#undef stbsp__int32" + } + }, + { + "name": "stbsp__uint64", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1860, + "column": 1, + "source_line": "#undef stbsp__uint64" + } + }, + { + "name": "stbsp__int64", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1861, + "column": 1, + "source_line": "#undef stbsp__int64" + } + }, + { + "name": "STBSP__UNALIGNED", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1862, + "column": 1, + "source_line": "#undef STBSP__UNALIGNED" + } + } + ], + "includes": [ + { + "target": "stdarg.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 196, + "column": 1, + "source_line": "#include // for va_arg(), va_list()" + } + }, + { + "target": "stddef.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 197, + "column": 1, + "source_line": "#include // size_t, ptrdiff_t" + } + } + ], + "raw_directives": [ + { + "directive": "ifndef", + "argument": "STB_SPRINTF_H_INCLUDE", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 29, + "column": 1, + "source_line": "#ifndef STB_SPRINTF_H_INCLUDE" + } + }, + { + "directive": "if", + "argument": "defined(__clang__)", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 145, + "column": 1, + "source_line": "#if defined(__clang__)" + } + }, + { + "directive": "if", + "argument": "defined(__has_feature) && defined(__has_attribute)", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 146, + "column": 2, + "source_line": " #if defined(__has_feature) && defined(__has_attribute)" + } + }, + { + "directive": "if", + "argument": "__has_feature(address_sanitizer)", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 147, + "column": 3, + "source_line": " #if __has_feature(address_sanitizer)" + } + }, + { + "directive": "if", + "argument": "__has_attribute(__no_sanitize__)", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 148, + "column": 4, + "source_line": " #if __has_attribute(__no_sanitize__)" + } + }, + { + "directive": "elif", + "argument": "__has_attribute(__no_sanitize_address__)", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 150, + "column": 4, + "source_line": " #elif __has_attribute(__no_sanitize_address__)" + } + }, + { + "directive": "elif", + "argument": "__has_attribute(__no_address_safety_analysis__)", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 152, + "column": 4, + "source_line": " #elif __has_attribute(__no_address_safety_analysis__)" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 154, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 155, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 156, + "column": 2, + "source_line": " #endif" + } + }, + { + "directive": "elif", + "argument": "defined(__GNUC__) && (__GNUC__ >= 5 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8))", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 157, + "column": 1, + "source_line": "#elif defined(__GNUC__) && (__GNUC__ >= 5 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8))" + } + }, + { + "directive": "if", + "argument": "defined(__SANITIZE_ADDRESS__) && __SANITIZE_ADDRESS__", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 158, + "column": 2, + "source_line": " #if defined(__SANITIZE_ADDRESS__) && __SANITIZE_ADDRESS__" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 160, + "column": 2, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 161, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBSP__ASAN", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 163, + "column": 1, + "source_line": "#ifndef STBSP__ASAN" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 165, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STB_SPRINTF_STATIC", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 167, + "column": 1, + "source_line": "#ifdef STB_SPRINTF_STATIC" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 170, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "ifdef", + "argument": "__cplusplus", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 171, + "column": 1, + "source_line": "#ifdef __cplusplus" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 174, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 177, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 178, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "defined(__has_attribute)", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 180, + "column": 1, + "source_line": "#if defined(__has_attribute)" + } + }, + { + "directive": "if", + "argument": "__has_attribute(format)", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 181, + "column": 2, + "source_line": " #if __has_attribute(format)" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 183, + "column": 2, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 184, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBSP__ATTRIBUTE_FORMAT", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 186, + "column": 1, + "source_line": "#ifndef STBSP__ATTRIBUTE_FORMAT" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 188, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "_MSC_VER", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 190, + "column": 1, + "source_line": "#ifdef _MSC_VER" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 192, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 194, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_SPRINTF_MIN", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 199, + "column": 1, + "source_line": "#ifndef STB_SPRINTF_MIN" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 201, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_SPRINTF_DECORATE", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 204, + "column": 1, + "source_line": "#ifndef STB_SPRINTF_DECORATE" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 206, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 216, + "column": 1, + "source_line": "#endif // STB_SPRINTF_H_INCLUDE" + } + }, + { + "directive": "ifdef", + "argument": "STB_SPRINTF_IMPLEMENTATION", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 218, + "column": 1, + "source_line": "#ifdef STB_SPRINTF_IMPLEMENTATION" + } + }, + { + "directive": "ifdef", + "argument": "_MSC_VER", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 223, + "column": 1, + "source_line": "#ifdef _MSC_VER" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 226, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 229, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "stbsp__uintptr", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 232, + "column": 1, + "source_line": "#ifndef stbsp__uintptr" + } + }, + { + "directive": "if", + "argument": "defined(__ppc64__) || defined(__powerpc64__) || defined(__aarch64__) || defined(_M_X64) || defined(__x86_64__) || defined(__x86_64) || defined(__s390x__)", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 233, + "column": 1, + "source_line": "#if defined(__ppc64__) || defined(__powerpc64__) || defined(__aarch64__) || defined(_M_X64) || defined(__x86_64__) || defined(__x86_64) || defined(__s390x__)" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 235, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 237, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 238, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_SPRINTF_MSVC_MODE", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 240, + "column": 1, + "source_line": "#ifndef STB_SPRINTF_MSVC_MODE // used for MSVC2013 and earlier (MSVC2015 matches GCC)" + } + }, + { + "directive": "if", + "argument": "defined(_MSC_VER) && (_MSC_VER < 1900)", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 241, + "column": 1, + "source_line": "#if defined(_MSC_VER) && (_MSC_VER < 1900)" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 243, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 244, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STB_SPRINTF_NOUNALIGNED", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 246, + "column": 1, + "source_line": "#ifdef STB_SPRINTF_NOUNALIGNED // define this before inclusion to force stbsp_sprintf to always use aligned accesses" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 248, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 250, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_SPRINTF_NOFLOAT", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 252, + "column": 1, + "source_line": "#ifndef STB_SPRINTF_NOFLOAT" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 257, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STB_SPRINTF_NOUNALIGNED", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 418, + "column": 13, + "source_line": " #ifdef STB_SPRINTF_NOUNALIGNED" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 425, + "column": 13, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_SPRINTF_NOFLOAT", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 581, + "column": 1, + "source_line": "#ifndef STB_SPRINTF_NOFLOAT" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 583, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STB_SPRINTF_NOFLOAT", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 621, + "column": 1, + "source_line": "#ifdef STB_SPRINTF_NOFLOAT" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 638, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "ifdef", + "argument": "STB_SPRINTF_MSVC_MODE", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 662, + "column": 1, + "source_line": "#ifdef STB_SPRINTF_MSVC_MODE" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 665, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 669, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STB_SPRINTF_MSVC_MODE", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 789, + "column": 1, + "source_line": "#ifdef STB_SPRINTF_MSVC_MODE" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 791, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 793, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 976, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_SPRINTF_NOFLOAT", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1076, + "column": 1, + "source_line": "#ifndef STB_SPRINTF_NOFLOAT" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1085, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_SPRINTF_NOFLOAT", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1480, + "column": 1, + "source_line": "#ifndef STB_SPRINTF_NOFLOAT" + } + }, + { + "directive": "if", + "argument": "defined(_MSC_VER) && (_MSC_VER <= 1200)", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1549, + "column": 1, + "source_line": "#if defined(_MSC_VER) && (_MSC_VER <= 1200)" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1573, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1597, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1854, + "column": 1, + "source_line": "#endif // STB_SPRINTF_NOFLOAT" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1864, + "column": 1, + "source_line": "#endif // STB_SPRINTF_IMPLEMENTATION" + } + } + ], + "macro_dependencies": [ + { + "name": "STB_SPRINTF_DECORATE", + "context": "declaration", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 208, + "column": 1, + "source_line": "STBSP__PUBLICDEC int STB_SPRINTF_DECORATE(vsprintf)(char *buf, char const *fmt, va_list va);" + }, + "source_text": "STBSP__PUBLICDEC int STB_SPRINTF_DECORATE(vsprintf)(char *buf, char const *fmt, va_list va)" + }, + { + "name": "STB_SPRINTF_DECORATE", + "context": "declaration", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 209, + "column": 1, + "source_line": "STBSP__PUBLICDEC int STB_SPRINTF_DECORATE(vsnprintf)(char *buf, int count, char const *fmt, va_list va);" + }, + "source_text": "STBSP__PUBLICDEC int STB_SPRINTF_DECORATE(vsnprintf)(char *buf, int count, char const *fmt, va_list va)" + }, + { + "name": "STBSP__ATTRIBUTE_FORMAT", + "context": "declaration", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 210, + "column": 1, + "source_line": "STBSP__PUBLICDEC int STB_SPRINTF_DECORATE(sprintf)(char *buf, char const *fmt, ...) STBSP__ATTRIBUTE_FORMAT(2,3);" + }, + "source_text": "STBSP__PUBLICDEC int STB_SPRINTF_DECORATE(sprintf)(char *buf, char const *fmt, ...) STBSP__ATTRIBUTE_FORMAT(2,3)" + }, + { + "name": "STBSP__ATTRIBUTE_FORMAT", + "context": "declaration", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 211, + "column": 1, + "source_line": "STBSP__PUBLICDEC int STB_SPRINTF_DECORATE(snprintf)(char *buf, int count, char const *fmt, ...) STBSP__ATTRIBUTE_FORMAT(3,4);" + }, + "source_text": "STBSP__PUBLICDEC int STB_SPRINTF_DECORATE(snprintf)(char *buf, int count, char const *fmt, ...) STBSP__ATTRIBUTE_FORMAT(3,4)" + }, + { + "name": "STB_SPRINTF_DECORATE", + "context": "declaration", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 213, + "column": 1, + "source_line": "STBSP__PUBLICDEC int STB_SPRINTF_DECORATE(vsprintfcb)(STBSP_SPRINTFCB *callback, void *user, char *buf, char const *fmt, va_list va);" + }, + "source_text": "STBSP__PUBLICDEC int STB_SPRINTF_DECORATE(vsprintfcb)(STBSP_SPRINTFCB *callback, void *user, char *buf, char const *fmt, va_list va)" + }, + { + "name": "STB_SPRINTF_DECORATE", + "context": "declaration", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 214, + "column": 1, + "source_line": "STBSP__PUBLICDEC void STB_SPRINTF_DECORATE(set_separators)(char comma, char period);" + }, + "source_text": "STBSP__PUBLICDEC void STB_SPRINTF_DECORATE(set_separators)(char comma, char period)" + }, + { + "name": "stbsp__int32", + "context": "declaration", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 254, + "column": 1, + "source_line": "static stbsp__int32 stbsp__real_to_str(char const **start, stbsp__uint32 *len, char *out, stbsp__int32 *decimal_pos, double value, stbsp__uint32 frac_digits);" + }, + "source_text": "static stbsp__int32 stbsp__real_to_str(char const **start, stbsp__uint32 *len, char *out, stbsp__int32 *decimal_pos, double value, stbsp__uint32 frac_digits)" + }, + { + "name": "stbsp__int32", + "context": "declaration", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 255, + "column": 1, + "source_line": "static stbsp__int32 stbsp__real_to_parts(stbsp__int64 *bits, stbsp__int32 *expo, double value);" + }, + "source_text": "static stbsp__int32 stbsp__real_to_parts(stbsp__int64 *bits, stbsp__int32 *expo, double value)" + }, + { + "name": "STB_SPRINTF_DECORATE", + "context": "declaration", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 274, + "column": 1, + "source_line": "STBSP__PUBLICDEF void STB_SPRINTF_DECORATE(set_separators)(char pcomma, char pperiod)" + }, + "source_text": "STBSP__PUBLICDEF void STB_SPRINTF_DECORATE(set_separators)(char pcomma, char pperiod)" + }, + { + "name": "STBSP__ASAN", + "context": "declaration", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 309, + "column": 1, + "source_line": "static STBSP__ASAN stbsp__uint32 stbsp__strlen_limited(char const *s, stbsp__uint32 limit)" + }, + "source_text": "static STBSP__ASAN stbsp__uint32 stbsp__strlen_limited(char const *s, stbsp__uint32 limit)" + }, + { + "name": "STB_SPRINTF_DECORATE", + "context": "declaration", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 349, + "column": 1, + "source_line": "STBSP__PUBLICDEF int STB_SPRINTF_DECORATE(vsprintfcb)(STBSP_SPRINTFCB *callback, void *user, char *buf, char const *fmt, va_list va)" + }, + "source_text": "STBSP__PUBLICDEF int STB_SPRINTF_DECORATE(vsprintfcb)(STBSP_SPRINTFCB *callback, void *user, char *buf, char const *fmt, va_list va)" + }, + { + "name": "STB_SPRINTF_DECORATE", + "context": "declaration", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1376, + "column": 1, + "source_line": "STBSP__PUBLICDEF int STB_SPRINTF_DECORATE(sprintf)(char *buf, char const *fmt, ...)" + }, + "source_text": "STBSP__PUBLICDEF int STB_SPRINTF_DECORATE(sprintf)(char *buf, char const *fmt, ...)" + }, + { + "name": "STB_SPRINTF_DECORATE", + "context": "declaration", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1430, + "column": 1, + "source_line": "STBSP__PUBLICDEF int STB_SPRINTF_DECORATE( vsnprintf )( char * buf, int count, char const * fmt, va_list va )" + }, + "source_text": "STBSP__PUBLICDEF int STB_SPRINTF_DECORATE( vsnprintf )( char * buf, int count, char const * fmt, va_list va )" + }, + { + "name": "STB_SPRINTF_DECORATE", + "context": "declaration", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1460, + "column": 1, + "source_line": "STBSP__PUBLICDEF int STB_SPRINTF_DECORATE(snprintf)(char *buf, int count, char const *fmt, ...)" + }, + "source_text": "STBSP__PUBLICDEF int STB_SPRINTF_DECORATE(snprintf)(char *buf, int count, char const *fmt, ...)" + }, + { + "name": "STB_SPRINTF_DECORATE", + "context": "declaration", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1472, + "column": 1, + "source_line": "STBSP__PUBLICDEF int STB_SPRINTF_DECORATE(vsprintf)(char *buf, char const *fmt, va_list va)" + }, + "source_text": "STBSP__PUBLICDEF int STB_SPRINTF_DECORATE(vsprintf)(char *buf, char const *fmt, va_list va)" + }, + { + "name": "stbsp__int32", + "context": "declaration", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1491, + "column": 1, + "source_line": "static stbsp__int32 stbsp__real_to_parts(stbsp__int64 *bits, stbsp__int32 *expo, double value)" + }, + "source_text": "static stbsp__int32 stbsp__real_to_parts(stbsp__int64 *bits, stbsp__int32 *expo, double value)" + }, + { + "name": "stbsp__uint64", + "context": "declaration", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1550, + "column": 1, + "source_line": "static stbsp__uint64 const stbsp__powten[20] = {" + }, + "source_text": "static stbsp__uint64 const stbsp__powten[20] =" + }, + { + "name": "stbsp__uint64", + "context": "declaration", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1574, + "column": 1, + "source_line": "static stbsp__uint64 const stbsp__powten[20] = {" + }, + "source_text": "static stbsp__uint64 const stbsp__powten[20] =" + }, + { + "name": "stbsp__int32", + "context": "declaration", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1705, + "column": 1, + "source_line": "static stbsp__int32 stbsp__real_to_str(char const **start, stbsp__uint32 *len, char *out, stbsp__int32 *decimal_pos, double value, stbsp__uint32 frac_digits)" + }, + "source_text": "static stbsp__int32 stbsp__real_to_str(char const **start, stbsp__uint32 *len, char *out, stbsp__int32 *decimal_pos, double value, stbsp__uint32 frac_digits)" + } + ], + "diagnostics": [ + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBSP__ATTRIBUTE_FORMAT' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 182, + "column": 4, + "source_line": " #define STBSP__ATTRIBUTE_FORMAT(fmt,va) __attribute__((format(printf,fmt,va)))" + }, + "unit_kind": "macro", + "unit_name": "STBSP__ATTRIBUTE_FORMAT" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBSP__ATTRIBUTE_FORMAT' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 187, + "column": 1, + "source_line": "#define STBSP__ATTRIBUTE_FORMAT(fmt,va)" + }, + "unit_kind": "macro", + "unit_name": "STBSP__ATTRIBUTE_FORMAT" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBSP__NOTUSED' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 191, + "column": 1, + "source_line": "#define STBSP__NOTUSED(v) (void)(v)" + }, + "unit_kind": "macro", + "unit_name": "STBSP__NOTUSED" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBSP__NOTUSED' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 193, + "column": 1, + "source_line": "#define STBSP__NOTUSED(v) (void)sizeof(v)" + }, + "unit_kind": "macro", + "unit_name": "STBSP__NOTUSED" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STB_SPRINTF_DECORATE' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 205, + "column": 1, + "source_line": "#define STB_SPRINTF_DECORATE(name) stbsp_##name // define this before including if you want to change the names" + }, + "unit_kind": "macro", + "unit_name": "STB_SPRINTF_DECORATE" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBSP__UNALIGNED' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 247, + "column": 1, + "source_line": "#define STBSP__UNALIGNED(code)" + }, + "unit_kind": "macro", + "unit_name": "STBSP__UNALIGNED" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBSP__UNALIGNED' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 249, + "column": 1, + "source_line": "#define STBSP__UNALIGNED(code) code" + }, + "unit_kind": "macro", + "unit_name": "STBSP__UNALIGNED" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbsp__chk_cb_bufL' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 364, + "column": 7, + "source_line": " #define stbsp__chk_cb_bufL(bytes) \\" + }, + "unit_kind": "macro", + "unit_name": "stbsp__chk_cb_bufL" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbsp__chk_cb_buf' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 373, + "column": 7, + "source_line": " #define stbsp__chk_cb_buf(bytes) \\" + }, + "unit_kind": "macro", + "unit_name": "stbsp__chk_cb_buf" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbsp__flush_cb' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 379, + "column": 7, + "source_line": " #define stbsp__flush_cb() \\" + }, + "unit_kind": "macro", + "unit_name": "stbsp__flush_cb" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbsp__cb_buf_clamp' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 383, + "column": 7, + "source_line": " #define stbsp__cb_buf_clamp(cl, v) \\" + }, + "unit_kind": "macro", + "unit_name": "stbsp__cb_buf_clamp" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBSP__COPYFP' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 1483, + "column": 1, + "source_line": "#define STBSP__COPYFP(dest, src) \\" + }, + "unit_kind": "macro", + "unit_name": "STBSP__COPYFP" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbsp__ddmulthi' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 1599, + "column": 1, + "source_line": "#define stbsp__ddmulthi(oh, ol, xh, yh) \\" + }, + "unit_kind": "macro", + "unit_name": "stbsp__ddmulthi" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbsp__ddtoS64' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 1615, + "column": 1, + "source_line": "#define stbsp__ddtoS64(ob, xh, xl) \\" + }, + "unit_kind": "macro", + "unit_name": "stbsp__ddtoS64" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbsp__ddrenorm' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 1626, + "column": 1, + "source_line": "#define stbsp__ddrenorm(oh, ol) \\" + }, + "unit_kind": "macro", + "unit_name": "stbsp__ddrenorm" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbsp__ddmultlo' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 1634, + "column": 1, + "source_line": "#define stbsp__ddmultlo(oh, ol, xh, xl, yh, yl) ol = ol + (xh * yl + xl * yh);" + }, + "unit_kind": "macro", + "unit_name": "stbsp__ddmultlo" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbsp__ddmultlos' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 1636, + "column": 1, + "source_line": "#define stbsp__ddmultlos(oh, ol, xh, yl) ol = ol + (xh * yl);" + }, + "unit_kind": "macro", + "unit_name": "stbsp__ddmultlos" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STB_SPRINTF_DECORATE'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 208, + "column": 1, + "source_line": "STBSP__PUBLICDEC int STB_SPRINTF_DECORATE(vsprintf)(char *buf, char const *fmt, va_list va);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STB_SPRINTF_DECORATE" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STB_SPRINTF_DECORATE'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 209, + "column": 1, + "source_line": "STBSP__PUBLICDEC int STB_SPRINTF_DECORATE(vsnprintf)(char *buf, int count, char const *fmt, va_list va);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STB_SPRINTF_DECORATE" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBSP__ATTRIBUTE_FORMAT'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 210, + "column": 1, + "source_line": "STBSP__PUBLICDEC int STB_SPRINTF_DECORATE(sprintf)(char *buf, char const *fmt, ...) STBSP__ATTRIBUTE_FORMAT(2,3);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBSP__ATTRIBUTE_FORMAT" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBSP__ATTRIBUTE_FORMAT'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 211, + "column": 1, + "source_line": "STBSP__PUBLICDEC int STB_SPRINTF_DECORATE(snprintf)(char *buf, int count, char const *fmt, ...) STBSP__ATTRIBUTE_FORMAT(3,4);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBSP__ATTRIBUTE_FORMAT" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STB_SPRINTF_DECORATE'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 213, + "column": 1, + "source_line": "STBSP__PUBLICDEC int STB_SPRINTF_DECORATE(vsprintfcb)(STBSP_SPRINTFCB *callback, void *user, char *buf, char const *fmt, va_list va);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STB_SPRINTF_DECORATE" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STB_SPRINTF_DECORATE'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 214, + "column": 1, + "source_line": "STBSP__PUBLICDEC void STB_SPRINTF_DECORATE(set_separators)(char comma, char period);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STB_SPRINTF_DECORATE" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbsp__int32'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 254, + "column": 1, + "source_line": "static stbsp__int32 stbsp__real_to_str(char const **start, stbsp__uint32 *len, char *out, stbsp__int32 *decimal_pos, double value, stbsp__uint32 frac_digits);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbsp__int32" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbsp__int32'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 255, + "column": 1, + "source_line": "static stbsp__int32 stbsp__real_to_parts(stbsp__int64 *bits, stbsp__int32 *expo, double value);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbsp__int32" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STB_SPRINTF_DECORATE'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 274, + "column": 1, + "source_line": "STBSP__PUBLICDEF void STB_SPRINTF_DECORATE(set_separators)(char pcomma, char pperiod)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STB_SPRINTF_DECORATE" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBSP__ASAN'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 309, + "column": 1, + "source_line": "static STBSP__ASAN stbsp__uint32 stbsp__strlen_limited(char const *s, stbsp__uint32 limit)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBSP__ASAN" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STB_SPRINTF_DECORATE'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 349, + "column": 1, + "source_line": "STBSP__PUBLICDEF int STB_SPRINTF_DECORATE(vsprintfcb)(STBSP_SPRINTFCB *callback, void *user, char *buf, char const *fmt, va_list va)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STB_SPRINTF_DECORATE" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STB_SPRINTF_DECORATE'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 1376, + "column": 1, + "source_line": "STBSP__PUBLICDEF int STB_SPRINTF_DECORATE(sprintf)(char *buf, char const *fmt, ...)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STB_SPRINTF_DECORATE" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STB_SPRINTF_DECORATE'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 1430, + "column": 1, + "source_line": "STBSP__PUBLICDEF int STB_SPRINTF_DECORATE( vsnprintf )( char * buf, int count, char const * fmt, va_list va )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STB_SPRINTF_DECORATE" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STB_SPRINTF_DECORATE'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 1460, + "column": 1, + "source_line": "STBSP__PUBLICDEF int STB_SPRINTF_DECORATE(snprintf)(char *buf, int count, char const *fmt, ...)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STB_SPRINTF_DECORATE" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STB_SPRINTF_DECORATE'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 1472, + "column": 1, + "source_line": "STBSP__PUBLICDEF int STB_SPRINTF_DECORATE(vsprintf)(char *buf, char const *fmt, va_list va)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STB_SPRINTF_DECORATE" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbsp__int32'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 1491, + "column": 1, + "source_line": "static stbsp__int32 stbsp__real_to_parts(stbsp__int64 *bits, stbsp__int32 *expo, double value)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbsp__int32" + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 1507, + "column": 1, + "source_line": "static double const stbsp__bot[23] = {" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 1511, + "column": 1, + "source_line": "static double const stbsp__negbot[22] = {" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 1515, + "column": 1, + "source_line": "static double const stbsp__negboterr[22] = {" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 1521, + "column": 1, + "source_line": "static double const stbsp__top[13] = {" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 1524, + "column": 1, + "source_line": "static double const stbsp__negtop[13] = {" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 1527, + "column": 1, + "source_line": "static double const stbsp__toperr[13] = {" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 1542, + "column": 1, + "source_line": "static double const stbsp__negtoperr[13] = {" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbsp__uint64'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 1550, + "column": 1, + "source_line": "static stbsp__uint64 const stbsp__powten[20] = {" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbsp__uint64" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbsp__uint64'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 1574, + "column": 1, + "source_line": "static stbsp__uint64 const stbsp__powten[20] = {" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbsp__uint64" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbsp__int32'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 1705, + "column": 1, + "source_line": "static stbsp__int32 stbsp__real_to_str(char const **start, stbsp__uint32 *len, char *out, stbsp__int32 *decimal_pos, double value, stbsp__uint32 frac_digits)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbsp__int32" + } + ] + } + }, + "functions": { + "stbsp__lead_sign": { + "name": "stbsp__lead_sign", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "fl", + "type": { + "reference": "stbsp__uint32" + }, + "declared_type": { + "reference": "stbsp__uint32" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "sign", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *sign", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *sign", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 294, + "column": 1, + "source_line": "static void stbsp__lead_sign(stbsp__uint32 fl, char *sign)" + }, + "start": { + "filename": "stb/stb_sprintf.h", + "line": 294, + "column": 1, + "source_line": "static void stbsp__lead_sign(stbsp__uint32 fl, char *sign)" + }, + "end": { + "filename": "stb/stb_sprintf.h", + "line": 307, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbsp__clamp_callback": { + "name": "stbsp__clamp_callback", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "parameters": [ + { + "name": "buf", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *buf", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *buf", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "user", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *user", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *user", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1393, + "column": 1, + "source_line": "static char *stbsp__clamp_callback(const char *buf, void *user, int len)" + }, + "start": { + "filename": "stb/stb_sprintf.h", + "line": 1393, + "column": 1, + "source_line": "static char *stbsp__clamp_callback(const char *buf, void *user, int len)" + }, + "end": { + "filename": "stb/stb_sprintf.h", + "line": 1419, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbsp__count_clamp_callback": { + "name": "stbsp__count_clamp_callback", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "parameters": [ + { + "name": "buf", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * buf", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * buf", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "user", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void * user", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1421, + "column": 1, + "source_line": "static char * stbsp__count_clamp_callback( const char * buf, void * user, int len )" + }, + "start": { + "filename": "stb/stb_sprintf.h", + "line": 1421, + "column": 1, + "source_line": "static char * stbsp__count_clamp_callback( const char * buf, void * user, int len )" + }, + "end": { + "filename": "stb/stb_sprintf.h", + "line": 1428, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbsp__raise_to_power10": { + "name": "stbsp__raise_to_power10", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "ohi", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "double *ohi", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "double *ohi", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "olo", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "double *olo", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "double *olo", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "d", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double d" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double d" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "power", + "type": { + "reference": "stbsp__int32" + }, + "declared_type": { + "reference": "stbsp__int32" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1638, + "column": 1, + "source_line": "static void stbsp__raise_to_power10(double *ohi, double *olo, double d, stbsp__int32 power) // power can be -323 to +350" + }, + "start": { + "filename": "stb/stb_sprintf.h", + "line": 1638, + "column": 1, + "source_line": "static void stbsp__raise_to_power10(double *ohi, double *olo, double d, stbsp__int32 power) // power can be -323 to +350" + }, + "end": { + "filename": "stb/stb_sprintf.h", + "line": 1699, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + } + }, + "structs": { + "stbsp__context": { + "reference": "struct stbsp__context" + } + }, + "unions": {}, + "enums": {}, + "typedefs": { + "STBSP_SPRINTFCB": { + "reference": "STBSP_SPRINTFCB" + }, + "stbsp__context": { + "reference": "stbsp__context" + } + }, + "variables": { + "stbsp__period": { + "name": "stbsp__period", + "type": { + "model": "CChar", + "qualifiers": [], + "source_text": "static char stbsp__period" + }, + "storage": [ + "static" + ], + "initializer": { + "source_text": "'.'" + }, + "bit_width": null, + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 259, + "column": 1, + "source_line": "static char stbsp__period = '.';" + }, + "callback_policy": null, + "declaration_locations": [] + }, + "stbsp__comma": { + "name": "stbsp__comma", + "type": { + "model": "CChar", + "qualifiers": [], + "source_text": "static char stbsp__comma" + }, + "storage": [ + "static" + ], + "initializer": { + "source_text": "','" + }, + "bit_width": null, + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 260, + "column": 1, + "source_line": "static char stbsp__comma = ',';" + }, + "callback_policy": null, + "declaration_locations": [] + }, + "stbsp__digitpair": { + "name": "stbsp__digitpair", + "type": { + "reference": "struct@stb/stb_sprintf.h:261:1" + }, + "storage": [ + "static" + ], + "initializer": { + "source_text": "" + }, + "bit_width": null, + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 261, + "column": 1, + "source_line": "static struct" + }, + "callback_policy": null, + "declaration_locations": [] + } + }, + "macros": { + "STB_SPRINTF_H_INCLUDE": { + "name": "STB_SPRINTF_H_INCLUDE", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 30, + "column": 1, + "source_line": "#define STB_SPRINTF_H_INCLUDE" + } + }, + "STBSP__ASAN": { + "name": "STBSP__ASAN", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 164, + "column": 1, + "source_line": "#define STBSP__ASAN" + } + }, + "STBSP__PUBLICDEC": { + "name": "STBSP__PUBLICDEC", + "value": "extern", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 175, + "column": 1, + "source_line": "#define STBSP__PUBLICDEC extern" + } + }, + "STBSP__PUBLICDEF": { + "name": "STBSP__PUBLICDEF", + "value": "STBSP__ASAN", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 176, + "column": 1, + "source_line": "#define STBSP__PUBLICDEF STBSP__ASAN" + } + }, + "STBSP__ATTRIBUTE_FORMAT": { + "name": "STBSP__ATTRIBUTE_FORMAT", + "value": null, + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 187, + "column": 1, + "source_line": "#define STBSP__ATTRIBUTE_FORMAT(fmt,va)" + } + }, + "STBSP__NOTUSED": { + "name": "STBSP__NOTUSED", + "value": "(void)sizeof(v)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 193, + "column": 1, + "source_line": "#define STBSP__NOTUSED(v) (void)sizeof(v)" + } + }, + "STB_SPRINTF_MIN": { + "name": "STB_SPRINTF_MIN", + "value": "512", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 200, + "column": 1, + "source_line": "#define STB_SPRINTF_MIN 512 // how many characters per callback" + } + }, + "STB_SPRINTF_DECORATE": { + "name": "STB_SPRINTF_DECORATE", + "value": "stbsp_##name", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 205, + "column": 1, + "source_line": "#define STB_SPRINTF_DECORATE(name) stbsp_##name // define this before including if you want to change the names" + } + }, + "stbsp__uint32": { + "name": "stbsp__uint32", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1858, + "column": 1, + "source_line": "#undef stbsp__uint32" + } + }, + "stbsp__int32": { + "name": "stbsp__int32", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1859, + "column": 1, + "source_line": "#undef stbsp__int32" + } + }, + "stbsp__uint64": { + "name": "stbsp__uint64", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1860, + "column": 1, + "source_line": "#undef stbsp__uint64" + } + }, + "stbsp__int64": { + "name": "stbsp__int64", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1861, + "column": 1, + "source_line": "#undef stbsp__int64" + } + }, + "stbsp__uint16": { + "name": "stbsp__uint16", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1857, + "column": 1, + "source_line": "#undef stbsp__uint16" + } + }, + "stbsp__uintptr": { + "name": "stbsp__uintptr", + "value": "stbsp__uint32", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 236, + "column": 1, + "source_line": "#define stbsp__uintptr stbsp__uint32" + } + }, + "STB_SPRINTF_MSVC_MODE": { + "name": "STB_SPRINTF_MSVC_MODE", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 242, + "column": 1, + "source_line": "#define STB_SPRINTF_MSVC_MODE" + } + }, + "STBSP__UNALIGNED": { + "name": "STBSP__UNALIGNED", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1862, + "column": 1, + "source_line": "#undef STBSP__UNALIGNED" + } + }, + "STBSP__SPECIAL": { + "name": "STBSP__SPECIAL", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1851, + "column": 1, + "source_line": "#undef STBSP__SPECIAL" + } + }, + "STBSP__LEFTJUST": { + "name": "STBSP__LEFTJUST", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1358, + "column": 1, + "source_line": "#undef STBSP__LEFTJUST" + } + }, + "STBSP__LEADINGPLUS": { + "name": "STBSP__LEADINGPLUS", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1359, + "column": 1, + "source_line": "#undef STBSP__LEADINGPLUS" + } + }, + "STBSP__LEADINGSPACE": { + "name": "STBSP__LEADINGSPACE", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1360, + "column": 1, + "source_line": "#undef STBSP__LEADINGSPACE" + } + }, + "STBSP__LEADING_0X": { + "name": "STBSP__LEADING_0X", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1361, + "column": 1, + "source_line": "#undef STBSP__LEADING_0X" + } + }, + "STBSP__LEADINGZERO": { + "name": "STBSP__LEADINGZERO", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1362, + "column": 1, + "source_line": "#undef STBSP__LEADINGZERO" + } + }, + "STBSP__INTMAX": { + "name": "STBSP__INTMAX", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1363, + "column": 1, + "source_line": "#undef STBSP__INTMAX" + } + }, + "STBSP__TRIPLET_COMMA": { + "name": "STBSP__TRIPLET_COMMA", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1364, + "column": 1, + "source_line": "#undef STBSP__TRIPLET_COMMA" + } + }, + "STBSP__NEGATIVE": { + "name": "STBSP__NEGATIVE", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1365, + "column": 1, + "source_line": "#undef STBSP__NEGATIVE" + } + }, + "STBSP__METRIC_SUFFIX": { + "name": "STBSP__METRIC_SUFFIX", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1366, + "column": 1, + "source_line": "#undef STBSP__METRIC_SUFFIX" + } + }, + "STBSP__HALFWIDTH": { + "name": "STBSP__HALFWIDTH", + "value": "512", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 289, + "column": 1, + "source_line": "#define STBSP__HALFWIDTH 512" + } + }, + "STBSP__METRIC_NOSPACE": { + "name": "STBSP__METRIC_NOSPACE", + "value": "1024", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 290, + "column": 1, + "source_line": "#define STBSP__METRIC_NOSPACE 1024" + } + }, + "STBSP__METRIC_1024": { + "name": "STBSP__METRIC_1024", + "value": "2048", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 291, + "column": 1, + "source_line": "#define STBSP__METRIC_1024 2048" + } + }, + "STBSP__METRIC_JEDEC": { + "name": "STBSP__METRIC_JEDEC", + "value": "4096", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 292, + "column": 1, + "source_line": "#define STBSP__METRIC_JEDEC 4096" + } + }, + "stbsp__chk_cb_bufL": { + "name": "stbsp__chk_cb_bufL", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1368, + "column": 1, + "source_line": "#undef stbsp__chk_cb_bufL" + } + }, + "stbsp__chk_cb_buf": { + "name": "stbsp__chk_cb_buf", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1369, + "column": 1, + "source_line": "#undef stbsp__chk_cb_buf" + } + }, + "stbsp__flush_cb": { + "name": "stbsp__flush_cb", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1370, + "column": 1, + "source_line": "#undef stbsp__flush_cb" + } + }, + "stbsp__cb_buf_clamp": { + "name": "stbsp__cb_buf_clamp", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1371, + "column": 1, + "source_line": "#undef stbsp__cb_buf_clamp" + } + }, + "STBSP__NUMSZ": { + "name": "STBSP__NUMSZ", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1367, + "column": 1, + "source_line": "#undef STBSP__NUMSZ" + } + }, + "STBSP__COPYFP": { + "name": "STBSP__COPYFP", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1852, + "column": 1, + "source_line": "#undef STBSP__COPYFP" + } + }, + "stbsp__tento19th": { + "name": "stbsp__tento19th", + "value": "(1000000000000000000ULL)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1596, + "column": 1, + "source_line": "#define stbsp__tento19th (1000000000000000000ULL)" + } + }, + "stbsp__ddmulthi": { + "name": "stbsp__ddmulthi", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1847, + "column": 1, + "source_line": "#undef stbsp__ddmulthi" + } + }, + "stbsp__ddtoS64": { + "name": "stbsp__ddtoS64", + "value": "{ double ahi = 0, alo, vh, t; ob = (stbsp__int64)xh; vh = (double)ob; ahi = (xh - vh); t = (ahi - xh); alo = (xh - (ahi - t)) - (vh + t); ob += (stbsp__int64)(ahi + alo + xl); }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1615, + "column": 1, + "source_line": "#define stbsp__ddtoS64(ob, xh, xl) \\" + } + }, + "stbsp__ddrenorm": { + "name": "stbsp__ddrenorm", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1848, + "column": 1, + "source_line": "#undef stbsp__ddrenorm" + } + }, + "stbsp__ddmultlo": { + "name": "stbsp__ddmultlo", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1849, + "column": 1, + "source_line": "#undef stbsp__ddmultlo" + } + }, + "stbsp__ddmultlos": { + "name": "stbsp__ddmultlos", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 1850, + "column": 1, + "source_line": "#undef stbsp__ddmultlos" + } + } + }, + "includes": { + "stb/stb_sprintf.h:stdarg.h": { + "target": "stdarg.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 196, + "column": 1, + "source_line": "#include // for va_arg(), va_list()" + } + }, + "stb/stb_sprintf.h:stddef.h": { + "target": "stddef.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_sprintf.h", + "line": 197, + "column": 1, + "source_line": "#include // size_t, ptrdiff_t" + } + } + }, + "functions_by_file": { + "stb/stb_sprintf.h": [ + "stbsp__lead_sign", + "stbsp__clamp_callback", + "stbsp__count_clamp_callback", + "stbsp__raise_to_power10" + ] + }, + "enum_constants": {}, + "include_graph": { + "stb/stb_sprintf.h": [] + }, + "system_includes": { + "stb/stb_sprintf.h": [ + "stdarg.h", + "stddef.h" + ] + }, + "unresolved_includes": { + "stb/stb_sprintf.h": [] + }, + "header_source_pairs": { + "stb/stb_sprintf.h": [] + }, + "diagnostics": [ + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBSP__ATTRIBUTE_FORMAT' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 182, + "column": 4, + "source_line": " #define STBSP__ATTRIBUTE_FORMAT(fmt,va) __attribute__((format(printf,fmt,va)))" + }, + "unit_kind": "macro", + "unit_name": "STBSP__ATTRIBUTE_FORMAT" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBSP__ATTRIBUTE_FORMAT' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 187, + "column": 1, + "source_line": "#define STBSP__ATTRIBUTE_FORMAT(fmt,va)" + }, + "unit_kind": "macro", + "unit_name": "STBSP__ATTRIBUTE_FORMAT" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBSP__NOTUSED' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 191, + "column": 1, + "source_line": "#define STBSP__NOTUSED(v) (void)(v)" + }, + "unit_kind": "macro", + "unit_name": "STBSP__NOTUSED" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBSP__NOTUSED' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 193, + "column": 1, + "source_line": "#define STBSP__NOTUSED(v) (void)sizeof(v)" + }, + "unit_kind": "macro", + "unit_name": "STBSP__NOTUSED" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STB_SPRINTF_DECORATE' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 205, + "column": 1, + "source_line": "#define STB_SPRINTF_DECORATE(name) stbsp_##name // define this before including if you want to change the names" + }, + "unit_kind": "macro", + "unit_name": "STB_SPRINTF_DECORATE" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBSP__UNALIGNED' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 247, + "column": 1, + "source_line": "#define STBSP__UNALIGNED(code)" + }, + "unit_kind": "macro", + "unit_name": "STBSP__UNALIGNED" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBSP__UNALIGNED' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 249, + "column": 1, + "source_line": "#define STBSP__UNALIGNED(code) code" + }, + "unit_kind": "macro", + "unit_name": "STBSP__UNALIGNED" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbsp__chk_cb_bufL' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 364, + "column": 7, + "source_line": " #define stbsp__chk_cb_bufL(bytes) \\" + }, + "unit_kind": "macro", + "unit_name": "stbsp__chk_cb_bufL" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbsp__chk_cb_buf' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 373, + "column": 7, + "source_line": " #define stbsp__chk_cb_buf(bytes) \\" + }, + "unit_kind": "macro", + "unit_name": "stbsp__chk_cb_buf" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbsp__flush_cb' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 379, + "column": 7, + "source_line": " #define stbsp__flush_cb() \\" + }, + "unit_kind": "macro", + "unit_name": "stbsp__flush_cb" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbsp__cb_buf_clamp' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 383, + "column": 7, + "source_line": " #define stbsp__cb_buf_clamp(cl, v) \\" + }, + "unit_kind": "macro", + "unit_name": "stbsp__cb_buf_clamp" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBSP__COPYFP' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 1483, + "column": 1, + "source_line": "#define STBSP__COPYFP(dest, src) \\" + }, + "unit_kind": "macro", + "unit_name": "STBSP__COPYFP" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbsp__ddmulthi' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 1599, + "column": 1, + "source_line": "#define stbsp__ddmulthi(oh, ol, xh, yh) \\" + }, + "unit_kind": "macro", + "unit_name": "stbsp__ddmulthi" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbsp__ddtoS64' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 1615, + "column": 1, + "source_line": "#define stbsp__ddtoS64(ob, xh, xl) \\" + }, + "unit_kind": "macro", + "unit_name": "stbsp__ddtoS64" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbsp__ddrenorm' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 1626, + "column": 1, + "source_line": "#define stbsp__ddrenorm(oh, ol) \\" + }, + "unit_kind": "macro", + "unit_name": "stbsp__ddrenorm" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbsp__ddmultlo' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 1634, + "column": 1, + "source_line": "#define stbsp__ddmultlo(oh, ol, xh, xl, yh, yl) ol = ol + (xh * yl + xl * yh);" + }, + "unit_kind": "macro", + "unit_name": "stbsp__ddmultlo" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbsp__ddmultlos' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 1636, + "column": 1, + "source_line": "#define stbsp__ddmultlos(oh, ol, xh, yl) ol = ol + (xh * yl);" + }, + "unit_kind": "macro", + "unit_name": "stbsp__ddmultlos" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STB_SPRINTF_DECORATE'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 208, + "column": 1, + "source_line": "STBSP__PUBLICDEC int STB_SPRINTF_DECORATE(vsprintf)(char *buf, char const *fmt, va_list va);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STB_SPRINTF_DECORATE" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STB_SPRINTF_DECORATE'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 209, + "column": 1, + "source_line": "STBSP__PUBLICDEC int STB_SPRINTF_DECORATE(vsnprintf)(char *buf, int count, char const *fmt, va_list va);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STB_SPRINTF_DECORATE" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBSP__ATTRIBUTE_FORMAT'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 210, + "column": 1, + "source_line": "STBSP__PUBLICDEC int STB_SPRINTF_DECORATE(sprintf)(char *buf, char const *fmt, ...) STBSP__ATTRIBUTE_FORMAT(2,3);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBSP__ATTRIBUTE_FORMAT" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STBSP__ATTRIBUTE_FORMAT'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 211, + "column": 1, + "source_line": "STBSP__PUBLICDEC int STB_SPRINTF_DECORATE(snprintf)(char *buf, int count, char const *fmt, ...) STBSP__ATTRIBUTE_FORMAT(3,4);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBSP__ATTRIBUTE_FORMAT" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STB_SPRINTF_DECORATE'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 213, + "column": 1, + "source_line": "STBSP__PUBLICDEC int STB_SPRINTF_DECORATE(vsprintfcb)(STBSP_SPRINTFCB *callback, void *user, char *buf, char const *fmt, va_list va);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STB_SPRINTF_DECORATE" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STB_SPRINTF_DECORATE'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 214, + "column": 1, + "source_line": "STBSP__PUBLICDEC void STB_SPRINTF_DECORATE(set_separators)(char comma, char period);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STB_SPRINTF_DECORATE" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbsp__int32'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 254, + "column": 1, + "source_line": "static stbsp__int32 stbsp__real_to_str(char const **start, stbsp__uint32 *len, char *out, stbsp__int32 *decimal_pos, double value, stbsp__uint32 frac_digits);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbsp__int32" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbsp__int32'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 255, + "column": 1, + "source_line": "static stbsp__int32 stbsp__real_to_parts(stbsp__int64 *bits, stbsp__int32 *expo, double value);" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbsp__int32" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STB_SPRINTF_DECORATE'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 274, + "column": 1, + "source_line": "STBSP__PUBLICDEF void STB_SPRINTF_DECORATE(set_separators)(char pcomma, char pperiod)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STB_SPRINTF_DECORATE" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBSP__ASAN'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 309, + "column": 1, + "source_line": "static STBSP__ASAN stbsp__uint32 stbsp__strlen_limited(char const *s, stbsp__uint32 limit)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBSP__ASAN" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STB_SPRINTF_DECORATE'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 349, + "column": 1, + "source_line": "STBSP__PUBLICDEF int STB_SPRINTF_DECORATE(vsprintfcb)(STBSP_SPRINTFCB *callback, void *user, char *buf, char const *fmt, va_list va)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STB_SPRINTF_DECORATE" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STB_SPRINTF_DECORATE'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 1376, + "column": 1, + "source_line": "STBSP__PUBLICDEF int STB_SPRINTF_DECORATE(sprintf)(char *buf, char const *fmt, ...)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STB_SPRINTF_DECORATE" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STB_SPRINTF_DECORATE'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 1430, + "column": 1, + "source_line": "STBSP__PUBLICDEF int STB_SPRINTF_DECORATE( vsnprintf )( char * buf, int count, char const * fmt, va_list va )" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STB_SPRINTF_DECORATE" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STB_SPRINTF_DECORATE'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 1460, + "column": 1, + "source_line": "STBSP__PUBLICDEF int STB_SPRINTF_DECORATE(snprintf)(char *buf, int count, char const *fmt, ...)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STB_SPRINTF_DECORATE" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on function-like macro 'STB_SPRINTF_DECORATE'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 1472, + "column": 1, + "source_line": "STBSP__PUBLICDEF int STB_SPRINTF_DECORATE(vsprintf)(char *buf, char const *fmt, va_list va)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STB_SPRINTF_DECORATE" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbsp__int32'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 1491, + "column": 1, + "source_line": "static stbsp__int32 stbsp__real_to_parts(stbsp__int64 *bits, stbsp__int32 *expo, double value)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbsp__int32" + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 1507, + "column": 1, + "source_line": "static double const stbsp__bot[23] = {" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 1511, + "column": 1, + "source_line": "static double const stbsp__negbot[22] = {" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 1515, + "column": 1, + "source_line": "static double const stbsp__negboterr[22] = {" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 1521, + "column": 1, + "source_line": "static double const stbsp__top[13] = {" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 1524, + "column": 1, + "source_line": "static double const stbsp__negtop[13] = {" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 1527, + "column": 1, + "source_line": "static double const stbsp__toperr[13] = {" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 1542, + "column": 1, + "source_line": "static double const stbsp__negtoperr[13] = {" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbsp__uint64'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 1550, + "column": 1, + "source_line": "static stbsp__uint64 const stbsp__powten[20] = {" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbsp__uint64" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbsp__uint64'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 1574, + "column": 1, + "source_line": "static stbsp__uint64 const stbsp__powten[20] = {" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbsp__uint64" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'stbsp__int32'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_sprintf.h", + "line": 1705, + "column": 1, + "source_line": "static stbsp__int32 stbsp__real_to_str(char const **start, stbsp__uint32 *len, char *out, stbsp__int32 *decimal_pos, double value, stbsp__uint32 frac_digits)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "stbsp__int32" + } + ] +} diff --git a/tests/parser/c/fixtures/stb/stb_textedit.json b/tests/parser/c/fixtures/stb/stb_textedit.json new file mode 100644 index 000000000..ad3901667 --- /dev/null +++ b/tests/parser/c/fixtures/stb/stb_textedit.json @@ -0,0 +1,8173 @@ +{ + "files": { + "stb/stb_textedit.h": { + "filename": "stb/stb_textedit.h", + "language": "c", + "parser_status": "partial", + "preprocessing": "raw", + "functions": [ + { + "name": "stb_text_locate_coord", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING", + "name": "STB_TEXTEDIT_STRING", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TEXTEDIT_STRING" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 394, + "column": 1, + "source_line": "static int stb_text_locate_coord(STB_TEXTEDIT_STRING *str, float x, float y)" + }, + "start": { + "filename": "stb/stb_textedit.h", + "line": 394, + "column": 1, + "source_line": "static int stb_text_locate_coord(STB_TEXTEDIT_STRING *str, float x, float y)" + }, + "end": { + "filename": "stb/stb_textedit.h", + "line": 451, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_textedit_click", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING", + "name": "STB_TEXTEDIT_STRING", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TEXTEDIT_STRING" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "state", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "STB_TexteditState", + "name": "STB_TexteditState", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "cursor", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int cursor" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 320, + "column": 4, + "source_line": " int cursor;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "select_start", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int select_start" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 323, + "column": 4, + "source_line": " int select_start; // selection start point" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "select_end", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int select_end" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 324, + "column": 4, + "source_line": " int select_end;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "insert_mode", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char insert_mode" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 330, + "column": 4, + "source_line": " unsigned char insert_mode;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "row_count_per_page", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int row_count_per_page" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 334, + "column": 4, + "source_line": " int row_count_per_page;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "cursor_at_end_of_line", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char cursor_at_end_of_line" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 342, + "column": 4, + "source_line": " unsigned char cursor_at_end_of_line; // not implemented yet" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "initialized", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char initialized" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 343, + "column": 4, + "source_line": " unsigned char initialized;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "has_preferred_x", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char has_preferred_x" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 344, + "column": 4, + "source_line": " unsigned char has_preferred_x;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "single_line", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char single_line" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 345, + "column": 4, + "source_line": " unsigned char single_line;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "padding1", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char padding1" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 346, + "column": 4, + "source_line": " unsigned char padding1, padding2, padding3;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "padding2", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char padding2" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 346, + "column": 4, + "source_line": " unsigned char padding1, padding2, padding3;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "padding3", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char padding3" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 346, + "column": 4, + "source_line": " unsigned char padding1, padding2, padding3;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "preferred_x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float preferred_x" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 347, + "column": 4, + "source_line": " float preferred_x; // this determines where the cursor up/down tries to seek to along x" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "undostate", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "StbUndoState", + "name": "StbUndoState", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "undo_rec", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "StbUndoRecord undo_rec [STB_TEXTEDIT_UNDOSTATECOUNT]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STB_TEXTEDIT_UNDOSTATECOUNT", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "StbUndoRecord", + "name": "StbUndoRecord", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "where", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_POSITIONTYPE where", + "name": "STB_TEXTEDIT_POSITIONTYPE", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 298, + "column": 4, + "source_line": " STB_TEXTEDIT_POSITIONTYPE where;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "insert_length", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_POSITIONTYPE insert_length", + "name": "STB_TEXTEDIT_POSITIONTYPE", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 299, + "column": 4, + "source_line": " STB_TEXTEDIT_POSITIONTYPE insert_length;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "delete_length", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_POSITIONTYPE delete_length", + "name": "STB_TEXTEDIT_POSITIONTYPE", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 300, + "column": 4, + "source_line": " STB_TEXTEDIT_POSITIONTYPE delete_length;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "char_storage", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int char_storage" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 301, + "column": 4, + "source_line": " int char_storage;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_textedit.h:295:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 295, + "column": 1, + "source_line": "typedef struct" + } + }, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 295, + "column": 1, + "source_line": "typedef struct" + }, + "declaration_locations": [] + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 307, + "column": 4, + "source_line": " StbUndoRecord undo_rec [STB_TEXTEDIT_UNDOSTATECOUNT];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "undo_char", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_CHARTYPE undo_char[STB_TEXTEDIT_UNDOCHARCOUNT]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STB_TEXTEDIT_UNDOCHARCOUNT", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_CHARTYPE", + "name": "STB_TEXTEDIT_CHARTYPE", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 308, + "column": 4, + "source_line": " STB_TEXTEDIT_CHARTYPE undo_char[STB_TEXTEDIT_UNDOCHARCOUNT];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "undo_point", + "type": { + "model": "CShort", + "qualifiers": [], + "source_text": "short undo_point" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 309, + "column": 4, + "source_line": " short undo_point, redo_point;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "redo_point", + "type": { + "model": "CShort", + "qualifiers": [], + "source_text": "short redo_point" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 309, + "column": 4, + "source_line": " short undo_point, redo_point;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "undo_char_point", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int undo_char_point" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 310, + "column": 4, + "source_line": " int undo_char_point, redo_char_point;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "redo_char_point", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int redo_char_point" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 310, + "column": 4, + "source_line": " int undo_char_point, redo_char_point;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_textedit.h:304:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 304, + "column": 1, + "source_line": "typedef struct" + } + }, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 304, + "column": 1, + "source_line": "typedef struct" + }, + "declaration_locations": [] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 348, + "column": 4, + "source_line": " StbUndoState undostate;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_textedit.h:313:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 313, + "column": 1, + "source_line": "typedef struct" + } + }, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 313, + "column": 1, + "source_line": "typedef struct" + }, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 454, + "column": 1, + "source_line": "static void stb_textedit_click(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, float x, float y)" + }, + "start": { + "filename": "stb/stb_textedit.h", + "line": 454, + "column": 1, + "source_line": "static void stb_textedit_click(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, float x, float y)" + }, + "end": { + "filename": "stb/stb_textedit.h", + "line": 469, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_textedit_drag", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING", + "name": "STB_TEXTEDIT_STRING", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TEXTEDIT_STRING" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "state", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 472, + "column": 1, + "source_line": "static void stb_textedit_drag(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, float x, float y)" + }, + "start": { + "filename": "stb/stb_textedit.h", + "line": 472, + "column": 1, + "source_line": "static void stb_textedit_drag(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, float x, float y)" + }, + "end": { + "filename": "stb/stb_textedit.h", + "line": 490, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_text_undo", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING", + "name": "STB_TEXTEDIT_STRING", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TEXTEDIT_STRING" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "state", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 1205, + "column": 1, + "source_line": "static void stb_text_undo(STB_TEXTEDIT_STRING *str, STB_TexteditState *state)" + }, + "start": { + "filename": "stb/stb_textedit.h", + "line": 1205, + "column": 1, + "source_line": "static void stb_text_undo(STB_TEXTEDIT_STRING *str, STB_TexteditState *state)" + }, + "end": { + "filename": "stb/stb_textedit.h", + "line": 1271, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_textedit.h", + "line": 498, + "column": 1, + "source_line": "static void stb_text_undo(STB_TEXTEDIT_STRING *str, STB_TexteditState *state);" + } + ] + }, + { + "name": "stb_text_redo", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING", + "name": "STB_TEXTEDIT_STRING", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TEXTEDIT_STRING" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "state", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 1273, + "column": 1, + "source_line": "static void stb_text_redo(STB_TEXTEDIT_STRING *str, STB_TexteditState *state)" + }, + "start": { + "filename": "stb/stb_textedit.h", + "line": 1273, + "column": 1, + "source_line": "static void stb_text_redo(STB_TEXTEDIT_STRING *str, STB_TexteditState *state)" + }, + "end": { + "filename": "stb/stb_textedit.h", + "line": 1322, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_textedit.h", + "line": 499, + "column": 1, + "source_line": "static void stb_text_redo(STB_TEXTEDIT_STRING *str, STB_TexteditState *state);" + } + ] + }, + { + "name": "stb_text_makeundo_delete", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING", + "name": "STB_TEXTEDIT_STRING", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TEXTEDIT_STRING" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "state", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "where", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int where" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int where" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "length", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int length" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int length" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 1329, + "column": 1, + "source_line": "static void stb_text_makeundo_delete(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, int where, int length)" + }, + "start": { + "filename": "stb/stb_textedit.h", + "line": 1329, + "column": 1, + "source_line": "static void stb_text_makeundo_delete(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, int where, int length)" + }, + "end": { + "filename": "stb/stb_textedit.h", + "line": 1337, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_textedit.h", + "line": 500, + "column": 1, + "source_line": "static void stb_text_makeundo_delete(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, int where, int length);" + } + ] + }, + { + "name": "stb_text_makeundo_insert", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "state", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "where", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int where" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int where" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "length", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int length" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int length" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 1324, + "column": 1, + "source_line": "static void stb_text_makeundo_insert(STB_TexteditState *state, int where, int length)" + }, + "start": { + "filename": "stb/stb_textedit.h", + "line": 1324, + "column": 1, + "source_line": "static void stb_text_makeundo_insert(STB_TexteditState *state, int where, int length)" + }, + "end": { + "filename": "stb/stb_textedit.h", + "line": 1327, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_textedit.h", + "line": 501, + "column": 1, + "source_line": "static void stb_text_makeundo_insert(STB_TexteditState *state, int where, int length);" + } + ] + }, + { + "name": "stb_text_makeundo_replace", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING", + "name": "STB_TEXTEDIT_STRING", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TEXTEDIT_STRING" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "state", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "where", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int where" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int where" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "old_length", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int old_length" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int old_length" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "new_length", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int new_length" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int new_length" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 1339, + "column": 1, + "source_line": "static void stb_text_makeundo_replace(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, int where, int old_length, int new_length)" + }, + "start": { + "filename": "stb/stb_textedit.h", + "line": 1339, + "column": 1, + "source_line": "static void stb_text_makeundo_replace(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, int where, int old_length, int new_length)" + }, + "end": { + "filename": "stb/stb_textedit.h", + "line": 1347, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_textedit.h", + "line": 502, + "column": 1, + "source_line": "static void stb_text_makeundo_replace(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, int where, int old_length, int new_length);" + } + ] + }, + { + "name": "stb_textedit_find_charpos", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "find", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "StbFindState *find", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "StbFindState", + "name": "StbFindState", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 506, + "column": 4, + "source_line": " float x,y; // position of n'th character" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "y", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 506, + "column": 4, + "source_line": " float x,y; // position of n'th character" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "height", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float height" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 507, + "column": 4, + "source_line": " float height; // height of line" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "first_char", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int first_char" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 508, + "column": 4, + "source_line": " int first_char, length; // first char of row, and length" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "length", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int length" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 508, + "column": 4, + "source_line": " int first_char, length; // first char of row, and length" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "prev_first", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int prev_first" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 509, + "column": 4, + "source_line": " int prev_first; // first char of previous row" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_textedit.h:504:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 504, + "column": 1, + "source_line": "typedef struct" + } + }, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 504, + "column": 1, + "source_line": "typedef struct" + }, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "StbFindState *find", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "StbFindState" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING", + "name": "STB_TEXTEDIT_STRING", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TEXTEDIT_STRING" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "single_line", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int single_line" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int single_line" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 514, + "column": 1, + "source_line": "static void stb_textedit_find_charpos(StbFindState *find, STB_TEXTEDIT_STRING *str, int n, int single_line)" + }, + "start": { + "filename": "stb/stb_textedit.h", + "line": 514, + "column": 1, + "source_line": "static void stb_textedit_find_charpos(StbFindState *find, STB_TEXTEDIT_STRING *str, int n, int single_line)" + }, + "end": { + "filename": "stb/stb_textedit.h", + "line": 568, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_textedit_clamp", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING", + "name": "STB_TEXTEDIT_STRING", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TEXTEDIT_STRING" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "state", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 573, + "column": 1, + "source_line": "static void stb_textedit_clamp(STB_TEXTEDIT_STRING *str, STB_TexteditState *state)" + }, + "start": { + "filename": "stb/stb_textedit.h", + "line": 573, + "column": 1, + "source_line": "static void stb_textedit_clamp(STB_TEXTEDIT_STRING *str, STB_TexteditState *state)" + }, + "end": { + "filename": "stb/stb_textedit.h", + "line": 584, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_textedit_delete", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING", + "name": "STB_TEXTEDIT_STRING", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TEXTEDIT_STRING" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "state", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "where", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int where" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int where" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 587, + "column": 1, + "source_line": "static void stb_textedit_delete(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, int where, int len)" + }, + "start": { + "filename": "stb/stb_textedit.h", + "line": 587, + "column": 1, + "source_line": "static void stb_textedit_delete(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, int where, int len)" + }, + "end": { + "filename": "stb/stb_textedit.h", + "line": 592, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_textedit_delete_selection", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING", + "name": "STB_TEXTEDIT_STRING", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TEXTEDIT_STRING" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "state", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 595, + "column": 1, + "source_line": "static void stb_textedit_delete_selection(STB_TEXTEDIT_STRING *str, STB_TexteditState *state)" + }, + "start": { + "filename": "stb/stb_textedit.h", + "line": 595, + "column": 1, + "source_line": "static void stb_textedit_delete_selection(STB_TEXTEDIT_STRING *str, STB_TexteditState *state)" + }, + "end": { + "filename": "stb/stb_textedit.h", + "line": 608, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_textedit_sortselection", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "state", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 611, + "column": 1, + "source_line": "static void stb_textedit_sortselection(STB_TexteditState *state)" + }, + "start": { + "filename": "stb/stb_textedit.h", + "line": 611, + "column": 1, + "source_line": "static void stb_textedit_sortselection(STB_TexteditState *state)" + }, + "end": { + "filename": "stb/stb_textedit.h", + "line": 618, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_textedit_move_to_first", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "state", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 621, + "column": 1, + "source_line": "static void stb_textedit_move_to_first(STB_TexteditState *state)" + }, + "start": { + "filename": "stb/stb_textedit.h", + "line": 621, + "column": 1, + "source_line": "static void stb_textedit_move_to_first(STB_TexteditState *state)" + }, + "end": { + "filename": "stb/stb_textedit.h", + "line": 629, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_textedit_move_to_last", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING", + "name": "STB_TEXTEDIT_STRING", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TEXTEDIT_STRING" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "state", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 632, + "column": 1, + "source_line": "static void stb_textedit_move_to_last(STB_TEXTEDIT_STRING *str, STB_TexteditState *state)" + }, + "start": { + "filename": "stb/stb_textedit.h", + "line": 632, + "column": 1, + "source_line": "static void stb_textedit_move_to_last(STB_TEXTEDIT_STRING *str, STB_TexteditState *state)" + }, + "end": { + "filename": "stb/stb_textedit.h", + "line": 641, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "is_word_boundary", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING", + "name": "STB_TEXTEDIT_STRING", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TEXTEDIT_STRING" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "idx", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int idx" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int idx" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 644, + "column": 1, + "source_line": "static int is_word_boundary( STB_TEXTEDIT_STRING *str, int idx )" + }, + "start": { + "filename": "stb/stb_textedit.h", + "line": 644, + "column": 1, + "source_line": "static int is_word_boundary( STB_TEXTEDIT_STRING *str, int idx )" + }, + "end": { + "filename": "stb/stb_textedit.h", + "line": 647, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_textedit_move_to_word_previous", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING", + "name": "STB_TEXTEDIT_STRING", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TEXTEDIT_STRING" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 650, + "column": 1, + "source_line": "static int stb_textedit_move_to_word_previous( STB_TEXTEDIT_STRING *str, int c )" + }, + "start": { + "filename": "stb/stb_textedit.h", + "line": 650, + "column": 1, + "source_line": "static int stb_textedit_move_to_word_previous( STB_TEXTEDIT_STRING *str, int c )" + }, + "end": { + "filename": "stb/stb_textedit.h", + "line": 660, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_textedit_move_to_word_next", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING", + "name": "STB_TEXTEDIT_STRING", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TEXTEDIT_STRING" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 665, + "column": 1, + "source_line": "static int stb_textedit_move_to_word_next( STB_TEXTEDIT_STRING *str, int c )" + }, + "start": { + "filename": "stb/stb_textedit.h", + "line": 665, + "column": 1, + "source_line": "static int stb_textedit_move_to_word_next( STB_TEXTEDIT_STRING *str, int c )" + }, + "end": { + "filename": "stb/stb_textedit.h", + "line": 676, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_textedit_prep_selection_at_cursor", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "state", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 683, + "column": 1, + "source_line": "static void stb_textedit_prep_selection_at_cursor(STB_TexteditState *state)" + }, + "start": { + "filename": "stb/stb_textedit.h", + "line": 683, + "column": 1, + "source_line": "static void stb_textedit_prep_selection_at_cursor(STB_TexteditState *state)" + }, + "end": { + "filename": "stb/stb_textedit.h", + "line": 689, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_textedit_cut", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING", + "name": "STB_TEXTEDIT_STRING", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TEXTEDIT_STRING" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "state", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 692, + "column": 1, + "source_line": "static int stb_textedit_cut(STB_TEXTEDIT_STRING *str, STB_TexteditState *state)" + }, + "start": { + "filename": "stb/stb_textedit.h", + "line": 692, + "column": 1, + "source_line": "static int stb_textedit_cut(STB_TEXTEDIT_STRING *str, STB_TexteditState *state)" + }, + "end": { + "filename": "stb/stb_textedit.h", + "line": 700, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_textedit_paste_internal", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING", + "name": "STB_TEXTEDIT_STRING", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TEXTEDIT_STRING" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "state", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "text", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_CHARTYPE *text", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_CHARTYPE", + "name": "STB_TEXTEDIT_CHARTYPE", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_CHARTYPE *text", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TEXTEDIT_CHARTYPE" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 703, + "column": 1, + "source_line": "static int stb_textedit_paste_internal(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, STB_TEXTEDIT_CHARTYPE *text, int len)" + }, + "start": { + "filename": "stb/stb_textedit.h", + "line": 703, + "column": 1, + "source_line": "static int stb_textedit_paste_internal(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, STB_TEXTEDIT_CHARTYPE *text, int len)" + }, + "end": { + "filename": "stb/stb_textedit.h", + "line": 717, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_textedit_key", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING", + "name": "STB_TEXTEDIT_STRING", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TEXTEDIT_STRING" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "state", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "key", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_KEYTYPE key", + "name": "STB_TEXTEDIT_KEYTYPE", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "declared_type": { + "reference": "STB_TEXTEDIT_KEYTYPE" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 724, + "column": 1, + "source_line": "static void stb_textedit_key(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, STB_TEXTEDIT_KEYTYPE key)" + }, + "start": { + "filename": "stb/stb_textedit.h", + "line": 724, + "column": 1, + "source_line": "static void stb_textedit_key(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, STB_TEXTEDIT_KEYTYPE key)" + }, + "end": { + "filename": "stb/stb_textedit.h", + "line": 1101, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_textedit_flush_redo", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "state", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "StbUndoState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "StbUndoState" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "StbUndoState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "StbUndoState" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 1109, + "column": 1, + "source_line": "static void stb_textedit_flush_redo(StbUndoState *state)" + }, + "start": { + "filename": "stb/stb_textedit.h", + "line": 1109, + "column": 1, + "source_line": "static void stb_textedit_flush_redo(StbUndoState *state)" + }, + "end": { + "filename": "stb/stb_textedit.h", + "line": 1113, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_textedit_discard_undo", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "state", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "StbUndoState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "StbUndoState" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "StbUndoState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "StbUndoState" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 1116, + "column": 1, + "source_line": "static void stb_textedit_discard_undo(StbUndoState *state)" + }, + "start": { + "filename": "stb/stb_textedit.h", + "line": 1116, + "column": 1, + "source_line": "static void stb_textedit_discard_undo(StbUndoState *state)" + }, + "end": { + "filename": "stb/stb_textedit.h", + "line": 1132, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_textedit_discard_redo", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "state", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "StbUndoState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "StbUndoState" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "StbUndoState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "StbUndoState" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 1138, + "column": 1, + "source_line": "static void stb_textedit_discard_redo(StbUndoState *state)" + }, + "start": { + "filename": "stb/stb_textedit.h", + "line": 1138, + "column": 1, + "source_line": "static void stb_textedit_discard_redo(StbUndoState *state)" + }, + "end": { + "filename": "stb/stb_textedit.h", + "line": 1159, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_text_create_undo_record", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "StbUndoRecord", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "StbUndoRecord" + } + ] + }, + "parameters": [ + { + "name": "state", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "StbUndoState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "StbUndoState" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "StbUndoState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "StbUndoState" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "numchars", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int numchars" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int numchars" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 1161, + "column": 1, + "source_line": "static StbUndoRecord *stb_text_create_undo_record(StbUndoState *state, int numchars)" + }, + "start": { + "filename": "stb/stb_textedit.h", + "line": 1161, + "column": 1, + "source_line": "static StbUndoRecord *stb_text_create_undo_record(StbUndoState *state, int numchars)" + }, + "end": { + "filename": "stb/stb_textedit.h", + "line": 1183, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_textedit_clear_state", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "state", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "is_single_line", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int is_single_line" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int is_single_line" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 1350, + "column": 1, + "source_line": "static void stb_textedit_clear_state(STB_TexteditState *state, int is_single_line)" + }, + "start": { + "filename": "stb/stb_textedit.h", + "line": 1350, + "column": 1, + "source_line": "static void stb_textedit_clear_state(STB_TexteditState *state, int is_single_line)" + }, + "end": { + "filename": "stb/stb_textedit.h", + "line": 1365, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_textedit_initialize_state", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "state", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "is_single_line", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int is_single_line" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int is_single_line" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 1368, + "column": 1, + "source_line": "static void stb_textedit_initialize_state(STB_TexteditState *state, int is_single_line)" + }, + "start": { + "filename": "stb/stb_textedit.h", + "line": 1368, + "column": 1, + "source_line": "static void stb_textedit_initialize_state(STB_TexteditState *state, int is_single_line)" + }, + "end": { + "filename": "stb/stb_textedit.h", + "line": 1371, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_textedit_paste", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING", + "name": "STB_TEXTEDIT_STRING", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TEXTEDIT_STRING" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "state", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ctext", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_CHARTYPE const *ctext", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [ + "const" + ], + "source_text": "const STB_TEXTEDIT_CHARTYPE", + "name": "STB_TEXTEDIT_CHARTYPE", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_CHARTYPE const *ctext", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TEXTEDIT_CHARTYPE" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 1378, + "column": 1, + "source_line": "static int stb_textedit_paste(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, STB_TEXTEDIT_CHARTYPE const *ctext, int len)" + }, + "start": { + "filename": "stb/stb_textedit.h", + "line": 1378, + "column": 1, + "source_line": "static int stb_textedit_paste(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, STB_TEXTEDIT_CHARTYPE const *ctext, int len)" + }, + "end": { + "filename": "stb/stb_textedit.h", + "line": 1381, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + } + ], + "structs": [ + { + "reference": "struct@stb/stb_textedit.h:295:1" + }, + { + "reference": "struct@stb/stb_textedit.h:304:1" + }, + { + "reference": "struct@stb/stb_textedit.h:313:1" + }, + { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "x0", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x0" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 362, + "column": 4, + "source_line": " float x0,x1; // starting x location, end x location (allows for align=right, etc)" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "x1", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x1" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 362, + "column": 4, + "source_line": " float x0,x1; // starting x location, end x location (allows for align=right, etc)" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "baseline_y_delta", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float baseline_y_delta" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 363, + "column": 4, + "source_line": " float baseline_y_delta; // position of baseline relative to previous row's baseline" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "ymin", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float ymin" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 364, + "column": 4, + "source_line": " float ymin,ymax; // height of row above and below baseline" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "ymax", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float ymax" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 364, + "column": 4, + "source_line": " float ymin,ymax; // height of row above and below baseline" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "num_chars", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_chars" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 365, + "column": 4, + "source_line": " int num_chars;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_textedit.h:360:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 360, + "column": 1, + "source_line": "typedef struct" + } + }, + { + "reference": "struct@stb/stb_textedit.h:504:1" + } + ], + "unions": [], + "enums": [], + "typedefs": [ + { + "reference": "StbUndoRecord" + }, + { + "reference": "StbUndoState" + }, + { + "reference": "STB_TexteditState" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "StbTexteditRow", + "name": "StbTexteditRow", + "type": { + "reference": "struct@stb/stb_textedit.h:360:1" + }, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 360, + "column": 1, + "source_line": "typedef struct" + }, + "declaration_locations": [] + }, + { + "reference": "StbFindState" + } + ], + "variables": [], + "macros": [ + { + "name": "INCLUDE_STB_TEXTEDIT_H", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 271, + "column": 1, + "source_line": "#define INCLUDE_STB_TEXTEDIT_H" + } + }, + { + "name": "STB_TEXTEDIT_UNDOSTATECOUNT", + "value": "99", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 283, + "column": 1, + "source_line": "#define STB_TEXTEDIT_UNDOSTATECOUNT 99" + } + }, + { + "name": "STB_TEXTEDIT_UNDOCHARCOUNT", + "value": "999", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 286, + "column": 1, + "source_line": "#define STB_TEXTEDIT_UNDOCHARCOUNT 999" + } + }, + { + "name": "STB_TEXTEDIT_CHARTYPE", + "value": "int", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 289, + "column": 1, + "source_line": "#define STB_TEXTEDIT_CHARTYPE int" + } + }, + { + "name": "STB_TEXTEDIT_POSITIONTYPE", + "value": "int", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 292, + "column": 1, + "source_line": "#define STB_TEXTEDIT_POSITIONTYPE int" + } + }, + { + "name": "STB_TEXTEDIT_memmove", + "value": "memmove", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 384, + "column": 1, + "source_line": "#define STB_TEXTEDIT_memmove memmove" + } + }, + { + "name": "STB_TEXT_HAS_SELECTION", + "value": "((s)->select_start != (s)->select_end)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 570, + "column": 1, + "source_line": "#define STB_TEXT_HAS_SELECTION(s) ((s)->select_start != (s)->select_end)" + } + }, + { + "name": "STB_TEXTEDIT_MOVEWORDLEFT", + "value": "stb_textedit_move_to_word_previous", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 661, + "column": 1, + "source_line": "#define STB_TEXTEDIT_MOVEWORDLEFT stb_textedit_move_to_word_previous" + } + }, + { + "name": "STB_TEXTEDIT_MOVEWORDRIGHT", + "value": "stb_textedit_move_to_word_next", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 677, + "column": 1, + "source_line": "#define STB_TEXTEDIT_MOVEWORDRIGHT stb_textedit_move_to_word_next" + } + }, + { + "name": "STB_TEXTEDIT_KEYTYPE", + "value": "int", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 720, + "column": 1, + "source_line": "#define STB_TEXTEDIT_KEYTYPE int" + } + } + ], + "includes": [ + { + "target": "string.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 383, + "column": 1, + "source_line": "#include " + } + } + ], + "raw_directives": [ + { + "directive": "ifndef", + "argument": "INCLUDE_STB_TEXTEDIT_H", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 270, + "column": 1, + "source_line": "#ifndef INCLUDE_STB_TEXTEDIT_H" + } + }, + { + "directive": "ifndef", + "argument": "STB_TEXTEDIT_UNDOSTATECOUNT", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 282, + "column": 1, + "source_line": "#ifndef STB_TEXTEDIT_UNDOSTATECOUNT" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 284, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_TEXTEDIT_UNDOCHARCOUNT", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 285, + "column": 1, + "source_line": "#ifndef STB_TEXTEDIT_UNDOCHARCOUNT" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 287, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_TEXTEDIT_CHARTYPE", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 288, + "column": 1, + "source_line": "#ifndef STB_TEXTEDIT_CHARTYPE" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 290, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_TEXTEDIT_POSITIONTYPE", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 291, + "column": 1, + "source_line": "#ifndef STB_TEXTEDIT_POSITIONTYPE" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 293, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 367, + "column": 1, + "source_line": "#endif //INCLUDE_STB_TEXTEDIT_H" + } + }, + { + "directive": "ifdef", + "argument": "STB_TEXTEDIT_IMPLEMENTATION", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 380, + "column": 1, + "source_line": "#ifdef STB_TEXTEDIT_IMPLEMENTATION" + } + }, + { + "directive": "ifndef", + "argument": "STB_TEXTEDIT_memmove", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 382, + "column": 1, + "source_line": "#ifndef STB_TEXTEDIT_memmove" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 385, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STB_TEXTEDIT_IS_SPACE", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 643, + "column": 1, + "source_line": "#ifdef STB_TEXTEDIT_IS_SPACE" + } + }, + { + "directive": "ifndef", + "argument": "STB_TEXTEDIT_MOVEWORDLEFT", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 649, + "column": 1, + "source_line": "#ifndef STB_TEXTEDIT_MOVEWORDLEFT" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 662, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_TEXTEDIT_MOVEWORDRIGHT", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 664, + "column": 1, + "source_line": "#ifndef STB_TEXTEDIT_MOVEWORDRIGHT" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 678, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 680, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_TEXTEDIT_KEYTYPE", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 719, + "column": 1, + "source_line": "#ifndef STB_TEXTEDIT_KEYTYPE" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 721, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STB_TEXTEDIT_K_INSERT", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 756, + "column": 1, + "source_line": "#ifdef STB_TEXTEDIT_K_INSERT" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 760, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STB_TEXTEDIT_MOVEWORDLEFT", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 802, + "column": 1, + "source_line": "#ifdef STB_TEXTEDIT_MOVEWORDLEFT" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 821, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STB_TEXTEDIT_MOVEWORDRIGHT", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 823, + "column": 1, + "source_line": "#ifdef STB_TEXTEDIT_MOVEWORDRIGHT" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 842, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STB_TEXTEDIT_GETWIDTH_NEWLINE", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 891, + "column": 16, + "source_line": " #ifdef STB_TEXTEDIT_GETWIDTH_NEWLINE" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 894, + "column": 16, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "STB_TEXTEDIT_GETWIDTH_NEWLINE", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 953, + "column": 16, + "source_line": " #ifdef STB_TEXTEDIT_GETWIDTH_NEWLINE" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 956, + "column": 16, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "STB_TEXTEDIT_K_TEXTSTART2", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 1007, + "column": 1, + "source_line": "#ifdef STB_TEXTEDIT_K_TEXTSTART2" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 1009, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STB_TEXTEDIT_K_TEXTEND2", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 1015, + "column": 1, + "source_line": "#ifdef STB_TEXTEDIT_K_TEXTEND2" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 1017, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STB_TEXTEDIT_K_TEXTSTART2", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 1024, + "column": 1, + "source_line": "#ifdef STB_TEXTEDIT_K_TEXTSTART2" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 1026, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STB_TEXTEDIT_K_TEXTEND2", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 1033, + "column": 1, + "source_line": "#ifdef STB_TEXTEDIT_K_TEXTEND2" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 1035, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STB_TEXTEDIT_K_LINESTART2", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 1043, + "column": 1, + "source_line": "#ifdef STB_TEXTEDIT_K_LINESTART2" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 1045, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STB_TEXTEDIT_K_LINEEND2", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 1056, + "column": 1, + "source_line": "#ifdef STB_TEXTEDIT_K_LINEEND2" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 1058, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STB_TEXTEDIT_K_LINESTART2", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 1071, + "column": 1, + "source_line": "#ifdef STB_TEXTEDIT_K_LINESTART2" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 1073, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STB_TEXTEDIT_K_LINEEND2", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 1085, + "column": 1, + "source_line": "#ifdef STB_TEXTEDIT_K_LINEEND2" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 1087, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "defined(__GNUC__) || defined(__clang__)", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 1373, + "column": 1, + "source_line": "#if defined(__GNUC__) || defined(__clang__)" + } + }, + { + "directive": "pragma", + "argument": "GCC diagnostic push", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 1374, + "column": 1, + "source_line": "#pragma GCC diagnostic push" + } + }, + { + "directive": "pragma", + "argument": "GCC diagnostic ignored \"-Wcast-qual\"", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 1375, + "column": 1, + "source_line": "#pragma GCC diagnostic ignored \"-Wcast-qual\"" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 1376, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "defined(__GNUC__) || defined(__clang__)", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 1383, + "column": 1, + "source_line": "#if defined(__GNUC__) || defined(__clang__)" + } + }, + { + "directive": "pragma", + "argument": "GCC diagnostic pop", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 1384, + "column": 1, + "source_line": "#pragma GCC diagnostic pop" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 1385, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 1387, + "column": 1, + "source_line": "#endif//STB_TEXTEDIT_IMPLEMENTATION" + } + } + ], + "macro_dependencies": [ + { + "name": "STB_TEXTEDIT_CHARTYPE", + "context": "declaration", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 1185, + "column": 1, + "source_line": "static STB_TEXTEDIT_CHARTYPE *stb_text_createundo(StbUndoState *state, int pos, int insert_len, int delete_len)" + }, + "source_text": "static STB_TEXTEDIT_CHARTYPE *stb_text_createundo(StbUndoState *state, int pos, int insert_len, int delete_len)" + } + ], + "diagnostics": [ + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STB_TEXT_HAS_SELECTION' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_textedit.h", + "line": 570, + "column": 1, + "source_line": "#define STB_TEXT_HAS_SELECTION(s) ((s)->select_start != (s)->select_end)" + }, + "unit_kind": "macro", + "unit_name": "STB_TEXT_HAS_SELECTION" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STB_TEXTEDIT_CHARTYPE'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_textedit.h", + "line": 1185, + "column": 1, + "source_line": "static STB_TEXTEDIT_CHARTYPE *stb_text_createundo(StbUndoState *state, int pos, int insert_len, int delete_len)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STB_TEXTEDIT_CHARTYPE" + } + ] + } + }, + "functions": { + "stb_text_locate_coord": { + "name": "stb_text_locate_coord", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TEXTEDIT_STRING" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TEXTEDIT_STRING" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 394, + "column": 1, + "source_line": "static int stb_text_locate_coord(STB_TEXTEDIT_STRING *str, float x, float y)" + }, + "start": { + "filename": "stb/stb_textedit.h", + "line": 394, + "column": 1, + "source_line": "static int stb_text_locate_coord(STB_TEXTEDIT_STRING *str, float x, float y)" + }, + "end": { + "filename": "stb/stb_textedit.h", + "line": 451, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_textedit_click": { + "name": "stb_textedit_click", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TEXTEDIT_STRING" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TEXTEDIT_STRING" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "state", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 454, + "column": 1, + "source_line": "static void stb_textedit_click(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, float x, float y)" + }, + "start": { + "filename": "stb/stb_textedit.h", + "line": 454, + "column": 1, + "source_line": "static void stb_textedit_click(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, float x, float y)" + }, + "end": { + "filename": "stb/stb_textedit.h", + "line": 469, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_textedit_drag": { + "name": "stb_textedit_drag", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TEXTEDIT_STRING" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TEXTEDIT_STRING" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "state", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 472, + "column": 1, + "source_line": "static void stb_textedit_drag(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, float x, float y)" + }, + "start": { + "filename": "stb/stb_textedit.h", + "line": 472, + "column": 1, + "source_line": "static void stb_textedit_drag(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, float x, float y)" + }, + "end": { + "filename": "stb/stb_textedit.h", + "line": 490, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_text_undo": { + "name": "stb_text_undo", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TEXTEDIT_STRING" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TEXTEDIT_STRING" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "state", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 1205, + "column": 1, + "source_line": "static void stb_text_undo(STB_TEXTEDIT_STRING *str, STB_TexteditState *state)" + }, + "start": { + "filename": "stb/stb_textedit.h", + "line": 1205, + "column": 1, + "source_line": "static void stb_text_undo(STB_TEXTEDIT_STRING *str, STB_TexteditState *state)" + }, + "end": { + "filename": "stb/stb_textedit.h", + "line": 1271, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_textedit.h", + "line": 498, + "column": 1, + "source_line": "static void stb_text_undo(STB_TEXTEDIT_STRING *str, STB_TexteditState *state);" + } + ] + }, + "stb_text_redo": { + "name": "stb_text_redo", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TEXTEDIT_STRING" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TEXTEDIT_STRING" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "state", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 1273, + "column": 1, + "source_line": "static void stb_text_redo(STB_TEXTEDIT_STRING *str, STB_TexteditState *state)" + }, + "start": { + "filename": "stb/stb_textedit.h", + "line": 1273, + "column": 1, + "source_line": "static void stb_text_redo(STB_TEXTEDIT_STRING *str, STB_TexteditState *state)" + }, + "end": { + "filename": "stb/stb_textedit.h", + "line": 1322, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_textedit.h", + "line": 499, + "column": 1, + "source_line": "static void stb_text_redo(STB_TEXTEDIT_STRING *str, STB_TexteditState *state);" + } + ] + }, + "stb_text_makeundo_delete": { + "name": "stb_text_makeundo_delete", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TEXTEDIT_STRING" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TEXTEDIT_STRING" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "state", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "where", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int where" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int where" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "length", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int length" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int length" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 1329, + "column": 1, + "source_line": "static void stb_text_makeundo_delete(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, int where, int length)" + }, + "start": { + "filename": "stb/stb_textedit.h", + "line": 1329, + "column": 1, + "source_line": "static void stb_text_makeundo_delete(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, int where, int length)" + }, + "end": { + "filename": "stb/stb_textedit.h", + "line": 1337, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_textedit.h", + "line": 500, + "column": 1, + "source_line": "static void stb_text_makeundo_delete(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, int where, int length);" + } + ] + }, + "stb_text_makeundo_insert": { + "name": "stb_text_makeundo_insert", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "state", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "where", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int where" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int where" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "length", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int length" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int length" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 1324, + "column": 1, + "source_line": "static void stb_text_makeundo_insert(STB_TexteditState *state, int where, int length)" + }, + "start": { + "filename": "stb/stb_textedit.h", + "line": 1324, + "column": 1, + "source_line": "static void stb_text_makeundo_insert(STB_TexteditState *state, int where, int length)" + }, + "end": { + "filename": "stb/stb_textedit.h", + "line": 1327, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_textedit.h", + "line": 501, + "column": 1, + "source_line": "static void stb_text_makeundo_insert(STB_TexteditState *state, int where, int length);" + } + ] + }, + "stb_text_makeundo_replace": { + "name": "stb_text_makeundo_replace", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TEXTEDIT_STRING" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TEXTEDIT_STRING" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "state", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "where", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int where" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int where" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "old_length", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int old_length" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int old_length" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "new_length", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int new_length" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int new_length" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 1339, + "column": 1, + "source_line": "static void stb_text_makeundo_replace(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, int where, int old_length, int new_length)" + }, + "start": { + "filename": "stb/stb_textedit.h", + "line": 1339, + "column": 1, + "source_line": "static void stb_text_makeundo_replace(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, int where, int old_length, int new_length)" + }, + "end": { + "filename": "stb/stb_textedit.h", + "line": 1347, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_textedit.h", + "line": 502, + "column": 1, + "source_line": "static void stb_text_makeundo_replace(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, int where, int old_length, int new_length);" + } + ] + }, + "stb_textedit_find_charpos": { + "name": "stb_textedit_find_charpos", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "find", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "StbFindState *find", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "StbFindState" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "StbFindState *find", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "StbFindState" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TEXTEDIT_STRING" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TEXTEDIT_STRING" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "single_line", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int single_line" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int single_line" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 514, + "column": 1, + "source_line": "static void stb_textedit_find_charpos(StbFindState *find, STB_TEXTEDIT_STRING *str, int n, int single_line)" + }, + "start": { + "filename": "stb/stb_textedit.h", + "line": 514, + "column": 1, + "source_line": "static void stb_textedit_find_charpos(StbFindState *find, STB_TEXTEDIT_STRING *str, int n, int single_line)" + }, + "end": { + "filename": "stb/stb_textedit.h", + "line": 568, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_textedit_clamp": { + "name": "stb_textedit_clamp", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TEXTEDIT_STRING" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TEXTEDIT_STRING" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "state", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 573, + "column": 1, + "source_line": "static void stb_textedit_clamp(STB_TEXTEDIT_STRING *str, STB_TexteditState *state)" + }, + "start": { + "filename": "stb/stb_textedit.h", + "line": 573, + "column": 1, + "source_line": "static void stb_textedit_clamp(STB_TEXTEDIT_STRING *str, STB_TexteditState *state)" + }, + "end": { + "filename": "stb/stb_textedit.h", + "line": 584, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_textedit_delete": { + "name": "stb_textedit_delete", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TEXTEDIT_STRING" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TEXTEDIT_STRING" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "state", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "where", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int where" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int where" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 587, + "column": 1, + "source_line": "static void stb_textedit_delete(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, int where, int len)" + }, + "start": { + "filename": "stb/stb_textedit.h", + "line": 587, + "column": 1, + "source_line": "static void stb_textedit_delete(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, int where, int len)" + }, + "end": { + "filename": "stb/stb_textedit.h", + "line": 592, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_textedit_delete_selection": { + "name": "stb_textedit_delete_selection", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TEXTEDIT_STRING" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TEXTEDIT_STRING" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "state", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 595, + "column": 1, + "source_line": "static void stb_textedit_delete_selection(STB_TEXTEDIT_STRING *str, STB_TexteditState *state)" + }, + "start": { + "filename": "stb/stb_textedit.h", + "line": 595, + "column": 1, + "source_line": "static void stb_textedit_delete_selection(STB_TEXTEDIT_STRING *str, STB_TexteditState *state)" + }, + "end": { + "filename": "stb/stb_textedit.h", + "line": 608, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_textedit_sortselection": { + "name": "stb_textedit_sortselection", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "state", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 611, + "column": 1, + "source_line": "static void stb_textedit_sortselection(STB_TexteditState *state)" + }, + "start": { + "filename": "stb/stb_textedit.h", + "line": 611, + "column": 1, + "source_line": "static void stb_textedit_sortselection(STB_TexteditState *state)" + }, + "end": { + "filename": "stb/stb_textedit.h", + "line": 618, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_textedit_move_to_first": { + "name": "stb_textedit_move_to_first", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "state", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 621, + "column": 1, + "source_line": "static void stb_textedit_move_to_first(STB_TexteditState *state)" + }, + "start": { + "filename": "stb/stb_textedit.h", + "line": 621, + "column": 1, + "source_line": "static void stb_textedit_move_to_first(STB_TexteditState *state)" + }, + "end": { + "filename": "stb/stb_textedit.h", + "line": 629, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_textedit_move_to_last": { + "name": "stb_textedit_move_to_last", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TEXTEDIT_STRING" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TEXTEDIT_STRING" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "state", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 632, + "column": 1, + "source_line": "static void stb_textedit_move_to_last(STB_TEXTEDIT_STRING *str, STB_TexteditState *state)" + }, + "start": { + "filename": "stb/stb_textedit.h", + "line": 632, + "column": 1, + "source_line": "static void stb_textedit_move_to_last(STB_TEXTEDIT_STRING *str, STB_TexteditState *state)" + }, + "end": { + "filename": "stb/stb_textedit.h", + "line": 641, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "is_word_boundary": { + "name": "is_word_boundary", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TEXTEDIT_STRING" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TEXTEDIT_STRING" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "idx", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int idx" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int idx" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 644, + "column": 1, + "source_line": "static int is_word_boundary( STB_TEXTEDIT_STRING *str, int idx )" + }, + "start": { + "filename": "stb/stb_textedit.h", + "line": 644, + "column": 1, + "source_line": "static int is_word_boundary( STB_TEXTEDIT_STRING *str, int idx )" + }, + "end": { + "filename": "stb/stb_textedit.h", + "line": 647, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_textedit_move_to_word_previous": { + "name": "stb_textedit_move_to_word_previous", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TEXTEDIT_STRING" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TEXTEDIT_STRING" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 650, + "column": 1, + "source_line": "static int stb_textedit_move_to_word_previous( STB_TEXTEDIT_STRING *str, int c )" + }, + "start": { + "filename": "stb/stb_textedit.h", + "line": 650, + "column": 1, + "source_line": "static int stb_textedit_move_to_word_previous( STB_TEXTEDIT_STRING *str, int c )" + }, + "end": { + "filename": "stb/stb_textedit.h", + "line": 660, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_textedit_move_to_word_next": { + "name": "stb_textedit_move_to_word_next", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TEXTEDIT_STRING" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TEXTEDIT_STRING" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int c" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 665, + "column": 1, + "source_line": "static int stb_textedit_move_to_word_next( STB_TEXTEDIT_STRING *str, int c )" + }, + "start": { + "filename": "stb/stb_textedit.h", + "line": 665, + "column": 1, + "source_line": "static int stb_textedit_move_to_word_next( STB_TEXTEDIT_STRING *str, int c )" + }, + "end": { + "filename": "stb/stb_textedit.h", + "line": 676, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_textedit_prep_selection_at_cursor": { + "name": "stb_textedit_prep_selection_at_cursor", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "state", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 683, + "column": 1, + "source_line": "static void stb_textedit_prep_selection_at_cursor(STB_TexteditState *state)" + }, + "start": { + "filename": "stb/stb_textedit.h", + "line": 683, + "column": 1, + "source_line": "static void stb_textedit_prep_selection_at_cursor(STB_TexteditState *state)" + }, + "end": { + "filename": "stb/stb_textedit.h", + "line": 689, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_textedit_cut": { + "name": "stb_textedit_cut", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TEXTEDIT_STRING" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TEXTEDIT_STRING" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "state", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 692, + "column": 1, + "source_line": "static int stb_textedit_cut(STB_TEXTEDIT_STRING *str, STB_TexteditState *state)" + }, + "start": { + "filename": "stb/stb_textedit.h", + "line": 692, + "column": 1, + "source_line": "static int stb_textedit_cut(STB_TEXTEDIT_STRING *str, STB_TexteditState *state)" + }, + "end": { + "filename": "stb/stb_textedit.h", + "line": 700, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_textedit_paste_internal": { + "name": "stb_textedit_paste_internal", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TEXTEDIT_STRING" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TEXTEDIT_STRING" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "state", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "text", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_CHARTYPE *text", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TEXTEDIT_CHARTYPE" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_CHARTYPE *text", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TEXTEDIT_CHARTYPE" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 703, + "column": 1, + "source_line": "static int stb_textedit_paste_internal(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, STB_TEXTEDIT_CHARTYPE *text, int len)" + }, + "start": { + "filename": "stb/stb_textedit.h", + "line": 703, + "column": 1, + "source_line": "static int stb_textedit_paste_internal(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, STB_TEXTEDIT_CHARTYPE *text, int len)" + }, + "end": { + "filename": "stb/stb_textedit.h", + "line": 717, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_textedit_key": { + "name": "stb_textedit_key", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TEXTEDIT_STRING" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TEXTEDIT_STRING" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "state", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "key", + "type": { + "reference": "STB_TEXTEDIT_KEYTYPE" + }, + "declared_type": { + "reference": "STB_TEXTEDIT_KEYTYPE" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 724, + "column": 1, + "source_line": "static void stb_textedit_key(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, STB_TEXTEDIT_KEYTYPE key)" + }, + "start": { + "filename": "stb/stb_textedit.h", + "line": 724, + "column": 1, + "source_line": "static void stb_textedit_key(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, STB_TEXTEDIT_KEYTYPE key)" + }, + "end": { + "filename": "stb/stb_textedit.h", + "line": 1101, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_textedit_flush_redo": { + "name": "stb_textedit_flush_redo", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "state", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "StbUndoState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "StbUndoState" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "StbUndoState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "StbUndoState" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 1109, + "column": 1, + "source_line": "static void stb_textedit_flush_redo(StbUndoState *state)" + }, + "start": { + "filename": "stb/stb_textedit.h", + "line": 1109, + "column": 1, + "source_line": "static void stb_textedit_flush_redo(StbUndoState *state)" + }, + "end": { + "filename": "stb/stb_textedit.h", + "line": 1113, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_textedit_discard_undo": { + "name": "stb_textedit_discard_undo", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "state", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "StbUndoState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "StbUndoState" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "StbUndoState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "StbUndoState" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 1116, + "column": 1, + "source_line": "static void stb_textedit_discard_undo(StbUndoState *state)" + }, + "start": { + "filename": "stb/stb_textedit.h", + "line": 1116, + "column": 1, + "source_line": "static void stb_textedit_discard_undo(StbUndoState *state)" + }, + "end": { + "filename": "stb/stb_textedit.h", + "line": 1132, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_textedit_discard_redo": { + "name": "stb_textedit_discard_redo", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "state", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "StbUndoState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "StbUndoState" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "StbUndoState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "StbUndoState" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 1138, + "column": 1, + "source_line": "static void stb_textedit_discard_redo(StbUndoState *state)" + }, + "start": { + "filename": "stb/stb_textedit.h", + "line": 1138, + "column": 1, + "source_line": "static void stb_textedit_discard_redo(StbUndoState *state)" + }, + "end": { + "filename": "stb/stb_textedit.h", + "line": 1159, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_text_create_undo_record": { + "name": "stb_text_create_undo_record", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "StbUndoRecord", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "StbUndoRecord" + } + ] + }, + "parameters": [ + { + "name": "state", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "StbUndoState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "StbUndoState" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "StbUndoState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "StbUndoState" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "numchars", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int numchars" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int numchars" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 1161, + "column": 1, + "source_line": "static StbUndoRecord *stb_text_create_undo_record(StbUndoState *state, int numchars)" + }, + "start": { + "filename": "stb/stb_textedit.h", + "line": 1161, + "column": 1, + "source_line": "static StbUndoRecord *stb_text_create_undo_record(StbUndoState *state, int numchars)" + }, + "end": { + "filename": "stb/stb_textedit.h", + "line": 1183, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_textedit_clear_state": { + "name": "stb_textedit_clear_state", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "state", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "is_single_line", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int is_single_line" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int is_single_line" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 1350, + "column": 1, + "source_line": "static void stb_textedit_clear_state(STB_TexteditState *state, int is_single_line)" + }, + "start": { + "filename": "stb/stb_textedit.h", + "line": 1350, + "column": 1, + "source_line": "static void stb_textedit_clear_state(STB_TexteditState *state, int is_single_line)" + }, + "end": { + "filename": "stb/stb_textedit.h", + "line": 1365, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_textedit_initialize_state": { + "name": "stb_textedit_initialize_state", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "state", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "is_single_line", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int is_single_line" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int is_single_line" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 1368, + "column": 1, + "source_line": "static void stb_textedit_initialize_state(STB_TexteditState *state, int is_single_line)" + }, + "start": { + "filename": "stb/stb_textedit.h", + "line": 1368, + "column": 1, + "source_line": "static void stb_textedit_initialize_state(STB_TexteditState *state, int is_single_line)" + }, + "end": { + "filename": "stb/stb_textedit.h", + "line": 1371, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_textedit_paste": { + "name": "stb_textedit_paste", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TEXTEDIT_STRING" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_STRING *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TEXTEDIT_STRING" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "state", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TexteditState *state", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TexteditState" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ctext", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_CHARTYPE const *ctext", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TEXTEDIT_CHARTYPE" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "STB_TEXTEDIT_CHARTYPE const *ctext", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "STB_TEXTEDIT_CHARTYPE" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 1378, + "column": 1, + "source_line": "static int stb_textedit_paste(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, STB_TEXTEDIT_CHARTYPE const *ctext, int len)" + }, + "start": { + "filename": "stb/stb_textedit.h", + "line": 1378, + "column": 1, + "source_line": "static int stb_textedit_paste(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, STB_TEXTEDIT_CHARTYPE const *ctext, int len)" + }, + "end": { + "filename": "stb/stb_textedit.h", + "line": 1381, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + } + }, + "structs": {}, + "unions": {}, + "enums": {}, + "typedefs": { + "StbUndoRecord": { + "reference": "StbUndoRecord" + }, + "StbUndoState": { + "reference": "StbUndoState" + }, + "STB_TexteditState": { + "reference": "STB_TexteditState" + }, + "StbTexteditRow": { + "reference": "StbTexteditRow" + }, + "StbFindState": { + "reference": "StbFindState" + } + }, + "variables": {}, + "macros": { + "INCLUDE_STB_TEXTEDIT_H": { + "name": "INCLUDE_STB_TEXTEDIT_H", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 271, + "column": 1, + "source_line": "#define INCLUDE_STB_TEXTEDIT_H" + } + }, + "STB_TEXTEDIT_UNDOSTATECOUNT": { + "name": "STB_TEXTEDIT_UNDOSTATECOUNT", + "value": "99", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 283, + "column": 1, + "source_line": "#define STB_TEXTEDIT_UNDOSTATECOUNT 99" + } + }, + "STB_TEXTEDIT_UNDOCHARCOUNT": { + "name": "STB_TEXTEDIT_UNDOCHARCOUNT", + "value": "999", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 286, + "column": 1, + "source_line": "#define STB_TEXTEDIT_UNDOCHARCOUNT 999" + } + }, + "STB_TEXTEDIT_CHARTYPE": { + "name": "STB_TEXTEDIT_CHARTYPE", + "value": "int", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 289, + "column": 1, + "source_line": "#define STB_TEXTEDIT_CHARTYPE int" + } + }, + "STB_TEXTEDIT_POSITIONTYPE": { + "name": "STB_TEXTEDIT_POSITIONTYPE", + "value": "int", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 292, + "column": 1, + "source_line": "#define STB_TEXTEDIT_POSITIONTYPE int" + } + }, + "STB_TEXTEDIT_memmove": { + "name": "STB_TEXTEDIT_memmove", + "value": "memmove", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 384, + "column": 1, + "source_line": "#define STB_TEXTEDIT_memmove memmove" + } + }, + "STB_TEXT_HAS_SELECTION": { + "name": "STB_TEXT_HAS_SELECTION", + "value": "((s)->select_start != (s)->select_end)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 570, + "column": 1, + "source_line": "#define STB_TEXT_HAS_SELECTION(s) ((s)->select_start != (s)->select_end)" + } + }, + "STB_TEXTEDIT_MOVEWORDLEFT": { + "name": "STB_TEXTEDIT_MOVEWORDLEFT", + "value": "stb_textedit_move_to_word_previous", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 661, + "column": 1, + "source_line": "#define STB_TEXTEDIT_MOVEWORDLEFT stb_textedit_move_to_word_previous" + } + }, + "STB_TEXTEDIT_MOVEWORDRIGHT": { + "name": "STB_TEXTEDIT_MOVEWORDRIGHT", + "value": "stb_textedit_move_to_word_next", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 677, + "column": 1, + "source_line": "#define STB_TEXTEDIT_MOVEWORDRIGHT stb_textedit_move_to_word_next" + } + }, + "STB_TEXTEDIT_KEYTYPE": { + "name": "STB_TEXTEDIT_KEYTYPE", + "value": "int", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 720, + "column": 1, + "source_line": "#define STB_TEXTEDIT_KEYTYPE int" + } + } + }, + "includes": { + "stb/stb_textedit.h:string.h": { + "target": "string.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_textedit.h", + "line": 383, + "column": 1, + "source_line": "#include " + } + } + }, + "functions_by_file": { + "stb/stb_textedit.h": [ + "stb_text_locate_coord", + "stb_textedit_click", + "stb_textedit_drag", + "stb_text_undo", + "stb_text_redo", + "stb_text_makeundo_delete", + "stb_text_makeundo_insert", + "stb_text_makeundo_replace", + "stb_textedit_find_charpos", + "stb_textedit_clamp", + "stb_textedit_delete", + "stb_textedit_delete_selection", + "stb_textedit_sortselection", + "stb_textedit_move_to_first", + "stb_textedit_move_to_last", + "is_word_boundary", + "stb_textedit_move_to_word_previous", + "stb_textedit_move_to_word_next", + "stb_textedit_prep_selection_at_cursor", + "stb_textedit_cut", + "stb_textedit_paste_internal", + "stb_textedit_key", + "stb_textedit_flush_redo", + "stb_textedit_discard_undo", + "stb_textedit_discard_redo", + "stb_text_create_undo_record", + "stb_textedit_clear_state", + "stb_textedit_initialize_state", + "stb_textedit_paste" + ] + }, + "enum_constants": {}, + "include_graph": { + "stb/stb_textedit.h": [] + }, + "system_includes": { + "stb/stb_textedit.h": [ + "string.h" + ] + }, + "unresolved_includes": { + "stb/stb_textedit.h": [] + }, + "header_source_pairs": { + "stb/stb_textedit.h": [] + }, + "diagnostics": [ + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STB_TEXT_HAS_SELECTION' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_textedit.h", + "line": 570, + "column": 1, + "source_line": "#define STB_TEXT_HAS_SELECTION(s) ((s)->select_start != (s)->select_end)" + }, + "unit_kind": "macro", + "unit_name": "STB_TEXT_HAS_SELECTION" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STB_TEXTEDIT_CHARTYPE'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_textedit.h", + "line": 1185, + "column": 1, + "source_line": "static STB_TEXTEDIT_CHARTYPE *stb_text_createundo(StbUndoState *state, int pos, int insert_len, int delete_len)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STB_TEXTEDIT_CHARTYPE" + } + ] +} diff --git a/tests/parser/c/fixtures/stb/stb_tilemap_editor.json b/tests/parser/c/fixtures/stb/stb_tilemap_editor.json new file mode 100644 index 000000000..86cc86c81 --- /dev/null +++ b/tests/parser/c/fixtures/stb/stb_tilemap_editor.json @@ -0,0 +1,35388 @@ +{ + "files": { + "stb/stb_tilemap_editor.h": { + "filename": "stb/stb_tilemap_editor.h", + "language": "c", + "parser_status": "partial", + "preprocessing": "raw", + "functions": [ + { + "name": "stbte_create_map", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbte_tilemap", + "name": "stbte_tilemap", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": "stbte_tilemap", + "members": [ + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte__tiledata data[STBTE_MAX_TILEMAP_Y][STBTE_MAX_TILEMAP_X][STBTE_MAX_LAYERS]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STBTE_MAX_TILEMAP_Y", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STBTE_MAX_TILEMAP_X", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STBTE_MAX_LAYERS", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbte__tiledata", + "name": "stbte__tiledata", + "type": { + "model": "CShort", + "qualifiers": [], + "source_text": "typedef short stbte__tiledata" + }, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 792, + "column": 1, + "source_line": "typedef short stbte__tiledata;" + }, + "declaration_locations": [] + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 944, + "column": 5, + "source_line": " stbte__tiledata data[STBTE_MAX_TILEMAP_Y][STBTE_MAX_TILEMAP_X][STBTE_MAX_LAYERS];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "props", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float props[STBTE_MAX_TILEMAP_Y][STBTE_MAX_TILEMAP_X][STBTE_MAX_PROPERTIES]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STBTE_MAX_TILEMAP_Y", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STBTE_MAX_TILEMAP_X", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STBTE_MAX_PROPERTIES", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 945, + "column": 5, + "source_line": " float props[STBTE_MAX_TILEMAP_Y][STBTE_MAX_TILEMAP_X][STBTE_MAX_PROPERTIES];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "link", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte__link link[STBTE_MAX_TILEMAP_Y][STBTE_MAX_TILEMAP_X]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STBTE_MAX_TILEMAP_Y", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STBTE_MAX_TILEMAP_X", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbte__link", + "name": "stbte__link", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "x", + "type": { + "model": "CShort", + "qualifiers": [], + "source_text": "short x" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 597, + "column": 4, + "source_line": " short x,y;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "y", + "type": { + "model": "CShort", + "qualifiers": [], + "source_text": "short y" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 597, + "column": 4, + "source_line": " short x,y;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_tilemap_editor.h:595:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 595, + "column": 1, + "source_line": "typedef struct" + } + }, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 595, + "column": 1, + "source_line": "typedef struct" + }, + "declaration_locations": [] + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 947, + "column": 5, + "source_line": " stbte__link link[STBTE_MAX_TILEMAP_Y][STBTE_MAX_TILEMAP_X];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "linkcount", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int linkcount[STBTE_MAX_TILEMAP_Y][STBTE_MAX_TILEMAP_X]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STBTE_MAX_TILEMAP_Y", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STBTE_MAX_TILEMAP_X", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 948, + "column": 5, + "source_line": " int linkcount[STBTE_MAX_TILEMAP_Y][STBTE_MAX_TILEMAP_X];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "max_x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int max_x" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 950, + "column": 5, + "source_line": " int max_x, max_y, num_layers;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "max_y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int max_y" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 950, + "column": 5, + "source_line": " int max_x, max_y, num_layers;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "num_layers", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_layers" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 950, + "column": 5, + "source_line": " int max_x, max_y, num_layers;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "spacing_x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int spacing_x" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 951, + "column": 5, + "source_line": " int spacing_x, spacing_y;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "spacing_y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int spacing_y" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 951, + "column": 5, + "source_line": " int spacing_x, spacing_y;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "palette_spacing_x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int palette_spacing_x" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 952, + "column": 5, + "source_line": " int palette_spacing_x, palette_spacing_y;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "palette_spacing_y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int palette_spacing_y" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 952, + "column": 5, + "source_line": " int palette_spacing_x, palette_spacing_y;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "scroll_x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int scroll_x" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 953, + "column": 5, + "source_line": " int scroll_x,scroll_y;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "scroll_y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int scroll_y" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 953, + "column": 5, + "source_line": " int scroll_x,scroll_y;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "cur_category", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int cur_category" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 954, + "column": 5, + "source_line": " int cur_category, cur_tile, cur_layer;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "cur_tile", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int cur_tile" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 954, + "column": 5, + "source_line": " int cur_category, cur_tile, cur_layer;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "cur_layer", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int cur_layer" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 954, + "column": 5, + "source_line": " int cur_category, cur_tile, cur_layer;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "categories", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *categories[STBTE_MAX_CATEGORIES]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STBTE_MAX_CATEGORIES", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 955, + "column": 5, + "source_line": " char *categories[STBTE_MAX_CATEGORIES];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "num_categories", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_categories" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 956, + "column": 5, + "source_line": " int num_categories, category_scroll;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "category_scroll", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int category_scroll" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 956, + "column": 5, + "source_line": " int num_categories, category_scroll;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "tiles", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte__tileinfo *tiles", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbte__tileinfo", + "name": "stbte__tileinfo", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "id", + "type": { + "model": "CShort", + "qualifiers": [], + "source_text": "short id" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 784, + "column": 4, + "source_line": " short id;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "category_id", + "type": { + "model": "CUnsignedShort", + "qualifiers": [], + "source_text": "unsigned short category_id" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 785, + "column": 4, + "source_line": " unsigned short category_id;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "category", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *category", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 786, + "column": 4, + "source_line": " char *category;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "layermask", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int layermask" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 787, + "column": 4, + "source_line": " unsigned int layermask;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_tilemap_editor.h:782:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 782, + "column": 1, + "source_line": "typedef struct" + } + }, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 782, + "column": 1, + "source_line": "typedef struct" + }, + "declaration_locations": [] + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 957, + "column": 5, + "source_line": " stbte__tileinfo *tiles;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "num_tiles", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_tiles" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 958, + "column": 5, + "source_line": " int num_tiles, max_tiles, digits;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "max_tiles", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int max_tiles" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 958, + "column": 5, + "source_line": " int num_tiles, max_tiles, digits;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "digits", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int digits" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 958, + "column": 5, + "source_line": " int num_tiles, max_tiles, digits;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "undo_available_valid", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char undo_available_valid" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 959, + "column": 5, + "source_line": " unsigned char undo_available_valid;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "undo_available", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char undo_available" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 960, + "column": 5, + "source_line": " unsigned char undo_available;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "redo_available", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char redo_available" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 961, + "column": 5, + "source_line": " unsigned char redo_available;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "padding", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char padding" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 962, + "column": 5, + "source_line": " unsigned char padding;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "cur_palette_count", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int cur_palette_count" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 963, + "column": 5, + "source_line": " int cur_palette_count;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "palette_scroll", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int palette_scroll" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 964, + "column": 5, + "source_line": " int palette_scroll;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "tileinfo_dirty", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int tileinfo_dirty" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 965, + "column": 5, + "source_line": " int tileinfo_dirty;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "layerinfo", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte__layer layerinfo[STBTE_MAX_LAYERS]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STBTE_MAX_LAYERS", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbte__layer", + "name": "stbte__layer", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "name", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *name", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 930, + "column": 4, + "source_line": " const char *name;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "locked", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int locked" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 931, + "column": 4, + "source_line": " int locked;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "hidden", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int hidden" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 932, + "column": 4, + "source_line": " int hidden;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_tilemap_editor.h:928:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 928, + "column": 1, + "source_line": "typedef struct" + } + }, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 928, + "column": 1, + "source_line": "typedef struct" + }, + "declaration_locations": [] + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 966, + "column": 5, + "source_line": " stbte__layer layerinfo[STBTE_MAX_LAYERS];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "has_layer_names", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int has_layer_names" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 967, + "column": 5, + "source_line": " int has_layer_names;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "layername_width", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int layername_width" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 968, + "column": 5, + "source_line": " int layername_width;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "layer_scroll", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int layer_scroll" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 969, + "column": 5, + "source_line": " int layer_scroll;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "propmode", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int propmode" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 970, + "column": 5, + "source_line": " int propmode;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "solo_layer", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int solo_layer" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 971, + "column": 5, + "source_line": " int solo_layer;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "undo_pos", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int undo_pos" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 972, + "column": 5, + "source_line": " int undo_pos, undo_len, redo_len;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "undo_len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int undo_len" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 972, + "column": 5, + "source_line": " int undo_pos, undo_len, redo_len;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "redo_len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int redo_len" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 972, + "column": 5, + "source_line": " int undo_pos, undo_len, redo_len;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "background_tile", + "type": { + "model": "CShort", + "qualifiers": [], + "source_text": "short background_tile" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 973, + "column": 5, + "source_line": " short background_tile;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "id_in_use", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char id_in_use[32768>>3]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "32768>>3", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 974, + "column": 5, + "source_line": " unsigned char id_in_use[32768>>3];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "undo_buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short *undo_buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 975, + "column": 5, + "source_line": " short *undo_buffer;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": null, + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 942, + "column": 1, + "source_line": "struct stbte_tilemap" + } + }, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 345, + "column": 1, + "source_line": "typedef struct stbte_tilemap stbte_tilemap;" + }, + "declaration_locations": [] + } + ] + }, + "parameters": [ + { + "name": "map_x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int map_x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int map_x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "map_y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int map_y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int map_y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "map_layers", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int map_layers" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int map_layers" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "spacing_x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int spacing_x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int spacing_x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "spacing_y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int spacing_y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int spacing_y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "max_tiles", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int max_tiles" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int max_tiles" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1007, + "column": 1, + "source_line": "stbte_tilemap *stbte_create_map(int map_x, int map_y, int map_layers, int spacing_x, int spacing_y, int max_tiles)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1007, + "column": 1, + "source_line": "stbte_tilemap *stbte_create_map(int map_x, int map_y, int map_layers, int spacing_x, int spacing_y, int max_tiles)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1065, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_tilemap_editor.h", + "line": 367, + "column": 1, + "source_line": "extern stbte_tilemap *stbte_create_map(int map_x, int map_y, int map_layers, int spacing_x, int spacing_y, int max_tiles);" + } + ] + }, + { + "name": "stbte_define_tile", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "id", + "type": { + "model": "CUnsignedShort", + "qualifiers": [], + "source_text": "unsigned short id" + }, + "declared_type": { + "model": "CUnsignedShort", + "qualifiers": [], + "source_text": "unsigned short id" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "layermask", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int layermask" + }, + "declared_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int layermask" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "category_c", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * category_c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * category_c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1102, + "column": 1, + "source_line": "void stbte_define_tile(stbte_tilemap *tm, unsigned short id, unsigned int layermask, const char * category_c)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1102, + "column": 1, + "source_line": "void stbte_define_tile(stbte_tilemap *tm, unsigned short id, unsigned int layermask, const char * category_c)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1119, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_tilemap_editor.h", + "line": 378, + "column": 1, + "source_line": "extern void stbte_define_tile(stbte_tilemap *tm, unsigned short id, unsigned int layermask, const char * category);" + } + ] + }, + { + "name": "stbte_set_display", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "x0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1094, + "column": 1, + "source_line": "void stbte_set_display(int x0, int y0, int x1, int y1)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1094, + "column": 1, + "source_line": "void stbte_set_display(int x0, int y0, int x1, int y1)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1100, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_tilemap_editor.h", + "line": 387, + "column": 1, + "source_line": "extern void stbte_set_display(int x0, int y0, int x1, int y1);" + } + ] + }, + { + "name": "stbte_draw", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 4053, + "column": 1, + "source_line": "void stbte_draw(stbte_tilemap *tm)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 4053, + "column": 1, + "source_line": "void stbte_draw(stbte_tilemap *tm)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 4057, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_tilemap_editor.h", + "line": 396, + "column": 1, + "source_line": "extern void stbte_draw(stbte_tilemap *tm);" + } + ] + }, + { + "name": "stbte_tick", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dt", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dt" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dt" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 4106, + "column": 1, + "source_line": "void stbte_tick(stbte_tilemap *tm, float dt)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 4106, + "column": 1, + "source_line": "void stbte_tick(stbte_tilemap *tm, float dt)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 4112, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_tilemap_editor.h", + "line": 398, + "column": 1, + "source_line": "extern void stbte_tick(stbte_tilemap *tm, float time_in_seconds_since_last_frame);" + } + ] + }, + { + "name": "stbte_mouse_sdl", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "sdl_event", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const void *sdl_event", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [ + "const" + ], + "source_text": "const void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const void *sdl_event", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [ + "const" + ], + "source_text": "const void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "xs", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float xs" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float xs" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ys", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float ys" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float ys" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "xo", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int xo" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int xo" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "yo", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int yo" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int yo" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 4114, + "column": 1, + "source_line": "void stbte_mouse_sdl(stbte_tilemap *tm, const void *sdl_event, float xs, float ys, int xo, int yo)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 4114, + "column": 1, + "source_line": "void stbte_mouse_sdl(stbte_tilemap *tm, const void *sdl_event, float xs, float ys, int xo, int yo)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 4143, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_tilemap_editor.h", + "line": 407, + "column": 1, + "source_line": "extern void stbte_mouse_sdl(stbte_tilemap *tm, const void *sdl_event, float xscale, float yscale, int xoffset, int yoffset);" + } + ] + }, + { + "name": "stbte_mouse_move", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "shifted", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int shifted" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int shifted" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "scrollkey", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int scrollkey" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int scrollkey" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 4059, + "column": 1, + "source_line": "void stbte_mouse_move(stbte_tilemap *tm, int x, int y, int shifted, int scrollkey)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 4059, + "column": 1, + "source_line": "void stbte_mouse_move(stbte_tilemap *tm, int x, int y, int shifted, int scrollkey)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 4065, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_tilemap_editor.h", + "line": 410, + "column": 1, + "source_line": "extern void stbte_mouse_move(stbte_tilemap *tm, int x, int y, int shifted, int scrollkey);" + } + ] + }, + { + "name": "stbte_mouse_button", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "right", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int right" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int right" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "down", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int down" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int down" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "shifted", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int shifted" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int shifted" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "scrollkey", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int scrollkey" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int scrollkey" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 4067, + "column": 1, + "source_line": "void stbte_mouse_button(stbte_tilemap *tm, int x, int y, int right, int down, int shifted, int scrollkey)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 4067, + "column": 1, + "source_line": "void stbte_mouse_button(stbte_tilemap *tm, int x, int y, int right, int down, int shifted, int scrollkey)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 4076, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_tilemap_editor.h", + "line": 411, + "column": 1, + "source_line": "extern void stbte_mouse_button(stbte_tilemap *tm, int x, int y, int right, int down, int shifted, int scrollkey);" + } + ] + }, + { + "name": "stbte_mouse_wheel", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "vscroll", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int vscroll" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int vscroll" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 4078, + "column": 1, + "source_line": "void stbte_mouse_wheel(stbte_tilemap *tm, int x, int y, int vscroll)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 4078, + "column": 1, + "source_line": "void stbte_mouse_wheel(stbte_tilemap *tm, int x, int y, int vscroll)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 4081, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_tilemap_editor.h", + "line": 412, + "column": 1, + "source_line": "extern void stbte_mouse_wheel(stbte_tilemap *tm, int x, int y, int vscroll);" + } + ] + }, + { + "name": "stbte_action", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "act", + "type": { + "model": "CEnum", + "qualifiers": [], + "source_text": "", + "name": "stbte_action", + "constants": [ + { + "name": "STBTE_tool_select", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 418, + "column": 1, + "source_line": "enum stbte_action" + } + }, + { + "name": "STBTE_tool_brush", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 418, + "column": 1, + "source_line": "enum stbte_action" + } + }, + { + "name": "STBTE_tool_erase", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 418, + "column": 1, + "source_line": "enum stbte_action" + } + }, + { + "name": "STBTE_tool_rectangle", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 418, + "column": 1, + "source_line": "enum stbte_action" + } + }, + { + "name": "STBTE_tool_eyedropper", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 418, + "column": 1, + "source_line": "enum stbte_action" + } + }, + { + "name": "STBTE_tool_link", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 418, + "column": 1, + "source_line": "enum stbte_action" + } + }, + { + "name": "STBTE_act_toggle_grid", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 418, + "column": 1, + "source_line": "enum stbte_action" + } + }, + { + "name": "STBTE_act_toggle_links", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 418, + "column": 1, + "source_line": "enum stbte_action" + } + }, + { + "name": "STBTE_act_undo", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 418, + "column": 1, + "source_line": "enum stbte_action" + } + }, + { + "name": "STBTE_act_redo", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 418, + "column": 1, + "source_line": "enum stbte_action" + } + }, + { + "name": "STBTE_act_cut", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 418, + "column": 1, + "source_line": "enum stbte_action" + } + }, + { + "name": "STBTE_act_copy", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 418, + "column": 1, + "source_line": "enum stbte_action" + } + }, + { + "name": "STBTE_act_paste", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 418, + "column": 1, + "source_line": "enum stbte_action" + } + }, + { + "name": "STBTE_scroll_left", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 418, + "column": 1, + "source_line": "enum stbte_action" + } + }, + { + "name": "STBTE_scroll_right", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 418, + "column": 1, + "source_line": "enum stbte_action" + } + }, + { + "name": "STBTE_scroll_up", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 418, + "column": 1, + "source_line": "enum stbte_action" + } + }, + { + "name": "STBTE_scroll_down", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 418, + "column": 1, + "source_line": "enum stbte_action" + } + } + ], + "anonymous_id": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 418, + "column": 1, + "source_line": "enum stbte_action" + } + }, + "declared_type": { + "reference": "enum stbte_action" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 4083, + "column": 1, + "source_line": "void stbte_action(stbte_tilemap *tm, enum stbte_action act)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 4083, + "column": 1, + "source_line": "void stbte_action(stbte_tilemap *tm, enum stbte_action act)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 4104, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_tilemap_editor.h", + "line": 438, + "column": 1, + "source_line": "extern void stbte_action(stbte_tilemap *tm, enum stbte_action act);" + } + ] + }, + { + "name": "stbte_get_dimensions", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "max_x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *max_x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *max_x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "max_y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *max_y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *max_y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1135, + "column": 1, + "source_line": "void stbte_get_dimensions(stbte_tilemap *tm, int *max_x, int *max_y)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1135, + "column": 1, + "source_line": "void stbte_get_dimensions(stbte_tilemap *tm, int *max_x, int *max_y)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1139, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_tilemap_editor.h", + "line": 451, + "column": 1, + "source_line": "extern void stbte_get_dimensions(stbte_tilemap *tm, int *max_x, int *max_y);" + } + ] + }, + { + "name": "stbte_get_tile", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1141, + "column": 1, + "source_line": "short* stbte_get_tile(stbte_tilemap *tm, int x, int y)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1141, + "column": 1, + "source_line": "short* stbte_get_tile(stbte_tilemap *tm, int x, int y)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1147, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_tilemap_editor.h", + "line": 454, + "column": 1, + "source_line": "extern short* stbte_get_tile(stbte_tilemap *tm, int x, int y);" + } + ] + }, + { + "name": "stbte_get_properties", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1149, + "column": 1, + "source_line": "float *stbte_get_properties(stbte_tilemap *tm, int x, int y)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1149, + "column": 1, + "source_line": "float *stbte_get_properties(stbte_tilemap *tm, int x, int y)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1155, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_tilemap_editor.h", + "line": 458, + "column": 1, + "source_line": "extern float *stbte_get_properties(stbte_tilemap *tm, int x, int y);" + } + ] + }, + { + "name": "stbte_get_link", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "destx", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *destx", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *destx", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "desty", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *desty", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *desty", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1157, + "column": 1, + "source_line": "void stbte_get_link(stbte_tilemap *tm, int x, int y, int *destx, int *desty)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1157, + "column": 1, + "source_line": "void stbte_get_link(stbte_tilemap *tm, int x, int y, int *destx, int *desty)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1172, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_tilemap_editor.h", + "line": 463, + "column": 1, + "source_line": "extern void stbte_get_link(stbte_tilemap *tm, int x, int y, int *destx, int *desty);" + } + ] + }, + { + "name": "stbte_set_dimensions", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "map_x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int map_x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int map_x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "map_y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int map_y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int map_y" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1203, + "column": 1, + "source_line": "void stbte_set_dimensions(stbte_tilemap *tm, int map_x, int map_y)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1203, + "column": 1, + "source_line": "void stbte_set_dimensions(stbte_tilemap *tm, int map_x, int map_y)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1211, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_tilemap_editor.h", + "line": 466, + "column": 1, + "source_line": "extern void stbte_set_dimensions(stbte_tilemap *tm, int max_x, int max_y);" + } + ] + }, + { + "name": "stbte_clear_map", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1213, + "column": 1, + "source_line": "void stbte_clear_map(stbte_tilemap *tm)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1213, + "column": 1, + "source_line": "void stbte_clear_map(stbte_tilemap *tm)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1228, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_tilemap_editor.h", + "line": 470, + "column": 1, + "source_line": "extern void stbte_clear_map(stbte_tilemap *tm);" + } + ] + }, + { + "name": "stbte_set_tile", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "layer", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int layer" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int layer" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "tile", + "type": { + "model": "CShort", + "qualifiers": [], + "source_text": "signed short tile" + }, + "declared_type": { + "model": "CShort", + "qualifiers": [], + "source_text": "signed short tile" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1230, + "column": 1, + "source_line": "void stbte_set_tile(stbte_tilemap *tm, int x, int y, int layer, signed short tile)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1230, + "column": 1, + "source_line": "void stbte_set_tile(stbte_tilemap *tm, int x, int y, int layer, signed short tile)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1241, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_tilemap_editor.h", + "line": 474, + "column": 1, + "source_line": "extern void stbte_set_tile(stbte_tilemap *tm, int x, int y, int layer, signed short tile);" + } + ] + }, + { + "name": "stbte_set_property", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "val", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float val" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float val" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1174, + "column": 1, + "source_line": "void stbte_set_property(stbte_tilemap *tm, int x, int y, int n, float val)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1174, + "column": 1, + "source_line": "void stbte_set_property(stbte_tilemap *tm, int x, int y, int n, float val)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1177, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_tilemap_editor.h", + "line": 477, + "column": 1, + "source_line": "extern void stbte_set_property(stbte_tilemap *tm, int x, int y, int n, float val);" + } + ] + }, + { + "name": "stbte_set_link", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "destx", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int destx" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int destx" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "desty", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int desty" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int desty" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1190, + "column": 1, + "source_line": "void stbte_set_link(stbte_tilemap *tm, int x, int y, int destx, int desty)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1190, + "column": 1, + "source_line": "void stbte_set_link(stbte_tilemap *tm, int x, int y, int destx, int desty)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1197, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_tilemap_editor.h", + "line": 480, + "column": 1, + "source_line": "extern void stbte_set_link(stbte_tilemap *tm, int x, int y, int destx, int desty);" + } + ] + }, + { + "name": "stbte_set_background_tile", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "id", + "type": { + "model": "CShort", + "qualifiers": [], + "source_text": "short id" + }, + "declared_type": { + "model": "CShort", + "qualifiers": [], + "source_text": "short id" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1067, + "column": 1, + "source_line": "void stbte_set_background_tile(stbte_tilemap *tm, short id)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1067, + "column": 1, + "source_line": "void stbte_set_background_tile(stbte_tilemap *tm, short id)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1078, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_tilemap_editor.h", + "line": 489, + "column": 1, + "source_line": "extern void stbte_set_background_tile(stbte_tilemap *tm, short id);" + } + ] + }, + { + "name": "stbte_set_sidewidths", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "left", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int left" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int left" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "right", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int right" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int right" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1088, + "column": 1, + "source_line": "void stbte_set_sidewidths(int left, int right)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1088, + "column": 1, + "source_line": "void stbte_set_sidewidths(int left, int right)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1092, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_tilemap_editor.h", + "line": 493, + "column": 1, + "source_line": "extern void stbte_set_sidewidths(int left, int right);" + } + ] + }, + { + "name": "stbte_set_spacing", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "spacing_x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int spacing_x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int spacing_x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "spacing_y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int spacing_y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int spacing_y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "palette_spacing_x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int palette_spacing_x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int palette_spacing_x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "palette_spacing_y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int palette_spacing_y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int palette_spacing_y" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1080, + "column": 1, + "source_line": "void stbte_set_spacing(stbte_tilemap *tm, int spacing_x, int spacing_y, int palette_spacing_x, int palette_spacing_y)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1080, + "column": 1, + "source_line": "void stbte_set_spacing(stbte_tilemap *tm, int spacing_x, int spacing_y, int palette_spacing_x, int palette_spacing_y)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1086, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_tilemap_editor.h", + "line": 497, + "column": 1, + "source_line": "extern void stbte_set_spacing(stbte_tilemap *tm, int spacing_x, int spacing_y, int palette_spacing_x, int palette_spacing_y);" + } + ] + }, + { + "name": "stbte_set_layername", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "layer", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int layer" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int layer" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "layername", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *layername", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *layername", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1123, + "column": 1, + "source_line": "void stbte_set_layername(stbte_tilemap *tm, int layer, const char *layername)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1123, + "column": 1, + "source_line": "void stbte_set_layername(stbte_tilemap *tm, int layer, const char *layername)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1133, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_tilemap_editor.h", + "line": 501, + "column": 1, + "source_line": "extern void stbte_set_layername(stbte_tilemap *tm, int layer, const char *layername);" + } + ] + }, + { + "name": "stbte__init_gui", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 980, + "column": 1, + "source_line": "static void stbte__init_gui(void)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 980, + "column": 1, + "source_line": "static void stbte__init_gui(void)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1005, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__text_width", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1735, + "column": 1, + "source_line": "static int stbte__text_width(const char *str)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1735, + "column": 1, + "source_line": "static int stbte__text_width(const char *str)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1744, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_tilemap_editor.h", + "line": 1121, + "column": 1, + "source_line": "static int stbte__text_width(const char *str);" + } + ] + }, + { + "name": "stbte__set_link", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "src_x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int src_x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int src_x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "src_y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int src_y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int src_y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dest_x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int dest_x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int dest_x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dest_y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int dest_y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int dest_y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "undo_mode", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int undo_mode" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int undo_mode" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1624, + "column": 1, + "source_line": "static void stbte__set_link(stbte_tilemap *tm, int src_x, int src_y, int dest_x, int dest_y, int undo_mode)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1624, + "column": 1, + "source_line": "static void stbte__set_link(stbte_tilemap *tm, int src_x, int src_y, int dest_x, int dest_y, int undo_mode)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1649, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_tilemap_editor.h", + "line": 1180, + "column": 1, + "source_line": "static void stbte__set_link(stbte_tilemap *tm, int src_x, int src_y, int dest_x, int dest_y, int undo_mode);" + } + ] + }, + { + "name": "stbte__choose_category", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "category", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int category" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int category" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1243, + "column": 1, + "source_line": "static void stbte__choose_category(stbte_tilemap *tm, int category)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1243, + "column": 1, + "source_line": "static void stbte__choose_category(stbte_tilemap *tm, int category)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1252, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__strequal", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "q", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *q", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *q", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1254, + "column": 1, + "source_line": "static int stbte__strequal(char *p, char *q)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1254, + "column": 1, + "source_line": "static int stbte__strequal(char *p, char *q)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1259, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__compute_tileinfo", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1261, + "column": 1, + "source_line": "static void stbte__compute_tileinfo(stbte_tilemap *tm)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1261, + "column": 1, + "source_line": "static void stbte__compute_tileinfo(stbte_tilemap *tm)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1288, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__prepare_tileinfo", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1290, + "column": 1, + "source_line": "static void stbte__prepare_tileinfo(stbte_tilemap *tm)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1290, + "column": 1, + "source_line": "static void stbte__prepare_tileinfo(stbte_tilemap *tm)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1294, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__write_undo", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "value", + "type": { + "model": "CShort", + "qualifiers": [], + "source_text": "short value" + }, + "declared_type": { + "model": "CShort", + "qualifiers": [], + "source_text": "short value" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1349, + "column": 1, + "source_line": "static void stbte__write_undo(stbte_tilemap *tm, short value)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1349, + "column": 1, + "source_line": "static void stbte__write_undo(stbte_tilemap *tm, short value)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1357, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__write_redo", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "value", + "type": { + "model": "CShort", + "qualifiers": [], + "source_text": "short value" + }, + "declared_type": { + "model": "CShort", + "qualifiers": [], + "source_text": "short value" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1359, + "column": 1, + "source_line": "static void stbte__write_redo(stbte_tilemap *tm, short value)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1359, + "column": 1, + "source_line": "static void stbte__write_redo(stbte_tilemap *tm, short value)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1367, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__begin_undo", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1369, + "column": 1, + "source_line": "static void stbte__begin_undo(stbte_tilemap *tm)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1369, + "column": 1, + "source_line": "static void stbte__begin_undo(stbte_tilemap *tm)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1375, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__end_undo", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1377, + "column": 1, + "source_line": "static void stbte__end_undo(stbte_tilemap *tm)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1377, + "column": 1, + "source_line": "static void stbte__end_undo(stbte_tilemap *tm)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1393, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__undo_record", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "i", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int i" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int i" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "v", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1395, + "column": 1, + "source_line": "static void stbte__undo_record(stbte_tilemap *tm, int x, int y, int i, int v)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1395, + "column": 1, + "source_line": "static void stbte__undo_record(stbte_tilemap *tm, int x, int y, int i, int v)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1404, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__redo_record", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "i", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int i" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int i" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "v", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1406, + "column": 1, + "source_line": "static void stbte__redo_record(stbte_tilemap *tm, int x, int y, int i, int v)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1406, + "column": 1, + "source_line": "static void stbte__redo_record(stbte_tilemap *tm, int x, int y, int i, int v)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1412, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__extract_float", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "s0", + "type": { + "model": "CShort", + "qualifiers": [], + "source_text": "short s0" + }, + "declared_type": { + "model": "CShort", + "qualifiers": [], + "source_text": "short s0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "s1", + "type": { + "model": "CShort", + "qualifiers": [], + "source_text": "short s1" + }, + "declared_type": { + "model": "CShort", + "qualifiers": [], + "source_text": "short s1" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1414, + "column": 1, + "source_line": "static float stbte__extract_float(short s0, short s1)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1414, + "column": 1, + "source_line": "static float stbte__extract_float(short s0, short s1)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1420, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__extract_short", + "result_type": { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float f" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float f" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "slot", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int slot" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int slot" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1422, + "column": 1, + "source_line": "static short stbte__extract_short(float f, int slot)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1422, + "column": 1, + "source_line": "static short stbte__extract_short(float f, int slot)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1427, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__undo_record_prop", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "i", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int i" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int i" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "s0", + "type": { + "model": "CShort", + "qualifiers": [], + "source_text": "short s0" + }, + "declared_type": { + "model": "CShort", + "qualifiers": [], + "source_text": "short s0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "s1", + "type": { + "model": "CShort", + "qualifiers": [], + "source_text": "short s1" + }, + "declared_type": { + "model": "CShort", + "qualifiers": [], + "source_text": "short s1" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1429, + "column": 1, + "source_line": "static void stbte__undo_record_prop(stbte_tilemap *tm, int x, int y, int i, short s0, short s1)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1429, + "column": 1, + "source_line": "static void stbte__undo_record_prop(stbte_tilemap *tm, int x, int y, int i, short s0, short s1)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1439, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__undo_record_prop_float", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "i", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int i" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int i" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "f", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float f" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float f" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1441, + "column": 1, + "source_line": "static void stbte__undo_record_prop_float(stbte_tilemap *tm, int x, int y, int i, float f)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1441, + "column": 1, + "source_line": "static void stbte__undo_record_prop_float(stbte_tilemap *tm, int x, int y, int i, float f)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1444, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__redo_record_prop", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "i", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int i" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int i" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "s0", + "type": { + "model": "CShort", + "qualifiers": [], + "source_text": "short s0" + }, + "declared_type": { + "model": "CShort", + "qualifiers": [], + "source_text": "short s0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "s1", + "type": { + "model": "CShort", + "qualifiers": [], + "source_text": "short s1" + }, + "declared_type": { + "model": "CShort", + "qualifiers": [], + "source_text": "short s1" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1446, + "column": 1, + "source_line": "static void stbte__redo_record_prop(stbte_tilemap *tm, int x, int y, int i, short s0, short s1)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1446, + "column": 1, + "source_line": "static void stbte__redo_record_prop(stbte_tilemap *tm, int x, int y, int i, short s0, short s1)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1453, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__undo_find_end", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1456, + "column": 1, + "source_line": "static int stbte__undo_find_end(stbte_tilemap *tm)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1456, + "column": 1, + "source_line": "static int stbte__undo_find_end(stbte_tilemap *tm)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1472, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__undo", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1474, + "column": 1, + "source_line": "static void stbte__undo(stbte_tilemap *tm)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1474, + "column": 1, + "source_line": "static void stbte__undo(stbte_tilemap *tm)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1525, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__redo_find_end", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1527, + "column": 1, + "source_line": "static int stbte__redo_find_end(stbte_tilemap *tm)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1527, + "column": 1, + "source_line": "static int stbte__redo_find_end(stbte_tilemap *tm)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1543, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__redo", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1545, + "column": 1, + "source_line": "static void stbte__redo(stbte_tilemap *tm)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1545, + "column": 1, + "source_line": "static void stbte__redo(stbte_tilemap *tm)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1598, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__recompute_undo_available", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1601, + "column": 1, + "source_line": "static void stbte__recompute_undo_available(stbte_tilemap *tm)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1601, + "column": 1, + "source_line": "static void stbte__recompute_undo_available(stbte_tilemap *tm)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1605, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__undo_available", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1607, + "column": 1, + "source_line": "static int stbte__undo_available(stbte_tilemap *tm)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1607, + "column": 1, + "source_line": "static int stbte__undo_available(stbte_tilemap *tm)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1612, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__redo_available", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1614, + "column": 1, + "source_line": "static int stbte__redo_available(stbte_tilemap *tm)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1614, + "column": 1, + "source_line": "static int stbte__redo_available(stbte_tilemap *tm)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1619, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__draw_rect", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "x0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "color", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int color" + }, + "declared_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int color" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1653, + "column": 1, + "source_line": "static void stbte__draw_rect(int x0, int y0, int x1, int y1, unsigned int color)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1653, + "column": 1, + "source_line": "static void stbte__draw_rect(int x0, int y0, int x1, int y1, unsigned int color)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1656, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__draw_line", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "x0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "color", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int color" + }, + "declared_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int color" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1659, + "column": 1, + "source_line": "static void stbte__draw_line(int x0, int y0, int x1, int y1, unsigned int color)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1659, + "column": 1, + "source_line": "static void stbte__draw_line(int x0, int y0, int x1, int y1, unsigned int color)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1665, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__draw_link", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "x0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "color", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int color" + }, + "declared_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int color" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1667, + "column": 1, + "source_line": "static void stbte__draw_link(int x0, int y0, int x1, int y1, unsigned int color)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1667, + "column": 1, + "source_line": "static void stbte__draw_link(int x0, int y0, int x1, int y1, unsigned int color)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1671, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__draw_frame", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "x0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "color", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int color" + }, + "declared_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int color" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1674, + "column": 1, + "source_line": "static void stbte__draw_frame(int x0, int y0, int x1, int y1, unsigned int color)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1674, + "column": 1, + "source_line": "static void stbte__draw_frame(int x0, int y0, int x1, int y1, unsigned int color)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1680, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__get_char_width", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "ch", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ch" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ch" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1682, + "column": 1, + "source_line": "static int stbte__get_char_width(int ch)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1682, + "column": 1, + "source_line": "static int stbte__get_char_width(int ch)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1685, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__get_char_bitmap", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "parameters": [ + { + "name": "ch", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ch" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ch" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1687, + "column": 1, + "source_line": "static short *stbte__get_char_bitmap(int ch)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1687, + "column": 1, + "source_line": "static short *stbte__get_char_bitmap(int ch)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1690, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__draw_bitmask_as_columns", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "bitmask", + "type": { + "model": "CShort", + "qualifiers": [], + "source_text": "short bitmask" + }, + "declared_type": { + "model": "CShort", + "qualifiers": [], + "source_text": "short bitmask" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "color", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int color" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int color" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1692, + "column": 1, + "source_line": "static void stbte__draw_bitmask_as_columns(int x, int y, short bitmask, int color)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1692, + "column": 1, + "source_line": "static void stbte__draw_bitmask_as_columns(int x, int y, short bitmask, int color)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1706, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__draw_bitmap", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "w", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "bitmap", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short *bitmap", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short *bitmap", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "color", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int color" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int color" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1708, + "column": 1, + "source_line": "static void stbte__draw_bitmap(int x, int y, int w, short *bitmap, int color)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1708, + "column": 1, + "source_line": "static void stbte__draw_bitmap(int x, int y, int w, short *bitmap, int color)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1713, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__draw_text_core", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "w", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "color", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int color" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int color" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "digitspace", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int digitspace" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int digitspace" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1715, + "column": 1, + "source_line": "static void stbte__draw_text_core(int x, int y, const char *str, int w, int color, int digitspace)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1715, + "column": 1, + "source_line": "static void stbte__draw_text_core(int x, int y, const char *str, int w, int color, int digitspace)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1728, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__draw_text", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "w", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "color", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int color" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int color" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1730, + "column": 1, + "source_line": "static void stbte__draw_text(int x, int y, const char *str, int w, int color)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1730, + "column": 1, + "source_line": "static void stbte__draw_text(int x, int y, const char *str, int w, int color)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1733, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__draw_frame_delayed", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "x0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "color", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int color" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int color" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1746, + "column": 1, + "source_line": "static void stbte__draw_frame_delayed(int x0, int y0, int x1, int y1, int color)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1746, + "column": 1, + "source_line": "static void stbte__draw_frame_delayed(int x0, int y0, int x1, int y1, int color)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1752, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__flush_delay", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1754, + "column": 1, + "source_line": "static void stbte__flush_delay(void)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1754, + "column": 1, + "source_line": "static void stbte__flush_delay(void)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1762, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__activate", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "id", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int id" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int id" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1764, + "column": 1, + "source_line": "static void stbte__activate(int id)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1764, + "column": 1, + "source_line": "static void stbte__activate(int id)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1770, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__hittest", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "x0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "id", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int id" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int id" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1772, + "column": 1, + "source_line": "static int stbte__hittest(int x0, int y0, int x1, int y1, int id)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1772, + "column": 1, + "source_line": "static int stbte__hittest(int x0, int y0, int x1, int y1, int id)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1781, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__button_core", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "id", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int id" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int id" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1783, + "column": 1, + "source_line": "static int stbte__button_core(int id)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1783, + "column": 1, + "source_line": "static int stbte__button_core(int id)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1808, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__draw_box", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "x0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "colormode", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int colormode" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int colormode" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "colorindex", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int colorindex" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int colorindex" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1810, + "column": 1, + "source_line": "static void stbte__draw_box(int x0, int y0, int x1, int y1, int colormode, int colorindex)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1810, + "column": 1, + "source_line": "static void stbte__draw_box(int x0, int y0, int x1, int y1, int colormode, int colorindex)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1814, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__draw_textbox", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "x0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "text", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *text", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *text", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "xoff", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int xoff" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int xoff" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "yoff", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int yoff" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int yoff" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "colormode", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int colormode" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int colormode" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "colorindex", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int colorindex" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int colorindex" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1816, + "column": 1, + "source_line": "static void stbte__draw_textbox(int x0, int y0, int x1, int y1, char *text, int xoff, int yoff, int colormode, int colorindex)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1816, + "column": 1, + "source_line": "static void stbte__draw_textbox(int x0, int y0, int x1, int y1, char *text, int xoff, int yoff, int colormode, int colorindex)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1820, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__button", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "colormode", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int colormode" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int colormode" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "label", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *label", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *label", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "textoff", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int textoff" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int textoff" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "width", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "id", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int id" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int id" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "toggled", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int toggled" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int toggled" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "disabled", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int disabled" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int disabled" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1822, + "column": 1, + "source_line": "static int stbte__button(int colormode, const char *label, int x, int y, int textoff, int width, int id, int toggled, int disabled)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1822, + "column": 1, + "source_line": "static int stbte__button(int colormode, const char *label, int x, int y, int textoff, int width, int id, int toggled, int disabled)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1834, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__button_icon", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "colormode", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int colormode" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int colormode" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ch", + "type": { + "model": "CChar", + "qualifiers": [], + "source_text": "char ch" + }, + "declared_type": { + "model": "CChar", + "qualifiers": [], + "source_text": "char ch" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "width", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "id", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int id" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int id" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "toggled", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int toggled" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int toggled" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "disabled", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int disabled" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int disabled" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1836, + "column": 1, + "source_line": "static int stbte__button_icon(int colormode, char ch, int x, int y, int width, int id, int toggled, int disabled)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1836, + "column": 1, + "source_line": "static int stbte__button_icon(int colormode, char ch, int x, int y, int width, int id, int toggled, int disabled)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1851, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__minibutton", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "colormode", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int colormode" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int colormode" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ch", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ch" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ch" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "id", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int id" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int id" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1853, + "column": 1, + "source_line": "static int stbte__minibutton(int colormode, int x, int y, int ch, int id)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1853, + "column": 1, + "source_line": "static int stbte__minibutton(int colormode, int x, int y, int ch, int id)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1862, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__layerbutton", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ch", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ch" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ch" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "id", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int id" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int id" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "toggled", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int toggled" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int toggled" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "disabled", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int disabled" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int disabled" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "colormode", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int colormode" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int colormode" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1864, + "column": 1, + "source_line": "static int stbte__layerbutton(int x, int y, int ch, int id, int toggled, int disabled, int colormode)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1864, + "column": 1, + "source_line": "static int stbte__layerbutton(int x, int y, int ch, int id, int toggled, int disabled, int colormode)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1876, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__microbutton", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "size", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int size" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int size" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "id", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int id" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int id" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "colormode", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int colormode" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int colormode" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1878, + "column": 1, + "source_line": "static int stbte__microbutton(int x, int y, int size, int id, int colormode)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1878, + "column": 1, + "source_line": "static int stbte__microbutton(int x, int y, int size, int id, int colormode)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1886, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__microbutton_dragger", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "size", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int size" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int size" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "id", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int id" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int id" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "pos", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *pos", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *pos", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1888, + "column": 1, + "source_line": "static int stbte__microbutton_dragger(int x, int y, int size, int id, int *pos)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1888, + "column": 1, + "source_line": "static int stbte__microbutton_dragger(int x, int y, int size, int id, int *pos)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1915, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__category_button", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "label", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *label", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *label", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "width", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "id", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int id" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int id" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "toggled", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int toggled" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int toggled" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1917, + "column": 1, + "source_line": "static int stbte__category_button(const char *label, int x, int y, int width, int id, int toggled)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1917, + "column": 1, + "source_line": "static int stbte__category_button(const char *label, int x, int y, int width, int id, int toggled)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1928, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__slider", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "x0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "w", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "range", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int range" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int range" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "value", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *value", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *value", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "id", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int id" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int id" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1939, + "column": 1, + "source_line": "static int stbte__slider(int x0, int w, int y, int range, int *value, int id)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1939, + "column": 1, + "source_line": "static int stbte__slider(int x0, int w, int y, int range, int *value, int id)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1972, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__float_control", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "x0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "w", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "minv", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float minv" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float minv" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "maxv", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float maxv" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float maxv" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "scale", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float scale" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float scale" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "fmt", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *fmt", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *fmt", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "value", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *value", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *value", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "colormode", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int colormode" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int colormode" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "id", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int id" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int id" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1982, + "column": 1, + "source_line": "static int stbte__float_control(int x0, int y0, int w, float minv, float maxv, float scale, const char *fmt, float *value, int colormode, int id)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1982, + "column": 1, + "source_line": "static int stbte__float_control(int x0, int y0, int w, float minv, float maxv, float scale, const char *fmt, float *value, int colormode, int id)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2034, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__scrollbar", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "val", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *val", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *val", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "v0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "v1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "num_vis", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_vis" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_vis" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "id", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int id" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int id" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2036, + "column": 1, + "source_line": "static void stbte__scrollbar(int x, int y0, int y1, int *val, int v0, int v1, int num_vis, int id)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2036, + "column": 1, + "source_line": "static void stbte__scrollbar(int x, int y0, int y1, int *val, int v0, int v1, int num_vis, int id)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2074, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__compute_digits", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2077, + "column": 1, + "source_line": "static void stbte__compute_digits(stbte_tilemap *tm)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2077, + "column": 1, + "source_line": "static void stbte__compute_digits(stbte_tilemap *tm)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2085, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__is_single_selection", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2087, + "column": 1, + "source_line": "static int stbte__is_single_selection(void)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2087, + "column": 1, + "source_line": "static int stbte__is_single_selection(void)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2092, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__compute_panel_locations", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2110, + "column": 1, + "source_line": "static void stbte__compute_panel_locations(stbte_tilemap *tm)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2110, + "column": 1, + "source_line": "static void stbte__compute_panel_locations(stbte_tilemap *tm)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2244, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__activate_map", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2275, + "column": 1, + "source_line": "static void stbte__activate_map(int x, int y)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2275, + "column": 1, + "source_line": "static void stbte__activate_map(int x, int y)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2281, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__alert", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "msg", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *msg", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *msg", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2283, + "column": 1, + "source_line": "static void stbte__alert(const char *msg)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2283, + "column": 1, + "source_line": "static void stbte__alert(const char *msg)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2287, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__brush_predict", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "result", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short result[]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short result[]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": null, + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2293, + "column": 1, + "source_line": "static void stbte__brush_predict(stbte_tilemap *tm, short result[])" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2293, + "column": 1, + "source_line": "static void stbte__brush_predict(stbte_tilemap *tm, short result[])" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2329, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__brush", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2331, + "column": 1, + "source_line": "static void stbte__brush(stbte_tilemap *tm, int x, int y)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2331, + "column": 1, + "source_line": "static void stbte__brush(stbte_tilemap *tm, int x, int y)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2371, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__erase_predict", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "result", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short result[]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short result[]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": null, + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "allow_any", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int allow_any" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int allow_any" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2381, + "column": 1, + "source_line": "static int stbte__erase_predict(stbte_tilemap *tm, short result[], int allow_any)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2381, + "column": 1, + "source_line": "static int stbte__erase_predict(stbte_tilemap *tm, short result[], int allow_any)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2449, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__erase", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "allow_any", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int allow_any" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int allow_any" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2451, + "column": 1, + "source_line": "static int stbte__erase(stbte_tilemap *tm, int x, int y, int allow_any)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2451, + "column": 1, + "source_line": "static int stbte__erase(stbte_tilemap *tm, int x, int y, int allow_any)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2522, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__find_tile", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "tile_id", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int tile_id" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int tile_id" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2524, + "column": 1, + "source_line": "static int stbte__find_tile(stbte_tilemap *tm, int tile_id)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2524, + "column": 1, + "source_line": "static int stbte__find_tile(stbte_tilemap *tm, int tile_id)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2532, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__eyedrop", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2534, + "column": 1, + "source_line": "static void stbte__eyedrop(stbte_tilemap *tm, int x, int y)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2534, + "column": 1, + "source_line": "static void stbte__eyedrop(stbte_tilemap *tm, int x, int y)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2569, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__should_copy_properties", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2571, + "column": 1, + "source_line": "static int stbte__should_copy_properties(stbte_tilemap *tm)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2571, + "column": 1, + "source_line": "static int stbte__should_copy_properties(stbte_tilemap *tm)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2584, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__paste_stack", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "result", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short result[]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short result[]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": null, + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dest", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short dest[]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short dest[]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": null, + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "src", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short src[]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short src[]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": null, + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dragging", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int dragging" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int dragging" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2587, + "column": 1, + "source_line": "static void stbte__paste_stack(stbte_tilemap *tm, short result[], short dest[], short src[], int dragging)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2587, + "column": 1, + "source_line": "static void stbte__paste_stack(stbte_tilemap *tm, short result[], short dest[], short src[], int dragging)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2619, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__clear_stack", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "result", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short result[]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short result[]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": null, + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2622, + "column": 1, + "source_line": "static void stbte__clear_stack(stbte_tilemap *tm, short result[])" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2622, + "column": 1, + "source_line": "static void stbte__clear_stack(stbte_tilemap *tm, short result[])" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2635, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__fillrect", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "fill", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int fill" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int fill" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2641, + "column": 1, + "source_line": "static void stbte__fillrect(stbte_tilemap *tm, int x0, int y0, int x1, int y1, int fill)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2641, + "column": 1, + "source_line": "static void stbte__fillrect(stbte_tilemap *tm, int x0, int y0, int x1, int y1, int fill)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2657, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__select_rect", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2659, + "column": 1, + "source_line": "static void stbte__select_rect(stbte_tilemap *tm, int x0, int y0, int x1, int y1)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2659, + "column": 1, + "source_line": "static void stbte__select_rect(stbte_tilemap *tm, int x0, int y0, int x1, int y1)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2666, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__copy_properties", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "dest", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *dest", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *dest", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "src", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *src", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *src", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2668, + "column": 1, + "source_line": "static void stbte__copy_properties(float *dest, float *src)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2668, + "column": 1, + "source_line": "static void stbte__copy_properties(float *dest, float *src)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2673, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__copy_cut", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cut", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int cut" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int cut" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2675, + "column": 1, + "source_line": "static void stbte__copy_cut(stbte_tilemap *tm, int cut)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2675, + "column": 1, + "source_line": "static void stbte__copy_cut(stbte_tilemap *tm, int cut)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2736, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__in_rect", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "w", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "h", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2738, + "column": 1, + "source_line": "static int stbte__in_rect(int x, int y, int x0, int y0, int w, int h)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2738, + "column": 1, + "source_line": "static int stbte__in_rect(int x, int y, int x0, int y0, int w, int h)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2741, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__in_src_rect", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2744, + "column": 1, + "source_line": "static int stbte__in_src_rect(int x, int y)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2744, + "column": 1, + "source_line": "static int stbte__in_src_rect(int x, int y)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2747, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__in_dest_rect", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "destx", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int destx" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int destx" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "desty", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int desty" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int desty" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2749, + "column": 1, + "source_line": "static int stbte__in_dest_rect(int x, int y, int destx, int desty)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2749, + "column": 1, + "source_line": "static int stbte__in_dest_rect(int x, int y, int destx, int desty)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2752, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__paste", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mapx", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mapx" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mapx" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mapy", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mapy" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mapy" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2755, + "column": 1, + "source_line": "static void stbte__paste(stbte_tilemap *tm, int mapx, int mapy)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2755, + "column": 1, + "source_line": "static void stbte__paste(stbte_tilemap *tm, int mapx, int mapy)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2816, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__drag_update", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mapx", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mapx" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mapx" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mapy", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mapy" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mapy" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "copy_props", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int copy_props" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int copy_props" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2818, + "column": 1, + "source_line": "static void stbte__drag_update(stbte_tilemap *tm, int mapx, int mapy, int copy_props)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2818, + "column": 1, + "source_line": "static void stbte__drag_update(stbte_tilemap *tm, int mapx, int mapy, int copy_props)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2912, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__drag_place", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mapx", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mapx" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mapx" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mapy", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mapy" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mapy" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2914, + "column": 1, + "source_line": "static void stbte__drag_place(stbte_tilemap *tm, int mapx, int mapy)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2914, + "column": 1, + "source_line": "static void stbte__drag_place(stbte_tilemap *tm, int mapx, int mapy)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2943, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__tile_paint", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "sx", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int sx" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int sx" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "sy", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int sy" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int sy" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mapx", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mapx" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mapx" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mapy", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mapy" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mapy" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "layer", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int layer" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int layer" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2945, + "column": 1, + "source_line": "static void stbte__tile_paint(stbte_tilemap *tm, int sx, int sy, int mapx, int mapy, int layer)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2945, + "column": 1, + "source_line": "static void stbte__tile_paint(stbte_tilemap *tm, int sx, int sy, int mapx, int mapy, int layer)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3022, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__tile", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "sx", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int sx" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int sx" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "sy", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int sy" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int sy" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mapx", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mapx" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mapx" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mapy", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mapy" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mapy" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3024, + "column": 1, + "source_line": "static void stbte__tile(stbte_tilemap *tm, int sx, int sy, int mapx, int mapy)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3024, + "column": 1, + "source_line": "static void stbte__tile(stbte_tilemap *tm, int sx, int sy, int mapx, int mapy)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3301, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__start_paste", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3303, + "column": 1, + "source_line": "static void stbte__start_paste(stbte_tilemap *tm)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3303, + "column": 1, + "source_line": "static void stbte__start_paste(stbte_tilemap *tm)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3309, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__toolbar", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "w", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "h", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3311, + "column": 1, + "source_line": "static void stbte__toolbar(stbte_tilemap *tm, int x0, int y0, int w, int h)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3311, + "column": 1, + "source_line": "static void stbte__toolbar(stbte_tilemap *tm, int x0, int y0, int w, int h)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3372, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__info_value", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "label", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *label", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *label", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "val", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int val" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int val" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "digits", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int digits" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int digits" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "id", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int id" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int id" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3376, + "column": 1, + "source_line": "static int stbte__info_value(const char *label, int x, int y, int val, int digits, int id)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3376, + "column": 1, + "source_line": "static int stbte__info_value(const char *label, int x, int y, int val, int digits, int id)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3394, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__info", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "w", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "h", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3396, + "column": 1, + "source_line": "static void stbte__info(stbte_tilemap *tm, int x0, int y0, int w, int h)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3396, + "column": 1, + "source_line": "static void stbte__info(stbte_tilemap *tm, int x0, int y0, int w, int h)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3425, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__layers", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "w", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "h", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3427, + "column": 1, + "source_line": "static void stbte__layers(stbte_tilemap *tm, int x0, int y0, int w, int h)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3427, + "column": 1, + "source_line": "static void stbte__layers(stbte_tilemap *tm, int x0, int y0, int w, int h)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3485, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__categories", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "w", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "h", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3487, + "column": 1, + "source_line": "static void stbte__categories(stbte_tilemap *tm, int x0, int y0, int w, int h)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3487, + "column": 1, + "source_line": "static void stbte__categories(stbte_tilemap *tm, int x0, int y0, int w, int h)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3512, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__tile_in_palette", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "slot", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int slot" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int slot" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3514, + "column": 1, + "source_line": "static void stbte__tile_in_palette(stbte_tilemap *tm, int x, int y, int slot)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3514, + "column": 1, + "source_line": "static void stbte__tile_in_palette(stbte_tilemap *tm, int x, int y, int slot)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3532, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__palette_of_tiles", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "w", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "h", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3534, + "column": 1, + "source_line": "static void stbte__palette_of_tiles(stbte_tilemap *tm, int x0, int y0, int w, int h)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3534, + "column": 1, + "source_line": "static void stbte__palette_of_tiles(stbte_tilemap *tm, int x0, int y0, int w, int h)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3574, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__props_panel", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "w", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "h", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3577, + "column": 1, + "source_line": "static void stbte__props_panel(stbte_tilemap *tm, int x0, int y0, int w, int h)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3577, + "column": 1, + "source_line": "static void stbte__props_panel(stbte_tilemap *tm, int x0, int y0, int w, int h)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3670, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__dump_colorstate", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3675, + "column": 1, + "source_line": "static void stbte__dump_colorstate(void)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3675, + "column": 1, + "source_line": "static void stbte__dump_colorstate(void)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3695, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__colorpicker", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "x0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "w", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "h", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3697, + "column": 1, + "source_line": "static void stbte__colorpicker(int x0, int y0, int w, int h)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3697, + "column": 1, + "source_line": "static void stbte__colorpicker(int x0, int y0, int w, int h)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3775, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__editor_traverse", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3778, + "column": 1, + "source_line": "static void stbte__editor_traverse(stbte_tilemap *tm)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3778, + "column": 1, + "source_line": "static void stbte__editor_traverse(stbte_tilemap *tm)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3999, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__do_event", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 4001, + "column": 1, + "source_line": "static void stbte__do_event(stbte_tilemap *tm)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 4001, + "column": 1, + "source_line": "static void stbte__do_event(stbte_tilemap *tm)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 4038, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbte__set_event", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "event", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int event" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int event" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 4040, + "column": 1, + "source_line": "static void stbte__set_event(int event, int x, int y)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 4040, + "column": 1, + "source_line": "static void stbte__set_event(int event, int x, int y)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 4051, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + } + ], + "structs": [ + { + "reference": "struct@stb/stb_tilemap_editor.h:595:1" + }, + { + "reference": "struct@stb/stb_tilemap_editor.h:782:1" + }, + { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "expanded", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int expanded" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 863, + "column": 4, + "source_line": " int expanded, mode;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "mode", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mode" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 863, + "column": 4, + "source_line": " int expanded, mode;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "delta_height", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int delta_height" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 864, + "column": 4, + "source_line": " int delta_height; // number of rows they've requested for this" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "side", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int side" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 865, + "column": 4, + "source_line": " int side;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "width", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 866, + "column": 4, + "source_line": " int width,height;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "height", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int height" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 866, + "column": 4, + "source_line": " int width,height;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "x0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 867, + "column": 4, + "source_line": " int x0,y0;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "y0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 867, + "column": 4, + "source_line": " int x0,y0;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_tilemap_editor.h:861:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 861, + "column": 1, + "source_line": "typedef struct" + } + }, + { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "x0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 872, + "column": 4, + "source_line": " int x0,y0,x1,y1,color;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "y0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 872, + "column": 4, + "source_line": " int x0,y0,x1,y1,color;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "x1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 872, + "column": 4, + "source_line": " int x0,y0,x1,y1,color;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "y1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 872, + "column": 4, + "source_line": " int x0,y0,x1,y1,color;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "color", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int color" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 872, + "column": 4, + "source_line": " int x0,y0,x1,y1,color;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_tilemap_editor.h:870:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 870, + "column": 1, + "source_line": "typedef struct" + } + }, + { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "tool", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int tool" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 879, + "column": 4, + "source_line": " int tool, active_event;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "active_event", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int active_event" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 879, + "column": 4, + "source_line": " int tool, active_event;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "active_id", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int active_id" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 880, + "column": 4, + "source_line": " int active_id, hot_id, next_hot_id;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "hot_id", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int hot_id" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 880, + "column": 4, + "source_line": " int active_id, hot_id, next_hot_id;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "next_hot_id", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int next_hot_id" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 880, + "column": 4, + "source_line": " int active_id, hot_id, next_hot_id;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "event", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int event" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 881, + "column": 4, + "source_line": " int event;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "mx", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mx" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 882, + "column": 4, + "source_line": " int mx,my, dx,dy;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "my", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int my" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 882, + "column": 4, + "source_line": " int mx,my, dx,dy;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "dx", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int dx" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 882, + "column": 4, + "source_line": " int mx,my, dx,dy;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "dy", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int dy" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 882, + "column": 4, + "source_line": " int mx,my, dx,dy;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "ms_time", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ms_time" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 883, + "column": 4, + "source_line": " int ms_time;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "shift", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int shift" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 884, + "column": 4, + "source_line": " int shift, scrollkey;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "scrollkey", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int scrollkey" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 884, + "column": 4, + "source_line": " int shift, scrollkey;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "initted", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int initted" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 885, + "column": 4, + "source_line": " int initted;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "side_extended", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int side_extended[2]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "2", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 886, + "column": 4, + "source_line": " int side_extended[2];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "delayrect", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte__colorrect delayrect[STBTE__MAX_DELAYRECT]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STBTE__MAX_DELAYRECT", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbte__colorrect", + "name": "stbte__colorrect", + "type": { + "reference": "struct@stb/stb_tilemap_editor.h:870:1" + }, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 870, + "column": 1, + "source_line": "typedef struct" + }, + "declaration_locations": [] + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 887, + "column": 4, + "source_line": " stbte__colorrect delayrect[STBTE__MAX_DELAYRECT];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "delaycount", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int delaycount" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 888, + "column": 4, + "source_line": " int delaycount;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "show_grid", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int show_grid" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 889, + "column": 4, + "source_line": " int show_grid, show_links;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "show_links", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int show_links" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 889, + "column": 4, + "source_line": " int show_grid, show_links;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "brush_state", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int brush_state" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 890, + "column": 4, + "source_line": " int brush_state; // used to decide which kind of erasing" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "eyedrop_x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int eyedrop_x" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 891, + "column": 4, + "source_line": " int eyedrop_x, eyedrop_y, eyedrop_last_layer;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "eyedrop_y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int eyedrop_y" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 891, + "column": 4, + "source_line": " int eyedrop_x, eyedrop_y, eyedrop_last_layer;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "eyedrop_last_layer", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int eyedrop_last_layer" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 891, + "column": 4, + "source_line": " int eyedrop_x, eyedrop_y, eyedrop_last_layer;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "pasting", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int pasting" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 892, + "column": 4, + "source_line": " int pasting, paste_x, paste_y;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "paste_x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int paste_x" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 892, + "column": 4, + "source_line": " int pasting, paste_x, paste_y;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "paste_y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int paste_y" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 892, + "column": 4, + "source_line": " int pasting, paste_x, paste_y;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "scrolling", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int scrolling" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 893, + "column": 4, + "source_line": " int scrolling, start_x, start_y;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "start_x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int start_x" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 893, + "column": 4, + "source_line": " int scrolling, start_x, start_y;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "start_y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int start_y" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 893, + "column": 4, + "source_line": " int scrolling, start_x, start_y;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "last_mouse_x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int last_mouse_x" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 894, + "column": 4, + "source_line": " int last_mouse_x, last_mouse_y;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "last_mouse_y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int last_mouse_y" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 894, + "column": 4, + "source_line": " int last_mouse_x, last_mouse_y;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "accum_x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int accum_x" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 895, + "column": 4, + "source_line": " int accum_x, accum_y;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "accum_y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int accum_y" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 895, + "column": 4, + "source_line": " int accum_x, accum_y;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "linking", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int linking" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 896, + "column": 4, + "source_line": " int linking;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "dragging", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int dragging" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 897, + "column": 4, + "source_line": " int dragging;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "drag_x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int drag_x" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 898, + "column": 4, + "source_line": " int drag_x, drag_y, drag_w, drag_h;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "drag_y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int drag_y" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 898, + "column": 4, + "source_line": " int drag_x, drag_y, drag_w, drag_h;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "drag_w", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int drag_w" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 898, + "column": 4, + "source_line": " int drag_x, drag_y, drag_w, drag_h;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "drag_h", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int drag_h" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 898, + "column": 4, + "source_line": " int drag_x, drag_y, drag_w, drag_h;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "drag_offx", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int drag_offx" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 899, + "column": 4, + "source_line": " int drag_offx, drag_offy, drag_dest_x, drag_dest_y;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "drag_offy", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int drag_offy" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 899, + "column": 4, + "source_line": " int drag_offx, drag_offy, drag_dest_x, drag_dest_y;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "drag_dest_x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int drag_dest_x" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 899, + "column": 4, + "source_line": " int drag_offx, drag_offy, drag_dest_x, drag_dest_y;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "drag_dest_y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int drag_dest_y" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 899, + "column": 4, + "source_line": " int drag_offx, drag_offy, drag_dest_x, drag_dest_y;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "undoing", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int undoing" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 900, + "column": 4, + "source_line": " int undoing;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "has_selection", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int has_selection" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 901, + "column": 4, + "source_line": " int has_selection, select_x0, select_y0, select_x1, select_y1;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "select_x0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int select_x0" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 901, + "column": 4, + "source_line": " int has_selection, select_x0, select_y0, select_x1, select_y1;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "select_y0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int select_y0" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 901, + "column": 4, + "source_line": " int has_selection, select_x0, select_y0, select_x1, select_y1;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "select_x1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int select_x1" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 901, + "column": 4, + "source_line": " int has_selection, select_x0, select_y0, select_x1, select_y1;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "select_y1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int select_y1" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 901, + "column": 4, + "source_line": " int has_selection, select_x0, select_y0, select_x1, select_y1;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "sx", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int sx" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 902, + "column": 4, + "source_line": " int sx,sy;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "sy", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int sy" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 902, + "column": 4, + "source_line": " int sx,sy;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "x0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 903, + "column": 4, + "source_line": " int x0,y0,x1,y1, left_width, right_width; // configurable widths" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "y0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 903, + "column": 4, + "source_line": " int x0,y0,x1,y1, left_width, right_width; // configurable widths" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "x1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 903, + "column": 4, + "source_line": " int x0,y0,x1,y1, left_width, right_width; // configurable widths" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "y1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 903, + "column": 4, + "source_line": " int x0,y0,x1,y1, left_width, right_width; // configurable widths" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "left_width", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int left_width" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 903, + "column": 4, + "source_line": " int x0,y0,x1,y1, left_width, right_width; // configurable widths" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "right_width", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int right_width" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 903, + "column": 4, + "source_line": " int x0,y0,x1,y1, left_width, right_width; // configurable widths" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "alert_timer", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float alert_timer" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 904, + "column": 4, + "source_line": " float alert_timer;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "alert_msg", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *alert_msg", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 905, + "column": 4, + "source_line": " const char *alert_msg;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "dt", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dt" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 906, + "column": 4, + "source_line": " float dt;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "panel", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte__panel panel[STBTE__num_panel]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STBTE__num_panel", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbte__panel", + "name": "stbte__panel", + "type": { + "reference": "struct@stb/stb_tilemap_editor.h:861:1" + }, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 861, + "column": 1, + "source_line": "typedef struct" + }, + "declaration_locations": [] + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 907, + "column": 4, + "source_line": " stbte__panel panel[STBTE__num_panel];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "copybuffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short copybuffer[STBTE_MAX_COPY][STBTE_MAX_LAYERS]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STBTE_MAX_COPY", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STBTE_MAX_LAYERS", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 908, + "column": 4, + "source_line": " short copybuffer[STBTE_MAX_COPY][STBTE_MAX_LAYERS];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "copyprops", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float copyprops[STBTE_MAX_COPY][STBTE_MAX_PROPERTIES]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STBTE_MAX_COPY", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STBTE_MAX_PROPERTIES", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 909, + "column": 4, + "source_line": " float copyprops[STBTE_MAX_COPY][STBTE_MAX_PROPERTIES];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "copylinks", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte__link copylinks[STBTE_MAX_COPY]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STBTE_MAX_COPY", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "reference": "stbte__link" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 911, + "column": 4, + "source_line": " stbte__link copylinks[STBTE_MAX_COPY];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "copy_src_x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int copy_src_x" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 913, + "column": 4, + "source_line": " int copy_src_x, copy_src_y;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "copy_src_y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int copy_src_y" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 913, + "column": 4, + "source_line": " int copy_src_x, copy_src_y;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "copy_src", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *copy_src", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 914, + "column": 4, + "source_line": " stbte_tilemap *copy_src;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "copy_width", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int copy_width" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 915, + "column": 4, + "source_line": " int copy_width,copy_height,has_copy,copy_has_props;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "copy_height", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int copy_height" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 915, + "column": 4, + "source_line": " int copy_width,copy_height,has_copy,copy_has_props;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "has_copy", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int has_copy" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 915, + "column": 4, + "source_line": " int copy_width,copy_height,has_copy,copy_has_props;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "copy_has_props", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int copy_has_props" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 915, + "column": 4, + "source_line": " int copy_width,copy_height,has_copy,copy_has_props;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_tilemap_editor.h:877:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 877, + "column": 1, + "source_line": "typedef struct" + } + }, + { + "reference": "struct@stb/stb_tilemap_editor.h:928:1" + }, + { + "reference": "struct stbte_tilemap" + }, + { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "width", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2096, + "column": 4, + "source_line": " int width, height;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "height", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int height" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2096, + "column": 4, + "source_line": " int width, height;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2097, + "column": 4, + "source_line": " int x,y;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2097, + "column": 4, + "source_line": " int x,y;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "active", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int active" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2098, + "column": 4, + "source_line": " int active;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "retracted", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float retracted" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2099, + "column": 4, + "source_line": " float retracted;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_tilemap_editor.h:2094:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2094, + "column": 1, + "source_line": "typedef struct" + } + } + ], + "unions": [], + "enums": [ + { + "model": "CEnum", + "qualifiers": [], + "source_text": "", + "name": null, + "constants": [ + { + "name": "STBTE_drawmode_deemphasize", + "value": "-1", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 348, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE_drawmode_normal", + "value": "0", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 348, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE_drawmode_emphasize", + "value": "1", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 348, + "column": 1, + "source_line": "enum" + } + } + ], + "anonymous_id": "enum@stb/stb_tilemap_editor.h:348:1", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 348, + "column": 1, + "source_line": "enum" + } + }, + { + "reference": "enum stbte_action" + }, + { + "model": "CEnum", + "qualifiers": [], + "source_text": "", + "name": null, + "constants": [ + { + "name": "STBTE__base", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 600, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__outline", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 600, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__text", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 600, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__num_color_aspects", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 600, + "column": 1, + "source_line": "enum" + } + } + ], + "anonymous_id": "enum@stb/stb_tilemap_editor.h:600:1", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 600, + "column": 1, + "source_line": "enum" + } + }, + { + "model": "CEnum", + "qualifiers": [], + "source_text": "", + "name": null, + "constants": [ + { + "name": "STBTE__idle", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 609, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__over", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 609, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__down", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 609, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__over_down", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 609, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__selected", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 609, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__selected_over", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 609, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__disabled", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 609, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__num_color_states", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 609, + "column": 1, + "source_line": "enum" + } + } + ], + "anonymous_id": "enum@stb/stb_tilemap_editor.h:609:1", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 609, + "column": 1, + "source_line": "enum" + } + }, + { + "model": "CEnum", + "qualifiers": [], + "source_text": "", + "name": null, + "constants": [ + { + "name": "STBTE__cexpander", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 621, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__ctoolbar", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 621, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__ctoolbar_button", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 621, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__cpanel", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 621, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__cpanel_sider", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 621, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__cpanel_sizer", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 621, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__cscrollbar", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 621, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__cmapsize", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 621, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__clayer_button", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 621, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__clayer_hide", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 621, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__clayer_lock", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 621, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__clayer_solo", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 621, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__ccategory_button", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 621, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__num_color_modes", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 621, + "column": 1, + "source_line": "enum" + } + } + ], + "anonymous_id": "enum@stb/stb_tilemap_editor.h:621:1", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 621, + "column": 1, + "source_line": "enum" + } + }, + { + "model": "CEnum", + "qualifiers": [], + "source_text": "", + "name": null, + "constants": [ + { + "name": "STBTE__panel_toolbar", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 796, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__panel_colorpick", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 796, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__panel_info", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 796, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__panel_layers", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 796, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__panel_props", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 796, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__panel_categories", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 796, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__panel_tiles", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 796, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__num_panel", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 796, + "column": 1, + "source_line": "enum" + } + } + ], + "anonymous_id": "enum@stb/stb_tilemap_editor.h:796:1", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 796, + "column": 1, + "source_line": "enum" + } + }, + { + "model": "CEnum", + "qualifiers": [], + "source_text": "", + "name": null, + "constants": [ + { + "name": "STBTE__side_left", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 809, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__side_right", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 809, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__side_top", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 809, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__side_bottom", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 809, + "column": 1, + "source_line": "enum" + } + } + ], + "anonymous_id": "enum@stb/stb_tilemap_editor.h:809:1", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 809, + "column": 1, + "source_line": "enum" + } + }, + { + "model": "CEnum", + "qualifiers": [], + "source_text": "", + "name": null, + "constants": [ + { + "name": "STBTE__tool_select", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 817, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__tool_brush", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 817, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__tool_erase", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 817, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__tool_rect", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 817, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__tool_eyedrop", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 817, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__tool_fill", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 817, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__tool_link", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 817, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__tool_showgrid", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 817, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__tool_showlinks", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 817, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__tool_undo", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 817, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__tool_redo", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 817, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__num_tool", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 817, + "column": 1, + "source_line": "enum" + } + } + ], + "anonymous_id": "enum@stb/stb_tilemap_editor.h:817:1", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 817, + "column": 1, + "source_line": "enum" + } + }, + { + "model": "CEnum", + "qualifiers": [], + "source_text": "", + "name": null, + "constants": [ + { + "name": "STBTE__propmode_default", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 840, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__propmode_always", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 840, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__propmode_never", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 840, + "column": 1, + "source_line": "enum" + } + } + ], + "anonymous_id": "enum@stb/stb_tilemap_editor.h:840:1", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 840, + "column": 1, + "source_line": "enum" + } + }, + { + "model": "CEnum", + "qualifiers": [], + "source_text": "", + "name": null, + "constants": [ + { + "name": "STBTE__paint", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 847, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__tick", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 847, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__mousemove", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 847, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__mousewheel", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 847, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__leftdown", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 847, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__leftup", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 847, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__rightdown", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 847, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__rightup", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 847, + "column": 1, + "source_line": "enum" + } + } + ], + "anonymous_id": "enum@stb/stb_tilemap_editor.h:847:1", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 847, + "column": 1, + "source_line": "enum" + } + }, + { + "model": "CEnum", + "qualifiers": [], + "source_text": "", + "name": null, + "constants": [ + { + "name": "STBTE__unlocked", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 935, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__protected", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 935, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__locked", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 935, + "column": 1, + "source_line": "enum" + } + } + ], + "anonymous_id": "enum@stb/stb_tilemap_editor.h:935:1", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 935, + "column": 1, + "source_line": "enum" + } + }, + { + "model": "CEnum", + "qualifiers": [], + "source_text": "", + "name": null, + "constants": [ + { + "name": "STBTE__undo_none", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1183, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__undo_record", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1183, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__undo_block", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1183, + "column": 1, + "source_line": "enum" + } + } + ], + "anonymous_id": "enum@stb/stb_tilemap_editor.h:1183:1", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1183, + "column": 1, + "source_line": "enum" + } + }, + { + "model": "CEnum", + "qualifiers": [], + "source_text": "", + "name": null, + "constants": [ + { + "name": "STBTE__none", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1930, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__begin", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1930, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__end", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1930, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__change", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1930, + "column": 1, + "source_line": "enum" + } + } + ], + "anonymous_id": "enum@stb/stb_tilemap_editor.h:1930:1", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1930, + "column": 1, + "source_line": "enum" + } + }, + { + "model": "CEnum", + "qualifiers": [], + "source_text": "", + "name": null, + "constants": [ + { + "name": "STBTE__map", + "value": "1", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2247, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__region", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2247, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__panel", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2247, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__info", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2247, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__toolbarA", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2247, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__toolbarB", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2247, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__palette", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2247, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__categories", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2247, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__layer", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2247, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__solo", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2247, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__hide", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2247, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__lock", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2247, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__scrollbar", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2247, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__panel_mover", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2247, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__panel_sizer", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2247, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__scrollbar_id", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2247, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__colorpick_id", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2247, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__prop_flag", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2247, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__prop_float", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2247, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__prop_int", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2247, + "column": 1, + "source_line": "enum" + } + } + ], + "anonymous_id": "enum@stb/stb_tilemap_editor.h:2247:1", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2247, + "column": 1, + "source_line": "enum" + } + }, + { + "model": "CEnum", + "qualifiers": [], + "source_text": "", + "name": null, + "constants": [ + { + "name": "STBTE__erase_none", + "value": "-1", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2373, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__erase_brushonly", + "value": "0", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2373, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__erase_any", + "value": "1", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2373, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBTE__erase_all", + "value": "2", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2373, + "column": 1, + "source_line": "enum" + } + } + ], + "anonymous_id": "enum@stb/stb_tilemap_editor.h:2373:1", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2373, + "column": 1, + "source_line": "enum" + } + } + ], + "typedefs": [ + { + "reference": "stbte_tilemap" + }, + { + "reference": "stbte__link" + }, + { + "reference": "stbte__tileinfo" + }, + { + "reference": "stbte__tiledata" + }, + { + "reference": "stbte__panel" + }, + { + "reference": "stbte__colorrect" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbte__ui_t", + "name": "stbte__ui_t", + "type": { + "reference": "struct@stb/stb_tilemap_editor.h:877:1" + }, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 877, + "column": 1, + "source_line": "typedef struct" + }, + "declaration_locations": [] + }, + { + "reference": "stbte__layer" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbte__region_t", + "name": "stbte__region_t", + "type": { + "reference": "struct@stb/stb_tilemap_editor.h:2094:1" + }, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2094, + "column": 1, + "source_line": "typedef struct" + }, + "declaration_locations": [] + } + ], + "variables": [ + { + "name": "stbte__font_offset", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "static short stbte__font_offset[95+16]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "95+16", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "storage": [ + "static" + ], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 745, + "column": 1, + "source_line": "static short stbte__font_offset[95+16];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "default_category", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "static char *default_category", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "storage": [ + "static" + ], + "initializer": { + "source_text": "(char*) \"[unassigned]\"" + }, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 978, + "column": 1, + "source_line": "static char *default_category = (char*) \"[unassigned]\";" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "stbte__region", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "static stbte__region_t stbte__region[4]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "4", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "reference": "stbte__region_t" + } + ] + }, + "storage": [ + "static" + ], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2102, + "column": 1, + "source_line": "static stbte__region_t stbte__region[4];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "stbte__saved", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "static float stbte__saved" + }, + "storage": [ + "static" + ], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3576, + "column": 1, + "source_line": "static float stbte__saved;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "stbte__cp_mode", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "static int stbte__cp_mode" + }, + "storage": [ + "static" + ], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3672, + "column": 1, + "source_line": "static int stbte__cp_mode, stbte__cp_aspect, stbte__save, stbte__cp_altered;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "stbte__cp_aspect", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "static int stbte__cp_aspect" + }, + "storage": [ + "static" + ], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3672, + "column": 1, + "source_line": "static int stbte__cp_mode, stbte__cp_aspect, stbte__save, stbte__cp_altered;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "stbte__save", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "static int stbte__save" + }, + "storage": [ + "static" + ], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3672, + "column": 1, + "source_line": "static int stbte__cp_mode, stbte__cp_aspect, stbte__save, stbte__cp_altered;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "stbte__cp_altered", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "static int stbte__cp_altered" + }, + "storage": [ + "static" + ], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3672, + "column": 1, + "source_line": "static int stbte__cp_mode, stbte__cp_aspect, stbte__save, stbte__cp_altered;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "stbte__cp_state", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "static int stbte__cp_state" + }, + "storage": [ + "static" + ], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3674, + "column": 1, + "source_line": "static int stbte__cp_state, stbte__cp_index, stbte__color_copy;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "stbte__cp_index", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "static int stbte__cp_index" + }, + "storage": [ + "static" + ], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3674, + "column": 1, + "source_line": "static int stbte__cp_state, stbte__cp_index, stbte__color_copy;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "stbte__color_copy", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "static int stbte__color_copy" + }, + "storage": [ + "static" + ], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3674, + "column": 1, + "source_line": "static int stbte__cp_state, stbte__cp_index, stbte__color_copy;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "macros": [ + { + "name": "STB_TILEMAP_INCLUDE_STB_TILEMAP_EDITOR_H", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 335, + "column": 1, + "source_line": "#define STB_TILEMAP_INCLUDE_STB_TILEMAP_EDITOR_H" + } + }, + { + "name": "_CRT_SECURE_NO_WARNINGS", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 339, + "column": 3, + "source_line": " #define _CRT_SECURE_NO_WARNINGS" + } + }, + { + "name": "STBTE_PROP_none", + "value": "0", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 356, + "column": 1, + "source_line": "#define STBTE_PROP_none 0" + } + }, + { + "name": "STBTE_PROP_int", + "value": "1", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 357, + "column": 1, + "source_line": "#define STBTE_PROP_int 1" + } + }, + { + "name": "STBTE_PROP_float", + "value": "2", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 358, + "column": 1, + "source_line": "#define STBTE_PROP_float 2" + } + }, + { + "name": "STBTE_PROP_bool", + "value": "3", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 359, + "column": 1, + "source_line": "#define STBTE_PROP_bool 3" + } + }, + { + "name": "STBTE_PROP_disabled", + "value": "4", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 360, + "column": 1, + "source_line": "#define STBTE_PROP_disabled 4" + } + }, + { + "name": "STBTE_EMPTY", + "value": "-1", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 449, + "column": 1, + "source_line": "#define STBTE_EMPTY -1" + } + }, + { + "name": "STBTE_ASSERT", + "value": "assert", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 510, + "column": 1, + "source_line": "#define STBTE_ASSERT assert" + } + }, + { + "name": "STBTE__NOTUSED", + "value": "(void)(v)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 515, + "column": 1, + "source_line": "#define STBTE__NOTUSED(v) (void)(v)" + } + }, + { + "name": "STBTE__NOTUSED", + "value": "(void)sizeof(v)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 517, + "column": 1, + "source_line": "#define STBTE__NOTUSED(v) (void)sizeof(v)" + } + }, + { + "name": "STBTE_MAX_TILEMAP_X", + "value": "200", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 521, + "column": 1, + "source_line": "#define STBTE_MAX_TILEMAP_X 200" + } + }, + { + "name": "STBTE_MAX_TILEMAP_Y", + "value": "200", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 525, + "column": 1, + "source_line": "#define STBTE_MAX_TILEMAP_Y 200" + } + }, + { + "name": "STBTE_MAX_LAYERS", + "value": "8", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 529, + "column": 1, + "source_line": "#define STBTE_MAX_LAYERS 8" + } + }, + { + "name": "STBTE_MAX_CATEGORIES", + "value": "100", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 533, + "column": 1, + "source_line": "#define STBTE_MAX_CATEGORIES 100" + } + }, + { + "name": "STBTE_MAX_COPY", + "value": "65536", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 537, + "column": 1, + "source_line": "#define STBTE_MAX_COPY 65536" + } + }, + { + "name": "STBTE_UNDO_BUFFER_BYTES", + "value": "(1 << 24)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 541, + "column": 1, + "source_line": "#define STBTE_UNDO_BUFFER_BYTES (1 << 24) // 16 MB" + } + }, + { + "name": "STBTE__NO_PROPS", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 545, + "column": 1, + "source_line": "#define STBTE__NO_PROPS" + } + }, + { + "name": "STBTE_PROP_TYPE", + "value": "0", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 546, + "column": 1, + "source_line": "#define STBTE_PROP_TYPE(n,td,tp) 0" + } + }, + { + "name": "STBTE_PROP_NAME", + "value": "\"\"", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 550, + "column": 1, + "source_line": "#define STBTE_PROP_NAME(n,td,tp) \"\"" + } + }, + { + "name": "STBTE_MAX_PROPERTIES", + "value": "10", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 554, + "column": 1, + "source_line": "#define STBTE_MAX_PROPERTIES 10" + } + }, + { + "name": "STBTE_PROP_MIN", + "value": "0", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 558, + "column": 1, + "source_line": "#define STBTE_PROP_MIN(n,td,tp) 0" + } + }, + { + "name": "STBTE_PROP_MAX", + "value": "100.0", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 562, + "column": 1, + "source_line": "#define STBTE_PROP_MAX(n,td,tp) 100.0" + } + }, + { + "name": "STBTE_PROP_FLOAT_SCALE", + "value": "1", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 566, + "column": 1, + "source_line": "#define STBTE_PROP_FLOAT_SCALE(n,td,tp) 1 // default scale size" + } + }, + { + "name": "STBTE_FLOAT_CONTROL_GRANULARITY", + "value": "4", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 570, + "column": 1, + "source_line": "#define STBTE_FLOAT_CONTROL_GRANULARITY 4" + } + }, + { + "name": "STBTE__UNDO_BUFFER_COUNT", + "value": "(STBTE_UNDO_BUFFER_BYTES>>1)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 574, + "column": 1, + "source_line": "#define STBTE__UNDO_BUFFER_COUNT (STBTE_UNDO_BUFFER_BYTES>>1)" + } + }, + { + "name": "STBTE__NO_PROPS", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 587, + "column": 1, + "source_line": "#define STBTE__NO_PROPS" + } + }, + { + "name": "STBTE_MAX_PROPERTIES", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 591, + "column": 1, + "source_line": "#undef STBTE_MAX_PROPERTIES" + } + }, + { + "name": "STBTE_MAX_PROPERTIES", + "value": "1", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 592, + "column": 1, + "source_line": "#define STBTE_MAX_PROPERTIES 1 // so we can declare arrays" + } + }, + { + "name": "STBTE_COLOR_TILEMAP_BACKGROUND", + "value": "0x000000", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 708, + "column": 1, + "source_line": "#define STBTE_COLOR_TILEMAP_BACKGROUND 0x000000" + } + }, + { + "name": "STBTE_COLOR_TILEMAP_BORDER", + "value": "0x203060", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 709, + "column": 1, + "source_line": "#define STBTE_COLOR_TILEMAP_BORDER 0x203060" + } + }, + { + "name": "STBTE_COLOR_TILEMAP_HIGHLIGHT", + "value": "0xffffff", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 710, + "column": 1, + "source_line": "#define STBTE_COLOR_TILEMAP_HIGHLIGHT 0xffffff" + } + }, + { + "name": "STBTE_COLOR_GRID", + "value": "0x404040", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 711, + "column": 1, + "source_line": "#define STBTE_COLOR_GRID 0x404040" + } + }, + { + "name": "STBTE_COLOR_SELECTION_OUTLINE1", + "value": "0xdfdfdf", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 712, + "column": 1, + "source_line": "#define STBTE_COLOR_SELECTION_OUTLINE1 0xdfdfdf" + } + }, + { + "name": "STBTE_COLOR_SELECTION_OUTLINE2", + "value": "0x303030", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 713, + "column": 1, + "source_line": "#define STBTE_COLOR_SELECTION_OUTLINE2 0x303030" + } + }, + { + "name": "STBTE_COLOR_TILEPALETTE_OUTLINE", + "value": "0xffffff", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 714, + "column": 1, + "source_line": "#define STBTE_COLOR_TILEPALETTE_OUTLINE 0xffffff" + } + }, + { + "name": "STBTE_COLOR_TILEPALETTE_BACKGROUND", + "value": "0x000000", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 715, + "column": 1, + "source_line": "#define STBTE_COLOR_TILEPALETTE_BACKGROUND 0x000000" + } + }, + { + "name": "STBTE_LINK_COLOR", + "value": "0x5030ff", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 718, + "column": 1, + "source_line": "#define STBTE_LINK_COLOR(src,sp,dest,dp) 0x5030ff" + } + }, + { + "name": "STBTE_LINK_COLOR_DRAWING", + "value": "0xff40ff", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 722, + "column": 1, + "source_line": "#define STBTE_LINK_COLOR_DRAWING 0xff40ff" + } + }, + { + "name": "STBTE_LINK_COLOR_DISALLOWED", + "value": "0x602060", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 726, + "column": 1, + "source_line": "#define STBTE_LINK_COLOR_DISALLOWED 0x602060" + } + }, + { + "name": "STBTE__INDEX_FOR_STATE", + "value": "stbte__state_to_index[disable][select][down][over]", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 741, + "column": 1, + "source_line": "#define STBTE__INDEX_FOR_STATE(disable,select,down,over) stbte__state_to_index[disable][select][down][over]" + } + }, + { + "name": "STBTE__INDEX_FOR_ID", + "value": "STBTE__INDEX_FOR_STATE(disable,select,STBTE__IS_ACTIVE(id),STBTE__IS_HOT(id))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 742, + "column": 1, + "source_line": "#define STBTE__INDEX_FOR_ID(id,disable,select) STBTE__INDEX_FOR_STATE(disable,select,STBTE__IS_ACTIVE(id),STBTE__IS_HOT(id))" + } + }, + { + "name": "STBTE__FONT_HEIGHT", + "value": "9", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 744, + "column": 1, + "source_line": "#define STBTE__FONT_HEIGHT 9" + } + }, + { + "name": "MAX_LAYERMASK", + "value": "(1 << (8*sizeof(unsigned int)))", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 790, + "column": 1, + "source_line": "#define MAX_LAYERMASK (1 << (8*sizeof(unsigned int)))" + } + }, + { + "name": "STBTE__NO_TILE", + "value": "-1", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 794, + "column": 1, + "source_line": "#define STBTE__NO_TILE -1" + } + }, + { + "name": "STBTE__MAX_DELAYRECT", + "value": "256", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 875, + "column": 1, + "source_line": "#define STBTE__MAX_DELAYRECT 256" + } + }, + { + "name": "STBTE__INACTIVE", + "value": "(stbte__ui.active_id == 0)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 921, + "column": 1, + "source_line": "#define STBTE__INACTIVE() (stbte__ui.active_id == 0)" + } + }, + { + "name": "STBTE__IS_ACTIVE", + "value": "(stbte__ui.active_id == (id))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 922, + "column": 1, + "source_line": "#define STBTE__IS_ACTIVE(id) (stbte__ui.active_id == (id))" + } + }, + { + "name": "STBTE__IS_HOT", + "value": "(stbte__ui.hot_id == (id))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 923, + "column": 1, + "source_line": "#define STBTE__IS_HOT(id) (stbte__ui.hot_id == (id))" + } + }, + { + "name": "STBTE__BUTTON_HEIGHT", + "value": "(STBTE__FONT_HEIGHT + 2 * STBTE__BUTTON_INTERNAL_SPACING)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 925, + "column": 1, + "source_line": "#define STBTE__BUTTON_HEIGHT (STBTE__FONT_HEIGHT + 2 * STBTE__BUTTON_INTERNAL_SPACING)" + } + }, + { + "name": "STBTE__BUTTON_INTERNAL_SPACING", + "value": "(2 + (STBTE__FONT_HEIGHT>>4))", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 926, + "column": 1, + "source_line": "#define STBTE__BUTTON_INTERNAL_SPACING (2 + (STBTE__FONT_HEIGHT>>4))" + } + }, + { + "name": "stbte__wrap", + "value": "((pos) & (STBTE__UNDO_BUFFER_COUNT-1))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1343, + "column": 1, + "source_line": "#define stbte__wrap(pos) ((pos) & (STBTE__UNDO_BUFFER_COUNT-1))" + } + }, + { + "name": "STBTE__undo_record", + "value": "-2", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1345, + "column": 1, + "source_line": "#define STBTE__undo_record -2" + } + }, + { + "name": "STBTE__redo_record", + "value": "-3", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1346, + "column": 1, + "source_line": "#define STBTE__redo_record -3" + } + }, + { + "name": "STBTE__undo_junk", + "value": "-4", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1347, + "column": 1, + "source_line": "#define STBTE__undo_junk -4 // this is written underneath the undo pointer, never used" + } + }, + { + "name": "stbte__sprintf", + "value": "sprintf_s", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1975, + "column": 4, + "source_line": " #define stbte__sprintf sprintf_s" + } + }, + { + "name": "stbte__sizeof", + "value": ", sizeof(s)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1976, + "column": 4, + "source_line": " #define stbte__sizeof(s) , sizeof(s)" + } + }, + { + "name": "stbte__sprintf", + "value": "sprintf", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1978, + "column": 4, + "source_line": " #define stbte__sprintf sprintf" + } + }, + { + "name": "stbte__sizeof", + "value": null, + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1979, + "column": 4, + "source_line": " #define stbte__sizeof(s)" + } + }, + { + "name": "STBTE__TOOLBAR_ICON_SIZE", + "value": "(9+2*2)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2104, + "column": 1, + "source_line": "#define STBTE__TOOLBAR_ICON_SIZE (9+2*2)" + } + }, + { + "name": "STBTE__TOOLBAR_PASTE_SIZE", + "value": "(34+2*2)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2105, + "column": 1, + "source_line": "#define STBTE__TOOLBAR_PASTE_SIZE (34+2*2)" + } + }, + { + "name": "STBTE__ID", + "value": "((n) + ((p)<<7))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2271, + "column": 1, + "source_line": "#define STBTE__ID(n,p) ((n) + ((p)<<7))" + } + }, + { + "name": "STBTE__ID2", + "value": "STBTE__ID(n, ((p)<<12)+(q) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2272, + "column": 1, + "source_line": "#define STBTE__ID2(n,p,q) STBTE__ID(n, ((p)<<12)+(q) )" + } + }, + { + "name": "STBTE__IDMAP", + "value": "STBTE__ID2(STBTE__map, x,y)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2273, + "column": 1, + "source_line": "#define STBTE__IDMAP(x,y) STBTE__ID2(STBTE__map, x,y)" + } + }, + { + "name": "STBTE__BG", + "value": "((layer) == 0 ? (tm)->background_tile : STBTE__NO_TILE)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2289, + "column": 1, + "source_line": "#define STBTE__BG(tm,layer) ((layer) == 0 ? (tm)->background_tile : STBTE__NO_TILE)" + } + }, + { + "name": "STBTE__IS_MAP_ACTIVE", + "value": "((stbte__ui.active_id & 127) == STBTE__map)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2638, + "column": 1, + "source_line": "#define STBTE__IS_MAP_ACTIVE() ((stbte__ui.active_id & 127) == STBTE__map)" + } + }, + { + "name": "STBTE__IS_MAP_HOT", + "value": "((stbte__ui.hot_id & 127) == STBTE__map)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2639, + "column": 1, + "source_line": "#define STBTE__IS_MAP_HOT() ((stbte__ui.hot_id & 127) == STBTE__map)" + } + }, + { + "name": "STBTE__TEXTCOLOR", + "value": "stbte__color_table[n][STBTE__text][STBTE__idle]", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3374, + "column": 1, + "source_line": "#define STBTE__TEXTCOLOR(n) stbte__color_table[n][STBTE__text][STBTE__idle]" + } + } + ], + "includes": [ + { + "target": "stdlib.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 341, + "column": 3, + "source_line": " #include " + } + }, + { + "target": "stdio.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 342, + "column": 3, + "source_line": " #include " + } + }, + { + "target": "assert.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 511, + "column": 1, + "source_line": "#include " + } + } + ], + "raw_directives": [ + { + "directive": "ifndef", + "argument": "STB_TILEMAP_INCLUDE_STB_TILEMAP_EDITOR_H", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 334, + "column": 1, + "source_line": "#ifndef STB_TILEMAP_INCLUDE_STB_TILEMAP_EDITOR_H" + } + }, + { + "directive": "ifdef", + "argument": "_WIN32", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 337, + "column": 1, + "source_line": "#ifdef _WIN32" + } + }, + { + "directive": "ifndef", + "argument": "_CRT_SECURE_NO_WARNINGS", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 338, + "column": 3, + "source_line": " #ifndef _CRT_SECURE_NO_WARNINGS" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 340, + "column": 3, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 343, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 505, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STB_TILEMAP_EDITOR_IMPLEMENTATION", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 507, + "column": 1, + "source_line": "#ifdef STB_TILEMAP_EDITOR_IMPLEMENTATION" + } + }, + { + "directive": "ifndef", + "argument": "STBTE_ASSERT", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 509, + "column": 1, + "source_line": "#ifndef STBTE_ASSERT" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 512, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "_MSC_VER", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 514, + "column": 1, + "source_line": "#ifdef _MSC_VER" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 516, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 518, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBTE_MAX_TILEMAP_X", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 520, + "column": 1, + "source_line": "#ifndef STBTE_MAX_TILEMAP_X" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 522, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBTE_MAX_TILEMAP_Y", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 524, + "column": 1, + "source_line": "#ifndef STBTE_MAX_TILEMAP_Y" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 526, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBTE_MAX_LAYERS", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 528, + "column": 1, + "source_line": "#ifndef STBTE_MAX_LAYERS" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 530, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBTE_MAX_CATEGORIES", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 532, + "column": 1, + "source_line": "#ifndef STBTE_MAX_CATEGORIES" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 534, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBTE_MAX_COPY", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 536, + "column": 1, + "source_line": "#ifndef STBTE_MAX_COPY" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 538, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBTE_UNDO_BUFFER_BYTES", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 540, + "column": 1, + "source_line": "#ifndef STBTE_UNDO_BUFFER_BYTES" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 542, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBTE_PROP_TYPE", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 544, + "column": 1, + "source_line": "#ifndef STBTE_PROP_TYPE" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 547, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBTE_PROP_NAME", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 549, + "column": 1, + "source_line": "#ifndef STBTE_PROP_NAME" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 551, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBTE_MAX_PROPERTIES", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 553, + "column": 1, + "source_line": "#ifndef STBTE_MAX_PROPERTIES" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 555, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBTE_PROP_MIN", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 557, + "column": 1, + "source_line": "#ifndef STBTE_PROP_MIN" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 559, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBTE_PROP_MAX", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 561, + "column": 1, + "source_line": "#ifndef STBTE_PROP_MAX" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 563, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBTE_PROP_FLOAT_SCALE", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 565, + "column": 1, + "source_line": "#ifndef STBTE_PROP_FLOAT_SCALE" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 567, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBTE_FLOAT_CONTROL_GRANULARITY", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 569, + "column": 1, + "source_line": "#ifndef STBTE_FLOAT_CONTROL_GRANULARITY" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 571, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "STBTE_MAX_TILEMAP_X > 4096 || STBTE_MAX_TILEMAP_Y > 4096", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 576, + "column": 1, + "source_line": "#if STBTE_MAX_TILEMAP_X > 4096 || STBTE_MAX_TILEMAP_Y > 4096" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 578, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "STBTE_MAX_LAYERS > 32", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 579, + "column": 1, + "source_line": "#if STBTE_MAX_LAYERS > 32" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 581, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "STBTE_UNDO_BUFFER_COUNT & (STBTE_UNDO_BUFFER_COUNT-1)", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 582, + "column": 1, + "source_line": "#if STBTE_UNDO_BUFFER_COUNT & (STBTE_UNDO_BUFFER_COUNT-1)" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 584, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "STBTE_MAX_PROPERTIES == 0", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 586, + "column": 1, + "source_line": "#if STBTE_MAX_PROPERTIES == 0" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 588, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBTE__NO_PROPS", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 590, + "column": 1, + "source_line": "#ifdef STBTE__NO_PROPS" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 593, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBTE__COLORPICKER", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 640, + "column": 1, + "source_line": "#ifdef STBTE__COLORPICKER" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 648, + "column": 1, + "source_line": "#endif // STBTE__COLORPICKER" + } + }, + { + "directive": "ifndef", + "argument": "STBTE_LINK_COLOR", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 717, + "column": 1, + "source_line": "#ifndef STBTE_LINK_COLOR" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 719, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBTE_LINK_COLOR_DRAWING", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 721, + "column": 1, + "source_line": "#ifndef STBTE_LINK_COLOR_DRAWING" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 723, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBTE_LINK_COLOR_DISALLOWED", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 725, + "column": 1, + "source_line": "#ifndef STBTE_LINK_COLOR_DISALLOWED" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 727, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBTE_ALLOW_LINK", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 910, + "column": 1, + "source_line": "#ifdef STBTE_ALLOW_LINK" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 912, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBTE_ALLOW_LINK", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 946, + "column": 5, + "source_line": " #ifdef STBTE_ALLOW_LINK" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 949, + "column": 5, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "STBTE_ALLOW_LINK", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1161, + "column": 1, + "source_line": "#ifdef STBTE_ALLOW_LINK" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1169, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBTE_ALLOW_LINK", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1179, + "column": 1, + "source_line": "#ifdef STBTE_ALLOW_LINK" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1181, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBTE_ALLOW_LINK", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1192, + "column": 1, + "source_line": "#ifdef STBTE_ALLOW_LINK" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1194, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1196, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBTE_ALLOW_LINK", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1222, + "column": 7, + "source_line": " #ifdef STBTE_ALLOW_LINK" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1226, + "column": 7, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "STBTE_ALLOW_LINK", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1506, + "column": 1, + "source_line": "#ifdef STBTE_ALLOW_LINK" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1510, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBTE_ALLOW_LINK", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1575, + "column": 1, + "source_line": "#ifdef STBTE_ALLOW_LINK" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1579, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBTE_ALLOW_LINK", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1623, + "column": 1, + "source_line": "#ifdef STBTE_ALLOW_LINK" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1650, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBTE_ALLOW_LINK", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1658, + "column": 1, + "source_line": "#ifdef STBTE_ALLOW_LINK" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1672, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "defined(_WIN32) && defined(__STDC_WANT_SECURE_LIB__)", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1974, + "column": 1, + "source_line": "#if defined(_WIN32) && defined(__STDC_WANT_SECURE_LIB__)" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1977, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1980, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBTE__NO_PROPS", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2121, + "column": 1, + "source_line": "#ifdef STBTE__NO_PROPS" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2123, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2125, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBTE__COLORPICKER", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2139, + "column": 1, + "source_line": "#ifdef STBTE__COLORPICKER" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2141, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBTE_ALLOW_LINK", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2717, + "column": 1, + "source_line": "#ifdef STBTE_ALLOW_LINK" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2721, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBTE_ALLOW_LINK", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2743, + "column": 1, + "source_line": "#ifdef STBTE_ALLOW_LINK" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2753, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBTE_ALLOW_LINK", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2784, + "column": 1, + "source_line": "#ifdef STBTE_ALLOW_LINK" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2805, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBTE_ALLOW_LINK", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2870, + "column": 4, + "source_line": " #ifdef STBTE_ALLOW_LINK" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2911, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "STBTE_ALLOW_LINK", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3056, + "column": 1, + "source_line": "#ifdef STBTE_ALLOW_LINK" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3073, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBTE_ALLOW_LINK", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3165, + "column": 1, + "source_line": "#ifdef STBTE_ALLOW_LINK" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3198, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBTE_ALLOW_LINK", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3329, + "column": 7, + "source_line": " #ifndef STBTE_ALLOW_LINK" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3332, + "column": 7, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STBTE_NO_PROPS", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3453, + "column": 1, + "source_line": "#ifndef STBTE_NO_PROPS" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3455, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBTE_NO_PROPS", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3477, + "column": 1, + "source_line": "#ifndef STBTE_NO_PROPS" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3484, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBTE__COLORPICKER", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3673, + "column": 1, + "source_line": "#ifdef STBTE__COLORPICKER" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3776, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBTE_ALLOW_LINK", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3867, + "column": 7, + "source_line": " #ifdef STBTE_ALLOW_LINK" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3883, + "column": 7, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "STBTE__COLORPICKER", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3911, + "column": 1, + "source_line": "#ifdef STBTE__COLORPICKER" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3913, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBTE_SHOW_CURSOR", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3982, + "column": 1, + "source_line": "#ifdef STBTE_SHOW_CURSOR" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3985, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "_SDL_H", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 4116, + "column": 1, + "source_line": "#ifdef _SDL_H" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 4135, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 4142, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 4145, + "column": 1, + "source_line": "#endif // STB_TILEMAP_EDITOR_IMPLEMENTATION" + } + } + ], + "macro_dependencies": [], + "diagnostics": [ + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTE__NOTUSED' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 515, + "column": 1, + "source_line": "#define STBTE__NOTUSED(v) (void)(v)" + }, + "unit_kind": "macro", + "unit_name": "STBTE__NOTUSED" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTE__NOTUSED' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 517, + "column": 1, + "source_line": "#define STBTE__NOTUSED(v) (void)sizeof(v)" + }, + "unit_kind": "macro", + "unit_name": "STBTE__NOTUSED" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTE_PROP_TYPE' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 546, + "column": 1, + "source_line": "#define STBTE_PROP_TYPE(n,td,tp) 0" + }, + "unit_kind": "macro", + "unit_name": "STBTE_PROP_TYPE" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTE_PROP_NAME' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 550, + "column": 1, + "source_line": "#define STBTE_PROP_NAME(n,td,tp) \"\"" + }, + "unit_kind": "macro", + "unit_name": "STBTE_PROP_NAME" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTE_PROP_MIN' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 558, + "column": 1, + "source_line": "#define STBTE_PROP_MIN(n,td,tp) 0" + }, + "unit_kind": "macro", + "unit_name": "STBTE_PROP_MIN" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTE_PROP_MAX' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 562, + "column": 1, + "source_line": "#define STBTE_PROP_MAX(n,td,tp) 100.0" + }, + "unit_kind": "macro", + "unit_name": "STBTE_PROP_MAX" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTE_PROP_FLOAT_SCALE' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 566, + "column": 1, + "source_line": "#define STBTE_PROP_FLOAT_SCALE(n,td,tp) 1 // default scale size" + }, + "unit_kind": "macro", + "unit_name": "STBTE_PROP_FLOAT_SCALE" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTE_LINK_COLOR' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 718, + "column": 1, + "source_line": "#define STBTE_LINK_COLOR(src,sp,dest,dp) 0x5030ff" + }, + "unit_kind": "macro", + "unit_name": "STBTE_LINK_COLOR" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTE__INDEX_FOR_STATE' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 741, + "column": 1, + "source_line": "#define STBTE__INDEX_FOR_STATE(disable,select,down,over) stbte__state_to_index[disable][select][down][over]" + }, + "unit_kind": "macro", + "unit_name": "STBTE__INDEX_FOR_STATE" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTE__INDEX_FOR_ID' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 742, + "column": 1, + "source_line": "#define STBTE__INDEX_FOR_ID(id,disable,select) STBTE__INDEX_FOR_STATE(disable,select,STBTE__IS_ACTIVE(id),STBTE__IS_HOT(id))" + }, + "unit_kind": "macro", + "unit_name": "STBTE__INDEX_FOR_ID" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTE__INACTIVE' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 921, + "column": 1, + "source_line": "#define STBTE__INACTIVE() (stbte__ui.active_id == 0)" + }, + "unit_kind": "macro", + "unit_name": "STBTE__INACTIVE" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTE__IS_ACTIVE' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 922, + "column": 1, + "source_line": "#define STBTE__IS_ACTIVE(id) (stbte__ui.active_id == (id))" + }, + "unit_kind": "macro", + "unit_name": "STBTE__IS_ACTIVE" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTE__IS_HOT' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 923, + "column": 1, + "source_line": "#define STBTE__IS_HOT(id) (stbte__ui.hot_id == (id))" + }, + "unit_kind": "macro", + "unit_name": "STBTE__IS_HOT" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbte__wrap' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1343, + "column": 1, + "source_line": "#define stbte__wrap(pos) ((pos) & (STBTE__UNDO_BUFFER_COUNT-1))" + }, + "unit_kind": "macro", + "unit_name": "stbte__wrap" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbte__sizeof' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1976, + "column": 4, + "source_line": " #define stbte__sizeof(s) , sizeof(s)" + }, + "unit_kind": "macro", + "unit_name": "stbte__sizeof" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbte__sizeof' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1979, + "column": 4, + "source_line": " #define stbte__sizeof(s)" + }, + "unit_kind": "macro", + "unit_name": "stbte__sizeof" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTE__ID' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2271, + "column": 1, + "source_line": "#define STBTE__ID(n,p) ((n) + ((p)<<7))" + }, + "unit_kind": "macro", + "unit_name": "STBTE__ID" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTE__ID2' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2272, + "column": 1, + "source_line": "#define STBTE__ID2(n,p,q) STBTE__ID(n, ((p)<<12)+(q) )" + }, + "unit_kind": "macro", + "unit_name": "STBTE__ID2" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTE__IDMAP' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2273, + "column": 1, + "source_line": "#define STBTE__IDMAP(x,y) STBTE__ID2(STBTE__map, x,y)" + }, + "unit_kind": "macro", + "unit_name": "STBTE__IDMAP" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTE__BG' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2289, + "column": 1, + "source_line": "#define STBTE__BG(tm,layer) ((layer) == 0 ? (tm)->background_tile : STBTE__NO_TILE)" + }, + "unit_kind": "macro", + "unit_name": "STBTE__BG" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTE__IS_MAP_ACTIVE' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2638, + "column": 1, + "source_line": "#define STBTE__IS_MAP_ACTIVE() ((stbte__ui.active_id & 127) == STBTE__map)" + }, + "unit_kind": "macro", + "unit_name": "STBTE__IS_MAP_ACTIVE" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTE__IS_MAP_HOT' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2639, + "column": 1, + "source_line": "#define STBTE__IS_MAP_HOT() ((stbte__ui.hot_id & 127) == STBTE__map)" + }, + "unit_kind": "macro", + "unit_name": "STBTE__IS_MAP_HOT" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTE__TEXTCOLOR' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3374, + "column": 1, + "source_line": "#define STBTE__TEXTCOLOR(n) stbte__color_table[n][STBTE__text][STBTE__idle]" + }, + "unit_kind": "macro", + "unit_name": "STBTE__TEXTCOLOR" + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 641, + "column": 1, + "source_line": "static char *stbte__color_names[] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 651, + "column": 1, + "source_line": "static int stbte__color_table[STBTE__num_color_modes][STBTE__num_color_aspects][STBTE__num_color_states] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 731, + "column": 1, + "source_line": "static unsigned char stbte__state_to_index[2][2][2][2] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 746, + "column": 1, + "source_line": "static short stbte__fontdata[769] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 838, + "column": 1, + "source_line": "static int toolchar[] = { 26,24,25,20,23,22,18, 19,17, 29,28, };" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 919, + "column": 1, + "source_line": "static stbte__ui_t stbte__ui = { STBTE__tool_brush, 0 };" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + } + ] + } + }, + "functions": { + "stbte_create_map": { + "name": "stbte_create_map", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "parameters": [ + { + "name": "map_x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int map_x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int map_x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "map_y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int map_y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int map_y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "map_layers", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int map_layers" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int map_layers" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "spacing_x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int spacing_x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int spacing_x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "spacing_y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int spacing_y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int spacing_y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "max_tiles", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int max_tiles" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int max_tiles" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1007, + "column": 1, + "source_line": "stbte_tilemap *stbte_create_map(int map_x, int map_y, int map_layers, int spacing_x, int spacing_y, int max_tiles)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1007, + "column": 1, + "source_line": "stbte_tilemap *stbte_create_map(int map_x, int map_y, int map_layers, int spacing_x, int spacing_y, int max_tiles)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1065, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_tilemap_editor.h", + "line": 367, + "column": 1, + "source_line": "extern stbte_tilemap *stbte_create_map(int map_x, int map_y, int map_layers, int spacing_x, int spacing_y, int max_tiles);" + } + ] + }, + "stbte_define_tile": { + "name": "stbte_define_tile", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "id", + "type": { + "model": "CUnsignedShort", + "qualifiers": [], + "source_text": "unsigned short id" + }, + "declared_type": { + "model": "CUnsignedShort", + "qualifiers": [], + "source_text": "unsigned short id" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "layermask", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int layermask" + }, + "declared_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int layermask" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "category_c", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * category_c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char * category_c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1102, + "column": 1, + "source_line": "void stbte_define_tile(stbte_tilemap *tm, unsigned short id, unsigned int layermask, const char * category_c)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1102, + "column": 1, + "source_line": "void stbte_define_tile(stbte_tilemap *tm, unsigned short id, unsigned int layermask, const char * category_c)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1119, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_tilemap_editor.h", + "line": 378, + "column": 1, + "source_line": "extern void stbte_define_tile(stbte_tilemap *tm, unsigned short id, unsigned int layermask, const char * category);" + } + ] + }, + "stbte_set_display": { + "name": "stbte_set_display", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "x0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1094, + "column": 1, + "source_line": "void stbte_set_display(int x0, int y0, int x1, int y1)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1094, + "column": 1, + "source_line": "void stbte_set_display(int x0, int y0, int x1, int y1)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1100, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_tilemap_editor.h", + "line": 387, + "column": 1, + "source_line": "extern void stbte_set_display(int x0, int y0, int x1, int y1);" + } + ] + }, + "stbte_draw": { + "name": "stbte_draw", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 4053, + "column": 1, + "source_line": "void stbte_draw(stbte_tilemap *tm)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 4053, + "column": 1, + "source_line": "void stbte_draw(stbte_tilemap *tm)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 4057, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_tilemap_editor.h", + "line": 396, + "column": 1, + "source_line": "extern void stbte_draw(stbte_tilemap *tm);" + } + ] + }, + "stbte_tick": { + "name": "stbte_tick", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dt", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dt" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dt" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 4106, + "column": 1, + "source_line": "void stbte_tick(stbte_tilemap *tm, float dt)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 4106, + "column": 1, + "source_line": "void stbte_tick(stbte_tilemap *tm, float dt)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 4112, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_tilemap_editor.h", + "line": 398, + "column": 1, + "source_line": "extern void stbte_tick(stbte_tilemap *tm, float time_in_seconds_since_last_frame);" + } + ] + }, + "stbte_mouse_sdl": { + "name": "stbte_mouse_sdl", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "sdl_event", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const void *sdl_event", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [ + "const" + ], + "source_text": "const void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const void *sdl_event", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [ + "const" + ], + "source_text": "const void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "xs", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float xs" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float xs" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ys", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float ys" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float ys" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "xo", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int xo" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int xo" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "yo", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int yo" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int yo" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 4114, + "column": 1, + "source_line": "void stbte_mouse_sdl(stbte_tilemap *tm, const void *sdl_event, float xs, float ys, int xo, int yo)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 4114, + "column": 1, + "source_line": "void stbte_mouse_sdl(stbte_tilemap *tm, const void *sdl_event, float xs, float ys, int xo, int yo)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 4143, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_tilemap_editor.h", + "line": 407, + "column": 1, + "source_line": "extern void stbte_mouse_sdl(stbte_tilemap *tm, const void *sdl_event, float xscale, float yscale, int xoffset, int yoffset);" + } + ] + }, + "stbte_mouse_move": { + "name": "stbte_mouse_move", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "shifted", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int shifted" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int shifted" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "scrollkey", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int scrollkey" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int scrollkey" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 4059, + "column": 1, + "source_line": "void stbte_mouse_move(stbte_tilemap *tm, int x, int y, int shifted, int scrollkey)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 4059, + "column": 1, + "source_line": "void stbte_mouse_move(stbte_tilemap *tm, int x, int y, int shifted, int scrollkey)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 4065, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_tilemap_editor.h", + "line": 410, + "column": 1, + "source_line": "extern void stbte_mouse_move(stbte_tilemap *tm, int x, int y, int shifted, int scrollkey);" + } + ] + }, + "stbte_mouse_button": { + "name": "stbte_mouse_button", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "right", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int right" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int right" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "down", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int down" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int down" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "shifted", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int shifted" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int shifted" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "scrollkey", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int scrollkey" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int scrollkey" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 4067, + "column": 1, + "source_line": "void stbte_mouse_button(stbte_tilemap *tm, int x, int y, int right, int down, int shifted, int scrollkey)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 4067, + "column": 1, + "source_line": "void stbte_mouse_button(stbte_tilemap *tm, int x, int y, int right, int down, int shifted, int scrollkey)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 4076, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_tilemap_editor.h", + "line": 411, + "column": 1, + "source_line": "extern void stbte_mouse_button(stbte_tilemap *tm, int x, int y, int right, int down, int shifted, int scrollkey);" + } + ] + }, + "stbte_mouse_wheel": { + "name": "stbte_mouse_wheel", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "vscroll", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int vscroll" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int vscroll" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 4078, + "column": 1, + "source_line": "void stbte_mouse_wheel(stbte_tilemap *tm, int x, int y, int vscroll)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 4078, + "column": 1, + "source_line": "void stbte_mouse_wheel(stbte_tilemap *tm, int x, int y, int vscroll)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 4081, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_tilemap_editor.h", + "line": 412, + "column": 1, + "source_line": "extern void stbte_mouse_wheel(stbte_tilemap *tm, int x, int y, int vscroll);" + } + ] + }, + "stbte_action": { + "name": "stbte_action", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "act", + "type": { + "reference": "enum stbte_action" + }, + "declared_type": { + "reference": "enum stbte_action" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 4083, + "column": 1, + "source_line": "void stbte_action(stbte_tilemap *tm, enum stbte_action act)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 4083, + "column": 1, + "source_line": "void stbte_action(stbte_tilemap *tm, enum stbte_action act)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 4104, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_tilemap_editor.h", + "line": 438, + "column": 1, + "source_line": "extern void stbte_action(stbte_tilemap *tm, enum stbte_action act);" + } + ] + }, + "stbte_get_dimensions": { + "name": "stbte_get_dimensions", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "max_x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *max_x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *max_x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "max_y", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *max_y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *max_y", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1135, + "column": 1, + "source_line": "void stbte_get_dimensions(stbte_tilemap *tm, int *max_x, int *max_y)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1135, + "column": 1, + "source_line": "void stbte_get_dimensions(stbte_tilemap *tm, int *max_x, int *max_y)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1139, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_tilemap_editor.h", + "line": 451, + "column": 1, + "source_line": "extern void stbte_get_dimensions(stbte_tilemap *tm, int *max_x, int *max_y);" + } + ] + }, + "stbte_get_tile": { + "name": "stbte_get_tile", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1141, + "column": 1, + "source_line": "short* stbte_get_tile(stbte_tilemap *tm, int x, int y)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1141, + "column": 1, + "source_line": "short* stbte_get_tile(stbte_tilemap *tm, int x, int y)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1147, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_tilemap_editor.h", + "line": 454, + "column": 1, + "source_line": "extern short* stbte_get_tile(stbte_tilemap *tm, int x, int y);" + } + ] + }, + "stbte_get_properties": { + "name": "stbte_get_properties", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1149, + "column": 1, + "source_line": "float *stbte_get_properties(stbte_tilemap *tm, int x, int y)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1149, + "column": 1, + "source_line": "float *stbte_get_properties(stbte_tilemap *tm, int x, int y)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1155, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_tilemap_editor.h", + "line": 458, + "column": 1, + "source_line": "extern float *stbte_get_properties(stbte_tilemap *tm, int x, int y);" + } + ] + }, + "stbte_get_link": { + "name": "stbte_get_link", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "destx", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *destx", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *destx", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "desty", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *desty", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *desty", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1157, + "column": 1, + "source_line": "void stbte_get_link(stbte_tilemap *tm, int x, int y, int *destx, int *desty)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1157, + "column": 1, + "source_line": "void stbte_get_link(stbte_tilemap *tm, int x, int y, int *destx, int *desty)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1172, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_tilemap_editor.h", + "line": 463, + "column": 1, + "source_line": "extern void stbte_get_link(stbte_tilemap *tm, int x, int y, int *destx, int *desty);" + } + ] + }, + "stbte_set_dimensions": { + "name": "stbte_set_dimensions", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "map_x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int map_x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int map_x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "map_y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int map_y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int map_y" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1203, + "column": 1, + "source_line": "void stbte_set_dimensions(stbte_tilemap *tm, int map_x, int map_y)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1203, + "column": 1, + "source_line": "void stbte_set_dimensions(stbte_tilemap *tm, int map_x, int map_y)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1211, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_tilemap_editor.h", + "line": 466, + "column": 1, + "source_line": "extern void stbte_set_dimensions(stbte_tilemap *tm, int max_x, int max_y);" + } + ] + }, + "stbte_clear_map": { + "name": "stbte_clear_map", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1213, + "column": 1, + "source_line": "void stbte_clear_map(stbte_tilemap *tm)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1213, + "column": 1, + "source_line": "void stbte_clear_map(stbte_tilemap *tm)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1228, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_tilemap_editor.h", + "line": 470, + "column": 1, + "source_line": "extern void stbte_clear_map(stbte_tilemap *tm);" + } + ] + }, + "stbte_set_tile": { + "name": "stbte_set_tile", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "layer", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int layer" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int layer" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "tile", + "type": { + "model": "CShort", + "qualifiers": [], + "source_text": "signed short tile" + }, + "declared_type": { + "model": "CShort", + "qualifiers": [], + "source_text": "signed short tile" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1230, + "column": 1, + "source_line": "void stbte_set_tile(stbte_tilemap *tm, int x, int y, int layer, signed short tile)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1230, + "column": 1, + "source_line": "void stbte_set_tile(stbte_tilemap *tm, int x, int y, int layer, signed short tile)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1241, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_tilemap_editor.h", + "line": 474, + "column": 1, + "source_line": "extern void stbte_set_tile(stbte_tilemap *tm, int x, int y, int layer, signed short tile);" + } + ] + }, + "stbte_set_property": { + "name": "stbte_set_property", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "val", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float val" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float val" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1174, + "column": 1, + "source_line": "void stbte_set_property(stbte_tilemap *tm, int x, int y, int n, float val)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1174, + "column": 1, + "source_line": "void stbte_set_property(stbte_tilemap *tm, int x, int y, int n, float val)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1177, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_tilemap_editor.h", + "line": 477, + "column": 1, + "source_line": "extern void stbte_set_property(stbte_tilemap *tm, int x, int y, int n, float val);" + } + ] + }, + "stbte_set_link": { + "name": "stbte_set_link", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "destx", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int destx" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int destx" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "desty", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int desty" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int desty" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1190, + "column": 1, + "source_line": "void stbte_set_link(stbte_tilemap *tm, int x, int y, int destx, int desty)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1190, + "column": 1, + "source_line": "void stbte_set_link(stbte_tilemap *tm, int x, int y, int destx, int desty)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1197, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_tilemap_editor.h", + "line": 480, + "column": 1, + "source_line": "extern void stbte_set_link(stbte_tilemap *tm, int x, int y, int destx, int desty);" + } + ] + }, + "stbte_set_background_tile": { + "name": "stbte_set_background_tile", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "id", + "type": { + "model": "CShort", + "qualifiers": [], + "source_text": "short id" + }, + "declared_type": { + "model": "CShort", + "qualifiers": [], + "source_text": "short id" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1067, + "column": 1, + "source_line": "void stbte_set_background_tile(stbte_tilemap *tm, short id)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1067, + "column": 1, + "source_line": "void stbte_set_background_tile(stbte_tilemap *tm, short id)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1078, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_tilemap_editor.h", + "line": 489, + "column": 1, + "source_line": "extern void stbte_set_background_tile(stbte_tilemap *tm, short id);" + } + ] + }, + "stbte_set_sidewidths": { + "name": "stbte_set_sidewidths", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "left", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int left" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int left" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "right", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int right" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int right" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1088, + "column": 1, + "source_line": "void stbte_set_sidewidths(int left, int right)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1088, + "column": 1, + "source_line": "void stbte_set_sidewidths(int left, int right)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1092, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_tilemap_editor.h", + "line": 493, + "column": 1, + "source_line": "extern void stbte_set_sidewidths(int left, int right);" + } + ] + }, + "stbte_set_spacing": { + "name": "stbte_set_spacing", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "spacing_x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int spacing_x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int spacing_x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "spacing_y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int spacing_y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int spacing_y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "palette_spacing_x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int palette_spacing_x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int palette_spacing_x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "palette_spacing_y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int palette_spacing_y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int palette_spacing_y" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1080, + "column": 1, + "source_line": "void stbte_set_spacing(stbte_tilemap *tm, int spacing_x, int spacing_y, int palette_spacing_x, int palette_spacing_y)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1080, + "column": 1, + "source_line": "void stbte_set_spacing(stbte_tilemap *tm, int spacing_x, int spacing_y, int palette_spacing_x, int palette_spacing_y)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1086, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_tilemap_editor.h", + "line": 497, + "column": 1, + "source_line": "extern void stbte_set_spacing(stbte_tilemap *tm, int spacing_x, int spacing_y, int palette_spacing_x, int palette_spacing_y);" + } + ] + }, + "stbte_set_layername": { + "name": "stbte_set_layername", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "layer", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int layer" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int layer" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "layername", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *layername", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *layername", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1123, + "column": 1, + "source_line": "void stbte_set_layername(stbte_tilemap *tm, int layer, const char *layername)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1123, + "column": 1, + "source_line": "void stbte_set_layername(stbte_tilemap *tm, int layer, const char *layername)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1133, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_tilemap_editor.h", + "line": 501, + "column": 1, + "source_line": "extern void stbte_set_layername(stbte_tilemap *tm, int layer, const char *layername);" + } + ] + }, + "stbte__init_gui": { + "name": "stbte__init_gui", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 980, + "column": 1, + "source_line": "static void stbte__init_gui(void)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 980, + "column": 1, + "source_line": "static void stbte__init_gui(void)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1005, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__text_width": { + "name": "stbte__text_width", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1735, + "column": 1, + "source_line": "static int stbte__text_width(const char *str)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1735, + "column": 1, + "source_line": "static int stbte__text_width(const char *str)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1744, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_tilemap_editor.h", + "line": 1121, + "column": 1, + "source_line": "static int stbte__text_width(const char *str);" + } + ] + }, + "stbte__set_link": { + "name": "stbte__set_link", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "src_x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int src_x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int src_x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "src_y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int src_y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int src_y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dest_x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int dest_x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int dest_x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dest_y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int dest_y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int dest_y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "undo_mode", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int undo_mode" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int undo_mode" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1624, + "column": 1, + "source_line": "static void stbte__set_link(stbte_tilemap *tm, int src_x, int src_y, int dest_x, int dest_y, int undo_mode)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1624, + "column": 1, + "source_line": "static void stbte__set_link(stbte_tilemap *tm, int src_x, int src_y, int dest_x, int dest_y, int undo_mode)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1649, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_tilemap_editor.h", + "line": 1180, + "column": 1, + "source_line": "static void stbte__set_link(stbte_tilemap *tm, int src_x, int src_y, int dest_x, int dest_y, int undo_mode);" + } + ] + }, + "stbte__choose_category": { + "name": "stbte__choose_category", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "category", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int category" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int category" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1243, + "column": 1, + "source_line": "static void stbte__choose_category(stbte_tilemap *tm, int category)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1243, + "column": 1, + "source_line": "static void stbte__choose_category(stbte_tilemap *tm, int category)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1252, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__strequal": { + "name": "stbte__strequal", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "q", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *q", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *q", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1254, + "column": 1, + "source_line": "static int stbte__strequal(char *p, char *q)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1254, + "column": 1, + "source_line": "static int stbte__strequal(char *p, char *q)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1259, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__compute_tileinfo": { + "name": "stbte__compute_tileinfo", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1261, + "column": 1, + "source_line": "static void stbte__compute_tileinfo(stbte_tilemap *tm)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1261, + "column": 1, + "source_line": "static void stbte__compute_tileinfo(stbte_tilemap *tm)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1288, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__prepare_tileinfo": { + "name": "stbte__prepare_tileinfo", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1290, + "column": 1, + "source_line": "static void stbte__prepare_tileinfo(stbte_tilemap *tm)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1290, + "column": 1, + "source_line": "static void stbte__prepare_tileinfo(stbte_tilemap *tm)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1294, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__write_undo": { + "name": "stbte__write_undo", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "value", + "type": { + "model": "CShort", + "qualifiers": [], + "source_text": "short value" + }, + "declared_type": { + "model": "CShort", + "qualifiers": [], + "source_text": "short value" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1349, + "column": 1, + "source_line": "static void stbte__write_undo(stbte_tilemap *tm, short value)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1349, + "column": 1, + "source_line": "static void stbte__write_undo(stbte_tilemap *tm, short value)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1357, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__write_redo": { + "name": "stbte__write_redo", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "value", + "type": { + "model": "CShort", + "qualifiers": [], + "source_text": "short value" + }, + "declared_type": { + "model": "CShort", + "qualifiers": [], + "source_text": "short value" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1359, + "column": 1, + "source_line": "static void stbte__write_redo(stbte_tilemap *tm, short value)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1359, + "column": 1, + "source_line": "static void stbte__write_redo(stbte_tilemap *tm, short value)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1367, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__begin_undo": { + "name": "stbte__begin_undo", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1369, + "column": 1, + "source_line": "static void stbte__begin_undo(stbte_tilemap *tm)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1369, + "column": 1, + "source_line": "static void stbte__begin_undo(stbte_tilemap *tm)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1375, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__end_undo": { + "name": "stbte__end_undo", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1377, + "column": 1, + "source_line": "static void stbte__end_undo(stbte_tilemap *tm)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1377, + "column": 1, + "source_line": "static void stbte__end_undo(stbte_tilemap *tm)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1393, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__undo_record": { + "name": "stbte__undo_record", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "i", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int i" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int i" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "v", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1395, + "column": 1, + "source_line": "static void stbte__undo_record(stbte_tilemap *tm, int x, int y, int i, int v)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1395, + "column": 1, + "source_line": "static void stbte__undo_record(stbte_tilemap *tm, int x, int y, int i, int v)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1404, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__redo_record": { + "name": "stbte__redo_record", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "i", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int i" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int i" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "v", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1406, + "column": 1, + "source_line": "static void stbte__redo_record(stbte_tilemap *tm, int x, int y, int i, int v)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1406, + "column": 1, + "source_line": "static void stbte__redo_record(stbte_tilemap *tm, int x, int y, int i, int v)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1412, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__extract_float": { + "name": "stbte__extract_float", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "s0", + "type": { + "model": "CShort", + "qualifiers": [], + "source_text": "short s0" + }, + "declared_type": { + "model": "CShort", + "qualifiers": [], + "source_text": "short s0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "s1", + "type": { + "model": "CShort", + "qualifiers": [], + "source_text": "short s1" + }, + "declared_type": { + "model": "CShort", + "qualifiers": [], + "source_text": "short s1" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1414, + "column": 1, + "source_line": "static float stbte__extract_float(short s0, short s1)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1414, + "column": 1, + "source_line": "static float stbte__extract_float(short s0, short s1)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1420, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__extract_short": { + "name": "stbte__extract_short", + "result_type": { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float f" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float f" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "slot", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int slot" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int slot" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1422, + "column": 1, + "source_line": "static short stbte__extract_short(float f, int slot)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1422, + "column": 1, + "source_line": "static short stbte__extract_short(float f, int slot)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1427, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__undo_record_prop": { + "name": "stbte__undo_record_prop", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "i", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int i" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int i" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "s0", + "type": { + "model": "CShort", + "qualifiers": [], + "source_text": "short s0" + }, + "declared_type": { + "model": "CShort", + "qualifiers": [], + "source_text": "short s0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "s1", + "type": { + "model": "CShort", + "qualifiers": [], + "source_text": "short s1" + }, + "declared_type": { + "model": "CShort", + "qualifiers": [], + "source_text": "short s1" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1429, + "column": 1, + "source_line": "static void stbte__undo_record_prop(stbte_tilemap *tm, int x, int y, int i, short s0, short s1)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1429, + "column": 1, + "source_line": "static void stbte__undo_record_prop(stbte_tilemap *tm, int x, int y, int i, short s0, short s1)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1439, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__undo_record_prop_float": { + "name": "stbte__undo_record_prop_float", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "i", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int i" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int i" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "f", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float f" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float f" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1441, + "column": 1, + "source_line": "static void stbte__undo_record_prop_float(stbte_tilemap *tm, int x, int y, int i, float f)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1441, + "column": 1, + "source_line": "static void stbte__undo_record_prop_float(stbte_tilemap *tm, int x, int y, int i, float f)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1444, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__redo_record_prop": { + "name": "stbte__redo_record_prop", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "i", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int i" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int i" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "s0", + "type": { + "model": "CShort", + "qualifiers": [], + "source_text": "short s0" + }, + "declared_type": { + "model": "CShort", + "qualifiers": [], + "source_text": "short s0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "s1", + "type": { + "model": "CShort", + "qualifiers": [], + "source_text": "short s1" + }, + "declared_type": { + "model": "CShort", + "qualifiers": [], + "source_text": "short s1" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1446, + "column": 1, + "source_line": "static void stbte__redo_record_prop(stbte_tilemap *tm, int x, int y, int i, short s0, short s1)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1446, + "column": 1, + "source_line": "static void stbte__redo_record_prop(stbte_tilemap *tm, int x, int y, int i, short s0, short s1)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1453, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__undo_find_end": { + "name": "stbte__undo_find_end", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1456, + "column": 1, + "source_line": "static int stbte__undo_find_end(stbte_tilemap *tm)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1456, + "column": 1, + "source_line": "static int stbte__undo_find_end(stbte_tilemap *tm)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1472, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__undo": { + "name": "stbte__undo", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1474, + "column": 1, + "source_line": "static void stbte__undo(stbte_tilemap *tm)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1474, + "column": 1, + "source_line": "static void stbte__undo(stbte_tilemap *tm)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1525, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__redo_find_end": { + "name": "stbte__redo_find_end", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1527, + "column": 1, + "source_line": "static int stbte__redo_find_end(stbte_tilemap *tm)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1527, + "column": 1, + "source_line": "static int stbte__redo_find_end(stbte_tilemap *tm)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1543, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__redo": { + "name": "stbte__redo", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1545, + "column": 1, + "source_line": "static void stbte__redo(stbte_tilemap *tm)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1545, + "column": 1, + "source_line": "static void stbte__redo(stbte_tilemap *tm)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1598, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__recompute_undo_available": { + "name": "stbte__recompute_undo_available", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1601, + "column": 1, + "source_line": "static void stbte__recompute_undo_available(stbte_tilemap *tm)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1601, + "column": 1, + "source_line": "static void stbte__recompute_undo_available(stbte_tilemap *tm)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1605, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__undo_available": { + "name": "stbte__undo_available", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1607, + "column": 1, + "source_line": "static int stbte__undo_available(stbte_tilemap *tm)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1607, + "column": 1, + "source_line": "static int stbte__undo_available(stbte_tilemap *tm)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1612, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__redo_available": { + "name": "stbte__redo_available", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1614, + "column": 1, + "source_line": "static int stbte__redo_available(stbte_tilemap *tm)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1614, + "column": 1, + "source_line": "static int stbte__redo_available(stbte_tilemap *tm)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1619, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__draw_rect": { + "name": "stbte__draw_rect", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "x0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "color", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int color" + }, + "declared_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int color" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1653, + "column": 1, + "source_line": "static void stbte__draw_rect(int x0, int y0, int x1, int y1, unsigned int color)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1653, + "column": 1, + "source_line": "static void stbte__draw_rect(int x0, int y0, int x1, int y1, unsigned int color)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1656, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__draw_line": { + "name": "stbte__draw_line", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "x0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "color", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int color" + }, + "declared_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int color" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1659, + "column": 1, + "source_line": "static void stbte__draw_line(int x0, int y0, int x1, int y1, unsigned int color)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1659, + "column": 1, + "source_line": "static void stbte__draw_line(int x0, int y0, int x1, int y1, unsigned int color)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1665, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__draw_link": { + "name": "stbte__draw_link", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "x0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "color", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int color" + }, + "declared_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int color" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1667, + "column": 1, + "source_line": "static void stbte__draw_link(int x0, int y0, int x1, int y1, unsigned int color)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1667, + "column": 1, + "source_line": "static void stbte__draw_link(int x0, int y0, int x1, int y1, unsigned int color)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1671, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__draw_frame": { + "name": "stbte__draw_frame", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "x0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "color", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int color" + }, + "declared_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int color" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1674, + "column": 1, + "source_line": "static void stbte__draw_frame(int x0, int y0, int x1, int y1, unsigned int color)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1674, + "column": 1, + "source_line": "static void stbte__draw_frame(int x0, int y0, int x1, int y1, unsigned int color)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1680, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__get_char_width": { + "name": "stbte__get_char_width", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "ch", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ch" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ch" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1682, + "column": 1, + "source_line": "static int stbte__get_char_width(int ch)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1682, + "column": 1, + "source_line": "static int stbte__get_char_width(int ch)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1685, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__get_char_bitmap": { + "name": "stbte__get_char_bitmap", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "parameters": [ + { + "name": "ch", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ch" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ch" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1687, + "column": 1, + "source_line": "static short *stbte__get_char_bitmap(int ch)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1687, + "column": 1, + "source_line": "static short *stbte__get_char_bitmap(int ch)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1690, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__draw_bitmask_as_columns": { + "name": "stbte__draw_bitmask_as_columns", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "bitmask", + "type": { + "model": "CShort", + "qualifiers": [], + "source_text": "short bitmask" + }, + "declared_type": { + "model": "CShort", + "qualifiers": [], + "source_text": "short bitmask" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "color", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int color" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int color" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1692, + "column": 1, + "source_line": "static void stbte__draw_bitmask_as_columns(int x, int y, short bitmask, int color)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1692, + "column": 1, + "source_line": "static void stbte__draw_bitmask_as_columns(int x, int y, short bitmask, int color)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1706, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__draw_bitmap": { + "name": "stbte__draw_bitmap", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "w", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "bitmap", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short *bitmap", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short *bitmap", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "color", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int color" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int color" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1708, + "column": 1, + "source_line": "static void stbte__draw_bitmap(int x, int y, int w, short *bitmap, int color)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1708, + "column": 1, + "source_line": "static void stbte__draw_bitmap(int x, int y, int w, short *bitmap, int color)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1713, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__draw_text_core": { + "name": "stbte__draw_text_core", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "w", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "color", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int color" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int color" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "digitspace", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int digitspace" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int digitspace" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1715, + "column": 1, + "source_line": "static void stbte__draw_text_core(int x, int y, const char *str, int w, int color, int digitspace)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1715, + "column": 1, + "source_line": "static void stbte__draw_text_core(int x, int y, const char *str, int w, int color, int digitspace)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1728, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__draw_text": { + "name": "stbte__draw_text", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "str", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *str", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "w", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "color", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int color" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int color" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1730, + "column": 1, + "source_line": "static void stbte__draw_text(int x, int y, const char *str, int w, int color)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1730, + "column": 1, + "source_line": "static void stbte__draw_text(int x, int y, const char *str, int w, int color)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1733, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__draw_frame_delayed": { + "name": "stbte__draw_frame_delayed", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "x0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "color", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int color" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int color" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1746, + "column": 1, + "source_line": "static void stbte__draw_frame_delayed(int x0, int y0, int x1, int y1, int color)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1746, + "column": 1, + "source_line": "static void stbte__draw_frame_delayed(int x0, int y0, int x1, int y1, int color)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1752, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__flush_delay": { + "name": "stbte__flush_delay", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1754, + "column": 1, + "source_line": "static void stbte__flush_delay(void)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1754, + "column": 1, + "source_line": "static void stbte__flush_delay(void)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1762, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__activate": { + "name": "stbte__activate", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "id", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int id" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int id" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1764, + "column": 1, + "source_line": "static void stbte__activate(int id)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1764, + "column": 1, + "source_line": "static void stbte__activate(int id)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1770, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__hittest": { + "name": "stbte__hittest", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "x0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "id", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int id" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int id" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1772, + "column": 1, + "source_line": "static int stbte__hittest(int x0, int y0, int x1, int y1, int id)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1772, + "column": 1, + "source_line": "static int stbte__hittest(int x0, int y0, int x1, int y1, int id)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1781, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__button_core": { + "name": "stbte__button_core", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "id", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int id" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int id" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1783, + "column": 1, + "source_line": "static int stbte__button_core(int id)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1783, + "column": 1, + "source_line": "static int stbte__button_core(int id)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1808, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__draw_box": { + "name": "stbte__draw_box", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "x0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "colormode", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int colormode" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int colormode" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "colorindex", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int colorindex" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int colorindex" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1810, + "column": 1, + "source_line": "static void stbte__draw_box(int x0, int y0, int x1, int y1, int colormode, int colorindex)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1810, + "column": 1, + "source_line": "static void stbte__draw_box(int x0, int y0, int x1, int y1, int colormode, int colorindex)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1814, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__draw_textbox": { + "name": "stbte__draw_textbox", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "x0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "text", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *text", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *text", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "xoff", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int xoff" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int xoff" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "yoff", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int yoff" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int yoff" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "colormode", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int colormode" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int colormode" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "colorindex", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int colorindex" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int colorindex" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1816, + "column": 1, + "source_line": "static void stbte__draw_textbox(int x0, int y0, int x1, int y1, char *text, int xoff, int yoff, int colormode, int colorindex)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1816, + "column": 1, + "source_line": "static void stbte__draw_textbox(int x0, int y0, int x1, int y1, char *text, int xoff, int yoff, int colormode, int colorindex)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1820, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__button": { + "name": "stbte__button", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "colormode", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int colormode" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int colormode" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "label", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *label", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *label", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "textoff", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int textoff" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int textoff" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "width", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "id", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int id" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int id" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "toggled", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int toggled" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int toggled" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "disabled", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int disabled" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int disabled" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1822, + "column": 1, + "source_line": "static int stbte__button(int colormode, const char *label, int x, int y, int textoff, int width, int id, int toggled, int disabled)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1822, + "column": 1, + "source_line": "static int stbte__button(int colormode, const char *label, int x, int y, int textoff, int width, int id, int toggled, int disabled)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1834, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__button_icon": { + "name": "stbte__button_icon", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "colormode", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int colormode" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int colormode" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ch", + "type": { + "model": "CChar", + "qualifiers": [], + "source_text": "char ch" + }, + "declared_type": { + "model": "CChar", + "qualifiers": [], + "source_text": "char ch" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "width", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "id", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int id" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int id" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "toggled", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int toggled" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int toggled" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "disabled", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int disabled" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int disabled" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1836, + "column": 1, + "source_line": "static int stbte__button_icon(int colormode, char ch, int x, int y, int width, int id, int toggled, int disabled)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1836, + "column": 1, + "source_line": "static int stbte__button_icon(int colormode, char ch, int x, int y, int width, int id, int toggled, int disabled)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1851, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__minibutton": { + "name": "stbte__minibutton", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "colormode", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int colormode" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int colormode" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ch", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ch" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ch" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "id", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int id" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int id" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1853, + "column": 1, + "source_line": "static int stbte__minibutton(int colormode, int x, int y, int ch, int id)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1853, + "column": 1, + "source_line": "static int stbte__minibutton(int colormode, int x, int y, int ch, int id)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1862, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__layerbutton": { + "name": "stbte__layerbutton", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ch", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ch" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ch" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "id", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int id" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int id" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "toggled", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int toggled" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int toggled" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "disabled", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int disabled" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int disabled" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "colormode", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int colormode" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int colormode" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1864, + "column": 1, + "source_line": "static int stbte__layerbutton(int x, int y, int ch, int id, int toggled, int disabled, int colormode)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1864, + "column": 1, + "source_line": "static int stbte__layerbutton(int x, int y, int ch, int id, int toggled, int disabled, int colormode)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1876, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__microbutton": { + "name": "stbte__microbutton", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "size", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int size" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int size" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "id", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int id" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int id" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "colormode", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int colormode" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int colormode" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1878, + "column": 1, + "source_line": "static int stbte__microbutton(int x, int y, int size, int id, int colormode)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1878, + "column": 1, + "source_line": "static int stbte__microbutton(int x, int y, int size, int id, int colormode)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1886, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__microbutton_dragger": { + "name": "stbte__microbutton_dragger", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "size", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int size" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int size" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "id", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int id" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int id" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "pos", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *pos", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *pos", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1888, + "column": 1, + "source_line": "static int stbte__microbutton_dragger(int x, int y, int size, int id, int *pos)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1888, + "column": 1, + "source_line": "static int stbte__microbutton_dragger(int x, int y, int size, int id, int *pos)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1915, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__category_button": { + "name": "stbte__category_button", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "label", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *label", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *label", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "width", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "id", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int id" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int id" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "toggled", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int toggled" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int toggled" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1917, + "column": 1, + "source_line": "static int stbte__category_button(const char *label, int x, int y, int width, int id, int toggled)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1917, + "column": 1, + "source_line": "static int stbte__category_button(const char *label, int x, int y, int width, int id, int toggled)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1928, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__slider": { + "name": "stbte__slider", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "x0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "w", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "range", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int range" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int range" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "value", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *value", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *value", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "id", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int id" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int id" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1939, + "column": 1, + "source_line": "static int stbte__slider(int x0, int w, int y, int range, int *value, int id)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1939, + "column": 1, + "source_line": "static int stbte__slider(int x0, int w, int y, int range, int *value, int id)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1972, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__float_control": { + "name": "stbte__float_control", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "x0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "w", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "minv", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float minv" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float minv" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "maxv", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float maxv" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float maxv" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "scale", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float scale" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float scale" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "fmt", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *fmt", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *fmt", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "value", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *value", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *value", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "colormode", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int colormode" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int colormode" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "id", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int id" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int id" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1982, + "column": 1, + "source_line": "static int stbte__float_control(int x0, int y0, int w, float minv, float maxv, float scale, const char *fmt, float *value, int colormode, int id)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1982, + "column": 1, + "source_line": "static int stbte__float_control(int x0, int y0, int w, float minv, float maxv, float scale, const char *fmt, float *value, int colormode, int id)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2034, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__scrollbar": { + "name": "stbte__scrollbar", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "val", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *val", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *val", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "v0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "v1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "num_vis", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_vis" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_vis" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "id", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int id" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int id" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2036, + "column": 1, + "source_line": "static void stbte__scrollbar(int x, int y0, int y1, int *val, int v0, int v1, int num_vis, int id)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2036, + "column": 1, + "source_line": "static void stbte__scrollbar(int x, int y0, int y1, int *val, int v0, int v1, int num_vis, int id)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2074, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__compute_digits": { + "name": "stbte__compute_digits", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2077, + "column": 1, + "source_line": "static void stbte__compute_digits(stbte_tilemap *tm)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2077, + "column": 1, + "source_line": "static void stbte__compute_digits(stbte_tilemap *tm)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2085, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__is_single_selection": { + "name": "stbte__is_single_selection", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2087, + "column": 1, + "source_line": "static int stbte__is_single_selection(void)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2087, + "column": 1, + "source_line": "static int stbte__is_single_selection(void)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2092, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__compute_panel_locations": { + "name": "stbte__compute_panel_locations", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2110, + "column": 1, + "source_line": "static void stbte__compute_panel_locations(stbte_tilemap *tm)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2110, + "column": 1, + "source_line": "static void stbte__compute_panel_locations(stbte_tilemap *tm)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2244, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__activate_map": { + "name": "stbte__activate_map", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2275, + "column": 1, + "source_line": "static void stbte__activate_map(int x, int y)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2275, + "column": 1, + "source_line": "static void stbte__activate_map(int x, int y)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2281, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__alert": { + "name": "stbte__alert", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "msg", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *msg", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *msg", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2283, + "column": 1, + "source_line": "static void stbte__alert(const char *msg)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2283, + "column": 1, + "source_line": "static void stbte__alert(const char *msg)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2287, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__brush_predict": { + "name": "stbte__brush_predict", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "result", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short result[]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short result[]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": null, + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2293, + "column": 1, + "source_line": "static void stbte__brush_predict(stbte_tilemap *tm, short result[])" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2293, + "column": 1, + "source_line": "static void stbte__brush_predict(stbte_tilemap *tm, short result[])" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2329, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__brush": { + "name": "stbte__brush", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2331, + "column": 1, + "source_line": "static void stbte__brush(stbte_tilemap *tm, int x, int y)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2331, + "column": 1, + "source_line": "static void stbte__brush(stbte_tilemap *tm, int x, int y)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2371, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__erase_predict": { + "name": "stbte__erase_predict", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "result", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short result[]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short result[]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": null, + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "allow_any", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int allow_any" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int allow_any" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2381, + "column": 1, + "source_line": "static int stbte__erase_predict(stbte_tilemap *tm, short result[], int allow_any)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2381, + "column": 1, + "source_line": "static int stbte__erase_predict(stbte_tilemap *tm, short result[], int allow_any)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2449, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__erase": { + "name": "stbte__erase", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "allow_any", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int allow_any" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int allow_any" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2451, + "column": 1, + "source_line": "static int stbte__erase(stbte_tilemap *tm, int x, int y, int allow_any)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2451, + "column": 1, + "source_line": "static int stbte__erase(stbte_tilemap *tm, int x, int y, int allow_any)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2522, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__find_tile": { + "name": "stbte__find_tile", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "tile_id", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int tile_id" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int tile_id" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2524, + "column": 1, + "source_line": "static int stbte__find_tile(stbte_tilemap *tm, int tile_id)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2524, + "column": 1, + "source_line": "static int stbte__find_tile(stbte_tilemap *tm, int tile_id)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2532, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__eyedrop": { + "name": "stbte__eyedrop", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2534, + "column": 1, + "source_line": "static void stbte__eyedrop(stbte_tilemap *tm, int x, int y)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2534, + "column": 1, + "source_line": "static void stbte__eyedrop(stbte_tilemap *tm, int x, int y)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2569, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__should_copy_properties": { + "name": "stbte__should_copy_properties", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2571, + "column": 1, + "source_line": "static int stbte__should_copy_properties(stbte_tilemap *tm)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2571, + "column": 1, + "source_line": "static int stbte__should_copy_properties(stbte_tilemap *tm)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2584, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__paste_stack": { + "name": "stbte__paste_stack", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "result", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short result[]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short result[]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": null, + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dest", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short dest[]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short dest[]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": null, + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "src", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short src[]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short src[]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": null, + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dragging", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int dragging" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int dragging" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2587, + "column": 1, + "source_line": "static void stbte__paste_stack(stbte_tilemap *tm, short result[], short dest[], short src[], int dragging)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2587, + "column": 1, + "source_line": "static void stbte__paste_stack(stbte_tilemap *tm, short result[], short dest[], short src[], int dragging)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2619, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__clear_stack": { + "name": "stbte__clear_stack", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "result", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short result[]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short result[]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": null, + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2622, + "column": 1, + "source_line": "static void stbte__clear_stack(stbte_tilemap *tm, short result[])" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2622, + "column": 1, + "source_line": "static void stbte__clear_stack(stbte_tilemap *tm, short result[])" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2635, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__fillrect": { + "name": "stbte__fillrect", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "fill", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int fill" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int fill" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2641, + "column": 1, + "source_line": "static void stbte__fillrect(stbte_tilemap *tm, int x0, int y0, int x1, int y1, int fill)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2641, + "column": 1, + "source_line": "static void stbte__fillrect(stbte_tilemap *tm, int x0, int y0, int x1, int y1, int fill)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2657, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__select_rect": { + "name": "stbte__select_rect", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2659, + "column": 1, + "source_line": "static void stbte__select_rect(stbte_tilemap *tm, int x0, int y0, int x1, int y1)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2659, + "column": 1, + "source_line": "static void stbte__select_rect(stbte_tilemap *tm, int x0, int y0, int x1, int y1)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2666, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__copy_properties": { + "name": "stbte__copy_properties", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "dest", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *dest", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *dest", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "src", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *src", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *src", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2668, + "column": 1, + "source_line": "static void stbte__copy_properties(float *dest, float *src)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2668, + "column": 1, + "source_line": "static void stbte__copy_properties(float *dest, float *src)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2673, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__copy_cut": { + "name": "stbte__copy_cut", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cut", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int cut" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int cut" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2675, + "column": 1, + "source_line": "static void stbte__copy_cut(stbte_tilemap *tm, int cut)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2675, + "column": 1, + "source_line": "static void stbte__copy_cut(stbte_tilemap *tm, int cut)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2736, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__in_rect": { + "name": "stbte__in_rect", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "w", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "h", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2738, + "column": 1, + "source_line": "static int stbte__in_rect(int x, int y, int x0, int y0, int w, int h)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2738, + "column": 1, + "source_line": "static int stbte__in_rect(int x, int y, int x0, int y0, int w, int h)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2741, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__in_src_rect": { + "name": "stbte__in_src_rect", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2744, + "column": 1, + "source_line": "static int stbte__in_src_rect(int x, int y)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2744, + "column": 1, + "source_line": "static int stbte__in_src_rect(int x, int y)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2747, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__in_dest_rect": { + "name": "stbte__in_dest_rect", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "destx", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int destx" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int destx" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "desty", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int desty" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int desty" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2749, + "column": 1, + "source_line": "static int stbte__in_dest_rect(int x, int y, int destx, int desty)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2749, + "column": 1, + "source_line": "static int stbte__in_dest_rect(int x, int y, int destx, int desty)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2752, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__paste": { + "name": "stbte__paste", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mapx", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mapx" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mapx" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mapy", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mapy" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mapy" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2755, + "column": 1, + "source_line": "static void stbte__paste(stbte_tilemap *tm, int mapx, int mapy)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2755, + "column": 1, + "source_line": "static void stbte__paste(stbte_tilemap *tm, int mapx, int mapy)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2816, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__drag_update": { + "name": "stbte__drag_update", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mapx", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mapx" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mapx" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mapy", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mapy" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mapy" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "copy_props", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int copy_props" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int copy_props" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2818, + "column": 1, + "source_line": "static void stbte__drag_update(stbte_tilemap *tm, int mapx, int mapy, int copy_props)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2818, + "column": 1, + "source_line": "static void stbte__drag_update(stbte_tilemap *tm, int mapx, int mapy, int copy_props)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2912, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__drag_place": { + "name": "stbte__drag_place", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mapx", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mapx" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mapx" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mapy", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mapy" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mapy" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2914, + "column": 1, + "source_line": "static void stbte__drag_place(stbte_tilemap *tm, int mapx, int mapy)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2914, + "column": 1, + "source_line": "static void stbte__drag_place(stbte_tilemap *tm, int mapx, int mapy)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2943, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__tile_paint": { + "name": "stbte__tile_paint", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "sx", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int sx" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int sx" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "sy", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int sy" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int sy" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mapx", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mapx" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mapx" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mapy", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mapy" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mapy" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "layer", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int layer" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int layer" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2945, + "column": 1, + "source_line": "static void stbte__tile_paint(stbte_tilemap *tm, int sx, int sy, int mapx, int mapy, int layer)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2945, + "column": 1, + "source_line": "static void stbte__tile_paint(stbte_tilemap *tm, int sx, int sy, int mapx, int mapy, int layer)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3022, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__tile": { + "name": "stbte__tile", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "sx", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int sx" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int sx" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "sy", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int sy" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int sy" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mapx", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mapx" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mapx" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mapy", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mapy" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mapy" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3024, + "column": 1, + "source_line": "static void stbte__tile(stbte_tilemap *tm, int sx, int sy, int mapx, int mapy)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3024, + "column": 1, + "source_line": "static void stbte__tile(stbte_tilemap *tm, int sx, int sy, int mapx, int mapy)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3301, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__start_paste": { + "name": "stbte__start_paste", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3303, + "column": 1, + "source_line": "static void stbte__start_paste(stbte_tilemap *tm)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3303, + "column": 1, + "source_line": "static void stbte__start_paste(stbte_tilemap *tm)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3309, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__toolbar": { + "name": "stbte__toolbar", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "w", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "h", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3311, + "column": 1, + "source_line": "static void stbte__toolbar(stbte_tilemap *tm, int x0, int y0, int w, int h)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3311, + "column": 1, + "source_line": "static void stbte__toolbar(stbte_tilemap *tm, int x0, int y0, int w, int h)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3372, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__info_value": { + "name": "stbte__info_value", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "label", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *label", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *label", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "val", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int val" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int val" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "digits", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int digits" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int digits" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "id", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int id" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int id" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3376, + "column": 1, + "source_line": "static int stbte__info_value(const char *label, int x, int y, int val, int digits, int id)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3376, + "column": 1, + "source_line": "static int stbte__info_value(const char *label, int x, int y, int val, int digits, int id)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3394, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__info": { + "name": "stbte__info", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "w", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "h", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3396, + "column": 1, + "source_line": "static void stbte__info(stbte_tilemap *tm, int x0, int y0, int w, int h)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3396, + "column": 1, + "source_line": "static void stbte__info(stbte_tilemap *tm, int x0, int y0, int w, int h)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3425, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__layers": { + "name": "stbte__layers", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "w", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "h", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3427, + "column": 1, + "source_line": "static void stbte__layers(stbte_tilemap *tm, int x0, int y0, int w, int h)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3427, + "column": 1, + "source_line": "static void stbte__layers(stbte_tilemap *tm, int x0, int y0, int w, int h)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3485, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__categories": { + "name": "stbte__categories", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "w", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "h", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3487, + "column": 1, + "source_line": "static void stbte__categories(stbte_tilemap *tm, int x0, int y0, int w, int h)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3487, + "column": 1, + "source_line": "static void stbte__categories(stbte_tilemap *tm, int x0, int y0, int w, int h)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3512, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__tile_in_palette": { + "name": "stbte__tile_in_palette", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "slot", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int slot" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int slot" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3514, + "column": 1, + "source_line": "static void stbte__tile_in_palette(stbte_tilemap *tm, int x, int y, int slot)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3514, + "column": 1, + "source_line": "static void stbte__tile_in_palette(stbte_tilemap *tm, int x, int y, int slot)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3532, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__palette_of_tiles": { + "name": "stbte__palette_of_tiles", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "w", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "h", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3534, + "column": 1, + "source_line": "static void stbte__palette_of_tiles(stbte_tilemap *tm, int x0, int y0, int w, int h)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3534, + "column": 1, + "source_line": "static void stbte__palette_of_tiles(stbte_tilemap *tm, int x0, int y0, int w, int h)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3574, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__props_panel": { + "name": "stbte__props_panel", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "w", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "h", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3577, + "column": 1, + "source_line": "static void stbte__props_panel(stbte_tilemap *tm, int x0, int y0, int w, int h)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3577, + "column": 1, + "source_line": "static void stbte__props_panel(stbte_tilemap *tm, int x0, int y0, int w, int h)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3670, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__dump_colorstate": { + "name": "stbte__dump_colorstate", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3675, + "column": 1, + "source_line": "static void stbte__dump_colorstate(void)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3675, + "column": 1, + "source_line": "static void stbte__dump_colorstate(void)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3695, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__colorpicker": { + "name": "stbte__colorpicker", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "x0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "w", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "h", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3697, + "column": 1, + "source_line": "static void stbte__colorpicker(int x0, int y0, int w, int h)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3697, + "column": 1, + "source_line": "static void stbte__colorpicker(int x0, int y0, int w, int h)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3775, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__editor_traverse": { + "name": "stbte__editor_traverse", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3778, + "column": 1, + "source_line": "static void stbte__editor_traverse(stbte_tilemap *tm)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3778, + "column": 1, + "source_line": "static void stbte__editor_traverse(stbte_tilemap *tm)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3999, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__do_event": { + "name": "stbte__do_event", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "tm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbte_tilemap *tm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbte_tilemap" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 4001, + "column": 1, + "source_line": "static void stbte__do_event(stbte_tilemap *tm)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 4001, + "column": 1, + "source_line": "static void stbte__do_event(stbte_tilemap *tm)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 4038, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbte__set_event": { + "name": "stbte__set_event", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "event", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int event" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int event" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 4040, + "column": 1, + "source_line": "static void stbte__set_event(int event, int x, int y)" + }, + "start": { + "filename": "stb/stb_tilemap_editor.h", + "line": 4040, + "column": 1, + "source_line": "static void stbte__set_event(int event, int x, int y)" + }, + "end": { + "filename": "stb/stb_tilemap_editor.h", + "line": 4051, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + } + }, + "structs": { + "stbte_tilemap": { + "reference": "struct stbte_tilemap" + } + }, + "unions": {}, + "enums": { + "stbte_action": { + "reference": "enum stbte_action" + } + }, + "typedefs": { + "stbte_tilemap": { + "reference": "stbte_tilemap" + }, + "stbte__link": { + "reference": "stbte__link" + }, + "stbte__tileinfo": { + "reference": "stbte__tileinfo" + }, + "stbte__tiledata": { + "reference": "stbte__tiledata" + }, + "stbte__panel": { + "reference": "stbte__panel" + }, + "stbte__colorrect": { + "reference": "stbte__colorrect" + }, + "stbte__ui_t": { + "reference": "stbte__ui_t" + }, + "stbte__layer": { + "reference": "stbte__layer" + }, + "stbte__region_t": { + "reference": "stbte__region_t" + } + }, + "variables": { + "stbte__font_offset": { + "name": "stbte__font_offset", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "static short stbte__font_offset[95+16]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "95+16", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "storage": [ + "static" + ], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 745, + "column": 1, + "source_line": "static short stbte__font_offset[95+16];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + "default_category": { + "name": "default_category", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "static char *default_category", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "storage": [ + "static" + ], + "initializer": { + "source_text": "(char*) \"[unassigned]\"" + }, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 978, + "column": 1, + "source_line": "static char *default_category = (char*) \"[unassigned]\";" + }, + "callback_policy": null, + "declaration_locations": [] + }, + "stbte__region": { + "name": "stbte__region", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "static stbte__region_t stbte__region[4]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "4", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "reference": "stbte__region_t" + } + ] + }, + "storage": [ + "static" + ], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2102, + "column": 1, + "source_line": "static stbte__region_t stbte__region[4];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + "stbte__saved": { + "name": "stbte__saved", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "static float stbte__saved" + }, + "storage": [ + "static" + ], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3576, + "column": 1, + "source_line": "static float stbte__saved;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + "stbte__cp_mode": { + "name": "stbte__cp_mode", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "static int stbte__cp_mode" + }, + "storage": [ + "static" + ], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3672, + "column": 1, + "source_line": "static int stbte__cp_mode, stbte__cp_aspect, stbte__save, stbte__cp_altered;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + "stbte__cp_aspect": { + "name": "stbte__cp_aspect", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "static int stbte__cp_aspect" + }, + "storage": [ + "static" + ], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3672, + "column": 1, + "source_line": "static int stbte__cp_mode, stbte__cp_aspect, stbte__save, stbte__cp_altered;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + "stbte__save": { + "name": "stbte__save", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "static int stbte__save" + }, + "storage": [ + "static" + ], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3672, + "column": 1, + "source_line": "static int stbte__cp_mode, stbte__cp_aspect, stbte__save, stbte__cp_altered;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + "stbte__cp_altered": { + "name": "stbte__cp_altered", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "static int stbte__cp_altered" + }, + "storage": [ + "static" + ], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3672, + "column": 1, + "source_line": "static int stbte__cp_mode, stbte__cp_aspect, stbte__save, stbte__cp_altered;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + "stbte__cp_state": { + "name": "stbte__cp_state", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "static int stbte__cp_state" + }, + "storage": [ + "static" + ], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3674, + "column": 1, + "source_line": "static int stbte__cp_state, stbte__cp_index, stbte__color_copy;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + "stbte__cp_index": { + "name": "stbte__cp_index", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "static int stbte__cp_index" + }, + "storage": [ + "static" + ], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3674, + "column": 1, + "source_line": "static int stbte__cp_state, stbte__cp_index, stbte__color_copy;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + "stbte__color_copy": { + "name": "stbte__color_copy", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "static int stbte__color_copy" + }, + "storage": [ + "static" + ], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3674, + "column": 1, + "source_line": "static int stbte__cp_state, stbte__cp_index, stbte__color_copy;" + }, + "callback_policy": null, + "declaration_locations": [] + } + }, + "macros": { + "STB_TILEMAP_INCLUDE_STB_TILEMAP_EDITOR_H": { + "name": "STB_TILEMAP_INCLUDE_STB_TILEMAP_EDITOR_H", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 335, + "column": 1, + "source_line": "#define STB_TILEMAP_INCLUDE_STB_TILEMAP_EDITOR_H" + } + }, + "_CRT_SECURE_NO_WARNINGS": { + "name": "_CRT_SECURE_NO_WARNINGS", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 339, + "column": 3, + "source_line": " #define _CRT_SECURE_NO_WARNINGS" + } + }, + "STBTE_PROP_none": { + "name": "STBTE_PROP_none", + "value": "0", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 356, + "column": 1, + "source_line": "#define STBTE_PROP_none 0" + } + }, + "STBTE_PROP_int": { + "name": "STBTE_PROP_int", + "value": "1", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 357, + "column": 1, + "source_line": "#define STBTE_PROP_int 1" + } + }, + "STBTE_PROP_float": { + "name": "STBTE_PROP_float", + "value": "2", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 358, + "column": 1, + "source_line": "#define STBTE_PROP_float 2" + } + }, + "STBTE_PROP_bool": { + "name": "STBTE_PROP_bool", + "value": "3", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 359, + "column": 1, + "source_line": "#define STBTE_PROP_bool 3" + } + }, + "STBTE_PROP_disabled": { + "name": "STBTE_PROP_disabled", + "value": "4", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 360, + "column": 1, + "source_line": "#define STBTE_PROP_disabled 4" + } + }, + "STBTE_EMPTY": { + "name": "STBTE_EMPTY", + "value": "-1", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 449, + "column": 1, + "source_line": "#define STBTE_EMPTY -1" + } + }, + "STBTE_ASSERT": { + "name": "STBTE_ASSERT", + "value": "assert", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 510, + "column": 1, + "source_line": "#define STBTE_ASSERT assert" + } + }, + "STBTE__NOTUSED": { + "name": "STBTE__NOTUSED", + "value": "(void)sizeof(v)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 517, + "column": 1, + "source_line": "#define STBTE__NOTUSED(v) (void)sizeof(v)" + } + }, + "STBTE_MAX_TILEMAP_X": { + "name": "STBTE_MAX_TILEMAP_X", + "value": "200", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 521, + "column": 1, + "source_line": "#define STBTE_MAX_TILEMAP_X 200" + } + }, + "STBTE_MAX_TILEMAP_Y": { + "name": "STBTE_MAX_TILEMAP_Y", + "value": "200", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 525, + "column": 1, + "source_line": "#define STBTE_MAX_TILEMAP_Y 200" + } + }, + "STBTE_MAX_LAYERS": { + "name": "STBTE_MAX_LAYERS", + "value": "8", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 529, + "column": 1, + "source_line": "#define STBTE_MAX_LAYERS 8" + } + }, + "STBTE_MAX_CATEGORIES": { + "name": "STBTE_MAX_CATEGORIES", + "value": "100", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 533, + "column": 1, + "source_line": "#define STBTE_MAX_CATEGORIES 100" + } + }, + "STBTE_MAX_COPY": { + "name": "STBTE_MAX_COPY", + "value": "65536", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 537, + "column": 1, + "source_line": "#define STBTE_MAX_COPY 65536" + } + }, + "STBTE_UNDO_BUFFER_BYTES": { + "name": "STBTE_UNDO_BUFFER_BYTES", + "value": "(1 << 24)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 541, + "column": 1, + "source_line": "#define STBTE_UNDO_BUFFER_BYTES (1 << 24) // 16 MB" + } + }, + "STBTE__NO_PROPS": { + "name": "STBTE__NO_PROPS", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 587, + "column": 1, + "source_line": "#define STBTE__NO_PROPS" + } + }, + "STBTE_PROP_TYPE": { + "name": "STBTE_PROP_TYPE", + "value": "0", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 546, + "column": 1, + "source_line": "#define STBTE_PROP_TYPE(n,td,tp) 0" + } + }, + "STBTE_PROP_NAME": { + "name": "STBTE_PROP_NAME", + "value": "\"\"", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 550, + "column": 1, + "source_line": "#define STBTE_PROP_NAME(n,td,tp) \"\"" + } + }, + "STBTE_MAX_PROPERTIES": { + "name": "STBTE_MAX_PROPERTIES", + "value": "1", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 592, + "column": 1, + "source_line": "#define STBTE_MAX_PROPERTIES 1 // so we can declare arrays" + } + }, + "STBTE_PROP_MIN": { + "name": "STBTE_PROP_MIN", + "value": "0", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 558, + "column": 1, + "source_line": "#define STBTE_PROP_MIN(n,td,tp) 0" + } + }, + "STBTE_PROP_MAX": { + "name": "STBTE_PROP_MAX", + "value": "100.0", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 562, + "column": 1, + "source_line": "#define STBTE_PROP_MAX(n,td,tp) 100.0" + } + }, + "STBTE_PROP_FLOAT_SCALE": { + "name": "STBTE_PROP_FLOAT_SCALE", + "value": "1", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 566, + "column": 1, + "source_line": "#define STBTE_PROP_FLOAT_SCALE(n,td,tp) 1 // default scale size" + } + }, + "STBTE_FLOAT_CONTROL_GRANULARITY": { + "name": "STBTE_FLOAT_CONTROL_GRANULARITY", + "value": "4", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 570, + "column": 1, + "source_line": "#define STBTE_FLOAT_CONTROL_GRANULARITY 4" + } + }, + "STBTE__UNDO_BUFFER_COUNT": { + "name": "STBTE__UNDO_BUFFER_COUNT", + "value": "(STBTE_UNDO_BUFFER_BYTES>>1)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 574, + "column": 1, + "source_line": "#define STBTE__UNDO_BUFFER_COUNT (STBTE_UNDO_BUFFER_BYTES>>1)" + } + }, + "STBTE_COLOR_TILEMAP_BACKGROUND": { + "name": "STBTE_COLOR_TILEMAP_BACKGROUND", + "value": "0x000000", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 708, + "column": 1, + "source_line": "#define STBTE_COLOR_TILEMAP_BACKGROUND 0x000000" + } + }, + "STBTE_COLOR_TILEMAP_BORDER": { + "name": "STBTE_COLOR_TILEMAP_BORDER", + "value": "0x203060", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 709, + "column": 1, + "source_line": "#define STBTE_COLOR_TILEMAP_BORDER 0x203060" + } + }, + "STBTE_COLOR_TILEMAP_HIGHLIGHT": { + "name": "STBTE_COLOR_TILEMAP_HIGHLIGHT", + "value": "0xffffff", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 710, + "column": 1, + "source_line": "#define STBTE_COLOR_TILEMAP_HIGHLIGHT 0xffffff" + } + }, + "STBTE_COLOR_GRID": { + "name": "STBTE_COLOR_GRID", + "value": "0x404040", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 711, + "column": 1, + "source_line": "#define STBTE_COLOR_GRID 0x404040" + } + }, + "STBTE_COLOR_SELECTION_OUTLINE1": { + "name": "STBTE_COLOR_SELECTION_OUTLINE1", + "value": "0xdfdfdf", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 712, + "column": 1, + "source_line": "#define STBTE_COLOR_SELECTION_OUTLINE1 0xdfdfdf" + } + }, + "STBTE_COLOR_SELECTION_OUTLINE2": { + "name": "STBTE_COLOR_SELECTION_OUTLINE2", + "value": "0x303030", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 713, + "column": 1, + "source_line": "#define STBTE_COLOR_SELECTION_OUTLINE2 0x303030" + } + }, + "STBTE_COLOR_TILEPALETTE_OUTLINE": { + "name": "STBTE_COLOR_TILEPALETTE_OUTLINE", + "value": "0xffffff", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 714, + "column": 1, + "source_line": "#define STBTE_COLOR_TILEPALETTE_OUTLINE 0xffffff" + } + }, + "STBTE_COLOR_TILEPALETTE_BACKGROUND": { + "name": "STBTE_COLOR_TILEPALETTE_BACKGROUND", + "value": "0x000000", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 715, + "column": 1, + "source_line": "#define STBTE_COLOR_TILEPALETTE_BACKGROUND 0x000000" + } + }, + "STBTE_LINK_COLOR": { + "name": "STBTE_LINK_COLOR", + "value": "0x5030ff", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 718, + "column": 1, + "source_line": "#define STBTE_LINK_COLOR(src,sp,dest,dp) 0x5030ff" + } + }, + "STBTE_LINK_COLOR_DRAWING": { + "name": "STBTE_LINK_COLOR_DRAWING", + "value": "0xff40ff", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 722, + "column": 1, + "source_line": "#define STBTE_LINK_COLOR_DRAWING 0xff40ff" + } + }, + "STBTE_LINK_COLOR_DISALLOWED": { + "name": "STBTE_LINK_COLOR_DISALLOWED", + "value": "0x602060", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 726, + "column": 1, + "source_line": "#define STBTE_LINK_COLOR_DISALLOWED 0x602060" + } + }, + "STBTE__INDEX_FOR_STATE": { + "name": "STBTE__INDEX_FOR_STATE", + "value": "stbte__state_to_index[disable][select][down][over]", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 741, + "column": 1, + "source_line": "#define STBTE__INDEX_FOR_STATE(disable,select,down,over) stbte__state_to_index[disable][select][down][over]" + } + }, + "STBTE__INDEX_FOR_ID": { + "name": "STBTE__INDEX_FOR_ID", + "value": "STBTE__INDEX_FOR_STATE(disable,select,STBTE__IS_ACTIVE(id),STBTE__IS_HOT(id))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 742, + "column": 1, + "source_line": "#define STBTE__INDEX_FOR_ID(id,disable,select) STBTE__INDEX_FOR_STATE(disable,select,STBTE__IS_ACTIVE(id),STBTE__IS_HOT(id))" + } + }, + "STBTE__FONT_HEIGHT": { + "name": "STBTE__FONT_HEIGHT", + "value": "9", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 744, + "column": 1, + "source_line": "#define STBTE__FONT_HEIGHT 9" + } + }, + "MAX_LAYERMASK": { + "name": "MAX_LAYERMASK", + "value": "(1 << (8*sizeof(unsigned int)))", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 790, + "column": 1, + "source_line": "#define MAX_LAYERMASK (1 << (8*sizeof(unsigned int)))" + } + }, + "STBTE__NO_TILE": { + "name": "STBTE__NO_TILE", + "value": "-1", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 794, + "column": 1, + "source_line": "#define STBTE__NO_TILE -1" + } + }, + "STBTE__MAX_DELAYRECT": { + "name": "STBTE__MAX_DELAYRECT", + "value": "256", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 875, + "column": 1, + "source_line": "#define STBTE__MAX_DELAYRECT 256" + } + }, + "STBTE__INACTIVE": { + "name": "STBTE__INACTIVE", + "value": "(stbte__ui.active_id == 0)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 921, + "column": 1, + "source_line": "#define STBTE__INACTIVE() (stbte__ui.active_id == 0)" + } + }, + "STBTE__IS_ACTIVE": { + "name": "STBTE__IS_ACTIVE", + "value": "(stbte__ui.active_id == (id))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 922, + "column": 1, + "source_line": "#define STBTE__IS_ACTIVE(id) (stbte__ui.active_id == (id))" + } + }, + "STBTE__IS_HOT": { + "name": "STBTE__IS_HOT", + "value": "(stbte__ui.hot_id == (id))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 923, + "column": 1, + "source_line": "#define STBTE__IS_HOT(id) (stbte__ui.hot_id == (id))" + } + }, + "STBTE__BUTTON_HEIGHT": { + "name": "STBTE__BUTTON_HEIGHT", + "value": "(STBTE__FONT_HEIGHT + 2 * STBTE__BUTTON_INTERNAL_SPACING)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 925, + "column": 1, + "source_line": "#define STBTE__BUTTON_HEIGHT (STBTE__FONT_HEIGHT + 2 * STBTE__BUTTON_INTERNAL_SPACING)" + } + }, + "STBTE__BUTTON_INTERNAL_SPACING": { + "name": "STBTE__BUTTON_INTERNAL_SPACING", + "value": "(2 + (STBTE__FONT_HEIGHT>>4))", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 926, + "column": 1, + "source_line": "#define STBTE__BUTTON_INTERNAL_SPACING (2 + (STBTE__FONT_HEIGHT>>4))" + } + }, + "stbte__wrap": { + "name": "stbte__wrap", + "value": "((pos) & (STBTE__UNDO_BUFFER_COUNT-1))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1343, + "column": 1, + "source_line": "#define stbte__wrap(pos) ((pos) & (STBTE__UNDO_BUFFER_COUNT-1))" + } + }, + "STBTE__undo_record": { + "name": "STBTE__undo_record", + "value": "-2", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1345, + "column": 1, + "source_line": "#define STBTE__undo_record -2" + } + }, + "STBTE__redo_record": { + "name": "STBTE__redo_record", + "value": "-3", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1346, + "column": 1, + "source_line": "#define STBTE__redo_record -3" + } + }, + "STBTE__undo_junk": { + "name": "STBTE__undo_junk", + "value": "-4", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1347, + "column": 1, + "source_line": "#define STBTE__undo_junk -4 // this is written underneath the undo pointer, never used" + } + }, + "stbte__sprintf": { + "name": "stbte__sprintf", + "value": "sprintf", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1978, + "column": 4, + "source_line": " #define stbte__sprintf sprintf" + } + }, + "stbte__sizeof": { + "name": "stbte__sizeof", + "value": null, + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1979, + "column": 4, + "source_line": " #define stbte__sizeof(s)" + } + }, + "STBTE__TOOLBAR_ICON_SIZE": { + "name": "STBTE__TOOLBAR_ICON_SIZE", + "value": "(9+2*2)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2104, + "column": 1, + "source_line": "#define STBTE__TOOLBAR_ICON_SIZE (9+2*2)" + } + }, + "STBTE__TOOLBAR_PASTE_SIZE": { + "name": "STBTE__TOOLBAR_PASTE_SIZE", + "value": "(34+2*2)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2105, + "column": 1, + "source_line": "#define STBTE__TOOLBAR_PASTE_SIZE (34+2*2)" + } + }, + "STBTE__ID": { + "name": "STBTE__ID", + "value": "((n) + ((p)<<7))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2271, + "column": 1, + "source_line": "#define STBTE__ID(n,p) ((n) + ((p)<<7))" + } + }, + "STBTE__ID2": { + "name": "STBTE__ID2", + "value": "STBTE__ID(n, ((p)<<12)+(q) )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2272, + "column": 1, + "source_line": "#define STBTE__ID2(n,p,q) STBTE__ID(n, ((p)<<12)+(q) )" + } + }, + "STBTE__IDMAP": { + "name": "STBTE__IDMAP", + "value": "STBTE__ID2(STBTE__map, x,y)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2273, + "column": 1, + "source_line": "#define STBTE__IDMAP(x,y) STBTE__ID2(STBTE__map, x,y)" + } + }, + "STBTE__BG": { + "name": "STBTE__BG", + "value": "((layer) == 0 ? (tm)->background_tile : STBTE__NO_TILE)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2289, + "column": 1, + "source_line": "#define STBTE__BG(tm,layer) ((layer) == 0 ? (tm)->background_tile : STBTE__NO_TILE)" + } + }, + "STBTE__IS_MAP_ACTIVE": { + "name": "STBTE__IS_MAP_ACTIVE", + "value": "((stbte__ui.active_id & 127) == STBTE__map)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2638, + "column": 1, + "source_line": "#define STBTE__IS_MAP_ACTIVE() ((stbte__ui.active_id & 127) == STBTE__map)" + } + }, + "STBTE__IS_MAP_HOT": { + "name": "STBTE__IS_MAP_HOT", + "value": "((stbte__ui.hot_id & 127) == STBTE__map)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2639, + "column": 1, + "source_line": "#define STBTE__IS_MAP_HOT() ((stbte__ui.hot_id & 127) == STBTE__map)" + } + }, + "STBTE__TEXTCOLOR": { + "name": "STBTE__TEXTCOLOR", + "value": "stbte__color_table[n][STBTE__text][STBTE__idle]", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3374, + "column": 1, + "source_line": "#define STBTE__TEXTCOLOR(n) stbte__color_table[n][STBTE__text][STBTE__idle]" + } + } + }, + "includes": { + "stb/stb_tilemap_editor.h:stdlib.h": { + "target": "stdlib.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 341, + "column": 3, + "source_line": " #include " + } + }, + "stb/stb_tilemap_editor.h:stdio.h": { + "target": "stdio.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 342, + "column": 3, + "source_line": " #include " + } + }, + "stb/stb_tilemap_editor.h:assert.h": { + "target": "assert.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 511, + "column": 1, + "source_line": "#include " + } + } + }, + "functions_by_file": { + "stb/stb_tilemap_editor.h": [ + "stbte_create_map", + "stbte_define_tile", + "stbte_set_display", + "stbte_draw", + "stbte_tick", + "stbte_mouse_sdl", + "stbte_mouse_move", + "stbte_mouse_button", + "stbte_mouse_wheel", + "stbte_action", + "stbte_get_dimensions", + "stbte_get_tile", + "stbte_get_properties", + "stbte_get_link", + "stbte_set_dimensions", + "stbte_clear_map", + "stbte_set_tile", + "stbte_set_property", + "stbte_set_link", + "stbte_set_background_tile", + "stbte_set_sidewidths", + "stbte_set_spacing", + "stbte_set_layername", + "stbte__init_gui", + "stbte__text_width", + "stbte__set_link", + "stbte__choose_category", + "stbte__strequal", + "stbte__compute_tileinfo", + "stbte__prepare_tileinfo", + "stbte__write_undo", + "stbte__write_redo", + "stbte__begin_undo", + "stbte__end_undo", + "stbte__undo_record", + "stbte__redo_record", + "stbte__extract_float", + "stbte__extract_short", + "stbte__undo_record_prop", + "stbte__undo_record_prop_float", + "stbte__redo_record_prop", + "stbte__undo_find_end", + "stbte__undo", + "stbte__redo_find_end", + "stbte__redo", + "stbte__recompute_undo_available", + "stbte__undo_available", + "stbte__redo_available", + "stbte__draw_rect", + "stbte__draw_line", + "stbte__draw_link", + "stbte__draw_frame", + "stbte__get_char_width", + "stbte__get_char_bitmap", + "stbte__draw_bitmask_as_columns", + "stbte__draw_bitmap", + "stbte__draw_text_core", + "stbte__draw_text", + "stbte__draw_frame_delayed", + "stbte__flush_delay", + "stbte__activate", + "stbte__hittest", + "stbte__button_core", + "stbte__draw_box", + "stbte__draw_textbox", + "stbte__button", + "stbte__button_icon", + "stbte__minibutton", + "stbte__layerbutton", + "stbte__microbutton", + "stbte__microbutton_dragger", + "stbte__category_button", + "stbte__slider", + "stbte__float_control", + "stbte__scrollbar", + "stbte__compute_digits", + "stbte__is_single_selection", + "stbte__compute_panel_locations", + "stbte__activate_map", + "stbte__alert", + "stbte__brush_predict", + "stbte__brush", + "stbte__erase_predict", + "stbte__erase", + "stbte__find_tile", + "stbte__eyedrop", + "stbte__should_copy_properties", + "stbte__paste_stack", + "stbte__clear_stack", + "stbte__fillrect", + "stbte__select_rect", + "stbte__copy_properties", + "stbte__copy_cut", + "stbte__in_rect", + "stbte__in_src_rect", + "stbte__in_dest_rect", + "stbte__paste", + "stbte__drag_update", + "stbte__drag_place", + "stbte__tile_paint", + "stbte__tile", + "stbte__start_paste", + "stbte__toolbar", + "stbte__info_value", + "stbte__info", + "stbte__layers", + "stbte__categories", + "stbte__tile_in_palette", + "stbte__palette_of_tiles", + "stbte__props_panel", + "stbte__dump_colorstate", + "stbte__colorpicker", + "stbte__editor_traverse", + "stbte__do_event", + "stbte__set_event" + ] + }, + "enum_constants": { + "STBTE_drawmode_deemphasize": { + "name": "STBTE_drawmode_deemphasize", + "value": "-1", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 348, + "column": 1, + "source_line": "enum" + } + }, + "STBTE_drawmode_normal": { + "name": "STBTE_drawmode_normal", + "value": "0", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 348, + "column": 1, + "source_line": "enum" + } + }, + "STBTE_drawmode_emphasize": { + "name": "STBTE_drawmode_emphasize", + "value": "1", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 348, + "column": 1, + "source_line": "enum" + } + }, + "STBTE_tool_select": { + "name": "STBTE_tool_select", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 418, + "column": 1, + "source_line": "enum stbte_action" + } + }, + "STBTE_tool_brush": { + "name": "STBTE_tool_brush", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 418, + "column": 1, + "source_line": "enum stbte_action" + } + }, + "STBTE_tool_erase": { + "name": "STBTE_tool_erase", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 418, + "column": 1, + "source_line": "enum stbte_action" + } + }, + "STBTE_tool_rectangle": { + "name": "STBTE_tool_rectangle", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 418, + "column": 1, + "source_line": "enum stbte_action" + } + }, + "STBTE_tool_eyedropper": { + "name": "STBTE_tool_eyedropper", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 418, + "column": 1, + "source_line": "enum stbte_action" + } + }, + "STBTE_tool_link": { + "name": "STBTE_tool_link", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 418, + "column": 1, + "source_line": "enum stbte_action" + } + }, + "STBTE_act_toggle_grid": { + "name": "STBTE_act_toggle_grid", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 418, + "column": 1, + "source_line": "enum stbte_action" + } + }, + "STBTE_act_toggle_links": { + "name": "STBTE_act_toggle_links", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 418, + "column": 1, + "source_line": "enum stbte_action" + } + }, + "STBTE_act_undo": { + "name": "STBTE_act_undo", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 418, + "column": 1, + "source_line": "enum stbte_action" + } + }, + "STBTE_act_redo": { + "name": "STBTE_act_redo", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 418, + "column": 1, + "source_line": "enum stbte_action" + } + }, + "STBTE_act_cut": { + "name": "STBTE_act_cut", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 418, + "column": 1, + "source_line": "enum stbte_action" + } + }, + "STBTE_act_copy": { + "name": "STBTE_act_copy", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 418, + "column": 1, + "source_line": "enum stbte_action" + } + }, + "STBTE_act_paste": { + "name": "STBTE_act_paste", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 418, + "column": 1, + "source_line": "enum stbte_action" + } + }, + "STBTE_scroll_left": { + "name": "STBTE_scroll_left", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 418, + "column": 1, + "source_line": "enum stbte_action" + } + }, + "STBTE_scroll_right": { + "name": "STBTE_scroll_right", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 418, + "column": 1, + "source_line": "enum stbte_action" + } + }, + "STBTE_scroll_up": { + "name": "STBTE_scroll_up", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 418, + "column": 1, + "source_line": "enum stbte_action" + } + }, + "STBTE_scroll_down": { + "name": "STBTE_scroll_down", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 418, + "column": 1, + "source_line": "enum stbte_action" + } + }, + "STBTE__base": { + "name": "STBTE__base", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 600, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__outline": { + "name": "STBTE__outline", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 600, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__text": { + "name": "STBTE__text", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 600, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__num_color_aspects": { + "name": "STBTE__num_color_aspects", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 600, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__idle": { + "name": "STBTE__idle", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 609, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__over": { + "name": "STBTE__over", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 609, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__down": { + "name": "STBTE__down", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 609, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__over_down": { + "name": "STBTE__over_down", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 609, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__selected": { + "name": "STBTE__selected", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 609, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__selected_over": { + "name": "STBTE__selected_over", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 609, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__disabled": { + "name": "STBTE__disabled", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 609, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__num_color_states": { + "name": "STBTE__num_color_states", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 609, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__cexpander": { + "name": "STBTE__cexpander", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 621, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__ctoolbar": { + "name": "STBTE__ctoolbar", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 621, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__ctoolbar_button": { + "name": "STBTE__ctoolbar_button", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 621, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__cpanel": { + "name": "STBTE__cpanel", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 621, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__cpanel_sider": { + "name": "STBTE__cpanel_sider", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 621, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__cpanel_sizer": { + "name": "STBTE__cpanel_sizer", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 621, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__cscrollbar": { + "name": "STBTE__cscrollbar", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 621, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__cmapsize": { + "name": "STBTE__cmapsize", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 621, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__clayer_button": { + "name": "STBTE__clayer_button", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 621, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__clayer_hide": { + "name": "STBTE__clayer_hide", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 621, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__clayer_lock": { + "name": "STBTE__clayer_lock", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 621, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__clayer_solo": { + "name": "STBTE__clayer_solo", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 621, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__ccategory_button": { + "name": "STBTE__ccategory_button", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 621, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__num_color_modes": { + "name": "STBTE__num_color_modes", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 621, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__panel_toolbar": { + "name": "STBTE__panel_toolbar", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 796, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__panel_colorpick": { + "name": "STBTE__panel_colorpick", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 796, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__panel_info": { + "name": "STBTE__panel_info", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 796, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__panel_layers": { + "name": "STBTE__panel_layers", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 796, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__panel_props": { + "name": "STBTE__panel_props", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 796, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__panel_categories": { + "name": "STBTE__panel_categories", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 796, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__panel_tiles": { + "name": "STBTE__panel_tiles", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 796, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__num_panel": { + "name": "STBTE__num_panel", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 796, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__side_left": { + "name": "STBTE__side_left", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 809, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__side_right": { + "name": "STBTE__side_right", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 809, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__side_top": { + "name": "STBTE__side_top", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 809, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__side_bottom": { + "name": "STBTE__side_bottom", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 809, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__tool_select": { + "name": "STBTE__tool_select", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 817, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__tool_brush": { + "name": "STBTE__tool_brush", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 817, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__tool_erase": { + "name": "STBTE__tool_erase", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 817, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__tool_rect": { + "name": "STBTE__tool_rect", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 817, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__tool_eyedrop": { + "name": "STBTE__tool_eyedrop", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 817, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__tool_fill": { + "name": "STBTE__tool_fill", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 817, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__tool_link": { + "name": "STBTE__tool_link", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 817, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__tool_showgrid": { + "name": "STBTE__tool_showgrid", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 817, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__tool_showlinks": { + "name": "STBTE__tool_showlinks", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 817, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__tool_undo": { + "name": "STBTE__tool_undo", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 817, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__tool_redo": { + "name": "STBTE__tool_redo", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 817, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__num_tool": { + "name": "STBTE__num_tool", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 817, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__propmode_default": { + "name": "STBTE__propmode_default", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 840, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__propmode_always": { + "name": "STBTE__propmode_always", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 840, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__propmode_never": { + "name": "STBTE__propmode_never", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 840, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__paint": { + "name": "STBTE__paint", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 847, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__tick": { + "name": "STBTE__tick", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 847, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__mousemove": { + "name": "STBTE__mousemove", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 847, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__mousewheel": { + "name": "STBTE__mousewheel", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 847, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__leftdown": { + "name": "STBTE__leftdown", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 847, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__leftup": { + "name": "STBTE__leftup", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 847, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__rightdown": { + "name": "STBTE__rightdown", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 847, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__rightup": { + "name": "STBTE__rightup", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 847, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__unlocked": { + "name": "STBTE__unlocked", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 935, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__protected": { + "name": "STBTE__protected", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 935, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__locked": { + "name": "STBTE__locked", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 935, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__undo_none": { + "name": "STBTE__undo_none", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1183, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__undo_record": { + "name": "STBTE__undo_record", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1183, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__undo_block": { + "name": "STBTE__undo_block", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1183, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__none": { + "name": "STBTE__none", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1930, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__begin": { + "name": "STBTE__begin", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1930, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__end": { + "name": "STBTE__end", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1930, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__change": { + "name": "STBTE__change", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1930, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__map": { + "name": "STBTE__map", + "value": "1", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2247, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__region": { + "name": "STBTE__region", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2247, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__panel": { + "name": "STBTE__panel", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2247, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__info": { + "name": "STBTE__info", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2247, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__toolbarA": { + "name": "STBTE__toolbarA", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2247, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__toolbarB": { + "name": "STBTE__toolbarB", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2247, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__palette": { + "name": "STBTE__palette", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2247, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__categories": { + "name": "STBTE__categories", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2247, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__layer": { + "name": "STBTE__layer", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2247, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__solo": { + "name": "STBTE__solo", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2247, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__hide": { + "name": "STBTE__hide", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2247, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__lock": { + "name": "STBTE__lock", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2247, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__scrollbar": { + "name": "STBTE__scrollbar", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2247, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__panel_mover": { + "name": "STBTE__panel_mover", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2247, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__panel_sizer": { + "name": "STBTE__panel_sizer", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2247, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__scrollbar_id": { + "name": "STBTE__scrollbar_id", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2247, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__colorpick_id": { + "name": "STBTE__colorpick_id", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2247, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__prop_flag": { + "name": "STBTE__prop_flag", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2247, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__prop_float": { + "name": "STBTE__prop_float", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2247, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__prop_int": { + "name": "STBTE__prop_int", + "value": null, + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2247, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__erase_none": { + "name": "STBTE__erase_none", + "value": "-1", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2373, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__erase_brushonly": { + "name": "STBTE__erase_brushonly", + "value": "0", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2373, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__erase_any": { + "name": "STBTE__erase_any", + "value": "1", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2373, + "column": 1, + "source_line": "enum" + } + }, + "STBTE__erase_all": { + "name": "STBTE__erase_all", + "value": "2", + "source_location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2373, + "column": 1, + "source_line": "enum" + } + } + }, + "include_graph": { + "stb/stb_tilemap_editor.h": [] + }, + "system_includes": { + "stb/stb_tilemap_editor.h": [ + "assert.h", + "stdio.h", + "stdlib.h" + ] + }, + "unresolved_includes": { + "stb/stb_tilemap_editor.h": [] + }, + "header_source_pairs": { + "stb/stb_tilemap_editor.h": [] + }, + "diagnostics": [ + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTE__NOTUSED' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 515, + "column": 1, + "source_line": "#define STBTE__NOTUSED(v) (void)(v)" + }, + "unit_kind": "macro", + "unit_name": "STBTE__NOTUSED" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTE__NOTUSED' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 517, + "column": 1, + "source_line": "#define STBTE__NOTUSED(v) (void)sizeof(v)" + }, + "unit_kind": "macro", + "unit_name": "STBTE__NOTUSED" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTE_PROP_TYPE' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 546, + "column": 1, + "source_line": "#define STBTE_PROP_TYPE(n,td,tp) 0" + }, + "unit_kind": "macro", + "unit_name": "STBTE_PROP_TYPE" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTE_PROP_NAME' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 550, + "column": 1, + "source_line": "#define STBTE_PROP_NAME(n,td,tp) \"\"" + }, + "unit_kind": "macro", + "unit_name": "STBTE_PROP_NAME" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTE_PROP_MIN' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 558, + "column": 1, + "source_line": "#define STBTE_PROP_MIN(n,td,tp) 0" + }, + "unit_kind": "macro", + "unit_name": "STBTE_PROP_MIN" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTE_PROP_MAX' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 562, + "column": 1, + "source_line": "#define STBTE_PROP_MAX(n,td,tp) 100.0" + }, + "unit_kind": "macro", + "unit_name": "STBTE_PROP_MAX" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTE_PROP_FLOAT_SCALE' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 566, + "column": 1, + "source_line": "#define STBTE_PROP_FLOAT_SCALE(n,td,tp) 1 // default scale size" + }, + "unit_kind": "macro", + "unit_name": "STBTE_PROP_FLOAT_SCALE" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTE_LINK_COLOR' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 718, + "column": 1, + "source_line": "#define STBTE_LINK_COLOR(src,sp,dest,dp) 0x5030ff" + }, + "unit_kind": "macro", + "unit_name": "STBTE_LINK_COLOR" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTE__INDEX_FOR_STATE' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 741, + "column": 1, + "source_line": "#define STBTE__INDEX_FOR_STATE(disable,select,down,over) stbte__state_to_index[disable][select][down][over]" + }, + "unit_kind": "macro", + "unit_name": "STBTE__INDEX_FOR_STATE" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTE__INDEX_FOR_ID' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 742, + "column": 1, + "source_line": "#define STBTE__INDEX_FOR_ID(id,disable,select) STBTE__INDEX_FOR_STATE(disable,select,STBTE__IS_ACTIVE(id),STBTE__IS_HOT(id))" + }, + "unit_kind": "macro", + "unit_name": "STBTE__INDEX_FOR_ID" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTE__INACTIVE' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 921, + "column": 1, + "source_line": "#define STBTE__INACTIVE() (stbte__ui.active_id == 0)" + }, + "unit_kind": "macro", + "unit_name": "STBTE__INACTIVE" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTE__IS_ACTIVE' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 922, + "column": 1, + "source_line": "#define STBTE__IS_ACTIVE(id) (stbte__ui.active_id == (id))" + }, + "unit_kind": "macro", + "unit_name": "STBTE__IS_ACTIVE" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTE__IS_HOT' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 923, + "column": 1, + "source_line": "#define STBTE__IS_HOT(id) (stbte__ui.hot_id == (id))" + }, + "unit_kind": "macro", + "unit_name": "STBTE__IS_HOT" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbte__wrap' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1343, + "column": 1, + "source_line": "#define stbte__wrap(pos) ((pos) & (STBTE__UNDO_BUFFER_COUNT-1))" + }, + "unit_kind": "macro", + "unit_name": "stbte__wrap" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbte__sizeof' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1976, + "column": 4, + "source_line": " #define stbte__sizeof(s) , sizeof(s)" + }, + "unit_kind": "macro", + "unit_name": "stbte__sizeof" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbte__sizeof' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 1979, + "column": 4, + "source_line": " #define stbte__sizeof(s)" + }, + "unit_kind": "macro", + "unit_name": "stbte__sizeof" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTE__ID' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2271, + "column": 1, + "source_line": "#define STBTE__ID(n,p) ((n) + ((p)<<7))" + }, + "unit_kind": "macro", + "unit_name": "STBTE__ID" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTE__ID2' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2272, + "column": 1, + "source_line": "#define STBTE__ID2(n,p,q) STBTE__ID(n, ((p)<<12)+(q) )" + }, + "unit_kind": "macro", + "unit_name": "STBTE__ID2" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTE__IDMAP' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2273, + "column": 1, + "source_line": "#define STBTE__IDMAP(x,y) STBTE__ID2(STBTE__map, x,y)" + }, + "unit_kind": "macro", + "unit_name": "STBTE__IDMAP" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTE__BG' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2289, + "column": 1, + "source_line": "#define STBTE__BG(tm,layer) ((layer) == 0 ? (tm)->background_tile : STBTE__NO_TILE)" + }, + "unit_kind": "macro", + "unit_name": "STBTE__BG" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTE__IS_MAP_ACTIVE' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2638, + "column": 1, + "source_line": "#define STBTE__IS_MAP_ACTIVE() ((stbte__ui.active_id & 127) == STBTE__map)" + }, + "unit_kind": "macro", + "unit_name": "STBTE__IS_MAP_ACTIVE" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTE__IS_MAP_HOT' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 2639, + "column": 1, + "source_line": "#define STBTE__IS_MAP_HOT() ((stbte__ui.hot_id & 127) == STBTE__map)" + }, + "unit_kind": "macro", + "unit_name": "STBTE__IS_MAP_HOT" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTE__TEXTCOLOR' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 3374, + "column": 1, + "source_line": "#define STBTE__TEXTCOLOR(n) stbte__color_table[n][STBTE__text][STBTE__idle]" + }, + "unit_kind": "macro", + "unit_name": "STBTE__TEXTCOLOR" + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 641, + "column": 1, + "source_line": "static char *stbte__color_names[] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 651, + "column": 1, + "source_line": "static int stbte__color_table[STBTE__num_color_modes][STBTE__num_color_aspects][STBTE__num_color_states] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 731, + "column": 1, + "source_line": "static unsigned char stbte__state_to_index[2][2][2][2] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 746, + "column": 1, + "source_line": "static short stbte__fontdata[769] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 838, + "column": 1, + "source_line": "static int toolchar[] = { 26,24,25,20,23,22,18, 19,17, 29,28, };" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_tilemap_editor.h", + "line": 919, + "column": 1, + "source_line": "static stbte__ui_t stbte__ui = { STBTE__tool_brush, 0 };" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + } + ] +} diff --git a/tests/parser/c/fixtures/stb/stb_truetype.json b/tests/parser/c/fixtures/stb/stb_truetype.json new file mode 100644 index 000000000..526b8f7eb --- /dev/null +++ b/tests/parser/c/fixtures/stb/stb_truetype.json @@ -0,0 +1,26687 @@ +{ + "files": { + "stb/stb_truetype.h": { + "filename": "stb/stb_truetype.h", + "language": "c", + "parser_status": "partial", + "preprocessing": "raw", + "functions": [ + { + "name": "my_stbtt_initfont", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 287, + "column": 1, + "source_line": "void my_stbtt_initfont(void)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 287, + "column": 1, + "source_line": "void my_stbtt_initfont(void)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 297, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "my_stbtt_print", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "text", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *text", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *text", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 299, + "column": 1, + "source_line": "void my_stbtt_print(float x, float y, char *text)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 299, + "column": 1, + "source_line": "void my_stbtt_print(float x, float y, char *text)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 319, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "main", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "argc", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int argc" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int argc" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "argv", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char **argv", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char **argv", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 334, + "column": 1, + "source_line": "int main(int argc, char **argv)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 334, + "column": 1, + "source_line": "int main(int argc, char **argv)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 351, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbtt__buf_get8", + "result_type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbtt_uint8", + "name": "stbtt_uint8", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "typedef unsigned char stbtt_uint8" + }, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 428, + "column": 4, + "source_line": " typedef unsigned char stbtt_uint8;" + }, + "declaration_locations": [] + }, + "parameters": [ + { + "name": "b", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__buf *b", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbtt__buf", + "name": "stbtt__buf", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__buf *b", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__buf" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1133, + "column": 1, + "source_line": "static stbtt_uint8 stbtt__buf_get8(stbtt__buf *b)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1133, + "column": 1, + "source_line": "static stbtt_uint8 stbtt__buf_get8(stbtt__buf *b)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1138, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbtt__buf_peek8", + "result_type": { + "reference": "stbtt_uint8" + }, + "parameters": [ + { + "name": "b", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__buf *b", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbtt__buf", + "name": "stbtt__buf", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__buf *b", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__buf" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1140, + "column": 1, + "source_line": "static stbtt_uint8 stbtt__buf_peek8(stbtt__buf *b)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1140, + "column": 1, + "source_line": "static stbtt_uint8 stbtt__buf_peek8(stbtt__buf *b)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1145, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbtt__buf_seek", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "b", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__buf *b", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbtt__buf", + "name": "stbtt__buf", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__buf *b", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__buf" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "o", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int o" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int o" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1147, + "column": 1, + "source_line": "static void stbtt__buf_seek(stbtt__buf *b, int o)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1147, + "column": 1, + "source_line": "static void stbtt__buf_seek(stbtt__buf *b, int o)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1151, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbtt__buf_skip", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "b", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__buf *b", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbtt__buf", + "name": "stbtt__buf", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__buf *b", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__buf" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "o", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int o" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int o" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1153, + "column": 1, + "source_line": "static void stbtt__buf_skip(stbtt__buf *b, int o)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1153, + "column": 1, + "source_line": "static void stbtt__buf_skip(stbtt__buf *b, int o)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1156, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbtt__buf_get", + "result_type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbtt_uint32", + "name": "stbtt_uint32", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "typedef unsigned int stbtt_uint32" + }, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 432, + "column": 4, + "source_line": " typedef unsigned int stbtt_uint32;" + }, + "declaration_locations": [] + }, + "parameters": [ + { + "name": "b", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__buf *b", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbtt__buf", + "name": "stbtt__buf", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__buf *b", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__buf" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1158, + "column": 1, + "source_line": "static stbtt_uint32 stbtt__buf_get(stbtt__buf *b, int n)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1158, + "column": 1, + "source_line": "static stbtt_uint32 stbtt__buf_get(stbtt__buf *b, int n)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1166, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbtt__new_buf", + "result_type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbtt__buf", + "name": "stbtt__buf", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const void *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [ + "const" + ], + "source_text": "const void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const void *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [ + "const" + ], + "source_text": "const void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "size", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t size", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1168, + "column": 1, + "source_line": "static stbtt__buf stbtt__new_buf(const void *p, size_t size)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1168, + "column": 1, + "source_line": "static stbtt__buf stbtt__new_buf(const void *p, size_t size)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1176, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbtt__buf_range", + "result_type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbtt__buf", + "name": "stbtt__buf", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "parameters": [ + { + "name": "b", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stbtt__buf *b", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [ + "const" + ], + "source_text": "const stbtt__buf", + "name": "stbtt__buf", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stbtt__buf *b", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__buf" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "o", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int o" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int o" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "s", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int s" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int s" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1181, + "column": 1, + "source_line": "static stbtt__buf stbtt__buf_range(const stbtt__buf *b, int o, int s)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1181, + "column": 1, + "source_line": "static stbtt__buf stbtt__buf_range(const stbtt__buf *b, int o, int s)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1188, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbtt__cff_get_index", + "result_type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbtt__buf", + "name": "stbtt__buf", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "parameters": [ + { + "name": "b", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__buf *b", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbtt__buf", + "name": "stbtt__buf", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__buf *b", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__buf" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1190, + "column": 1, + "source_line": "static stbtt__buf stbtt__cff_get_index(stbtt__buf *b)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1190, + "column": 1, + "source_line": "static stbtt__buf stbtt__cff_get_index(stbtt__buf *b)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1202, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbtt__cff_int", + "result_type": { + "reference": "stbtt_uint32" + }, + "parameters": [ + { + "name": "b", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__buf *b", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbtt__buf", + "name": "stbtt__buf", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__buf *b", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__buf" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1204, + "column": 1, + "source_line": "static stbtt_uint32 stbtt__cff_int(stbtt__buf *b)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1204, + "column": 1, + "source_line": "static stbtt_uint32 stbtt__cff_int(stbtt__buf *b)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1214, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbtt__cff_skip_operand", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "b", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__buf *b", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbtt__buf", + "name": "stbtt__buf", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__buf *b", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__buf" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1216, + "column": 1, + "source_line": "static void stbtt__cff_skip_operand(stbtt__buf *b) {" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1216, + "column": 1, + "source_line": "static void stbtt__cff_skip_operand(stbtt__buf *b) {" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1229, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbtt__dict_get", + "result_type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbtt__buf", + "name": "stbtt__buf", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "parameters": [ + { + "name": "b", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__buf *b", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbtt__buf", + "name": "stbtt__buf", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__buf *b", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__buf" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "key", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int key" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int key" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1231, + "column": 1, + "source_line": "static stbtt__buf stbtt__dict_get(stbtt__buf *b, int key)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1231, + "column": 1, + "source_line": "static stbtt__buf stbtt__dict_get(stbtt__buf *b, int key)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1244, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbtt__dict_get_ints", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "b", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__buf *b", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbtt__buf", + "name": "stbtt__buf", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__buf *b", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__buf" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "key", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int key" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int key" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "outcount", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int outcount" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int outcount" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "out", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_uint32 *out", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_uint32" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_uint32 *out", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_uint32" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1246, + "column": 1, + "source_line": "static void stbtt__dict_get_ints(stbtt__buf *b, int key, int outcount, stbtt_uint32 *out)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1246, + "column": 1, + "source_line": "static void stbtt__dict_get_ints(stbtt__buf *b, int key, int outcount, stbtt_uint32 *out)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1252, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbtt__cff_index_count", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "b", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__buf *b", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbtt__buf", + "name": "stbtt__buf", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__buf *b", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__buf" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1254, + "column": 1, + "source_line": "static int stbtt__cff_index_count(stbtt__buf *b)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1254, + "column": 1, + "source_line": "static int stbtt__cff_index_count(stbtt__buf *b)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1258, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbtt__cff_index_get", + "result_type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbtt__buf", + "name": "stbtt__buf", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "parameters": [ + { + "name": "b", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbtt__buf b", + "name": "stbtt__buf", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "declared_type": { + "reference": "stbtt__buf" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "i", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int i" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int i" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1260, + "column": 1, + "source_line": "static stbtt__buf stbtt__cff_index_get(stbtt__buf b, int i)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1260, + "column": 1, + "source_line": "static stbtt__buf stbtt__cff_index_get(stbtt__buf b, int i)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1272, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "ttUSHORT", + "result_type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbtt_uint16", + "name": "stbtt_uint16", + "type": { + "model": "CUnsignedShort", + "qualifiers": [], + "source_text": "typedef unsigned short stbtt_uint16" + }, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 430, + "column": 4, + "source_line": " typedef unsigned short stbtt_uint16;" + }, + "declaration_locations": [] + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_uint8 *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_uint8" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_uint8 *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_uint8" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1286, + "column": 1, + "source_line": "static stbtt_uint16 ttUSHORT(stbtt_uint8 *p) { return p[0]*256 + p[1]; }" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1286, + "column": 1, + "source_line": "static stbtt_uint16 ttUSHORT(stbtt_uint8 *p) { return p[0]*256 + p[1]; }" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1286, + "column": 72, + "source_line": "static stbtt_uint16 ttUSHORT(stbtt_uint8 *p) { return p[0]*256 + p[1]; }" + }, + "declaration_locations": [] + }, + { + "name": "ttSHORT", + "result_type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbtt_int16", + "name": "stbtt_int16", + "type": { + "model": "CShort", + "qualifiers": [], + "source_text": "typedef signed short stbtt_int16" + }, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 431, + "column": 4, + "source_line": " typedef signed short stbtt_int16;" + }, + "declaration_locations": [] + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_uint8 *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_uint8" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_uint8 *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_uint8" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1287, + "column": 1, + "source_line": "static stbtt_int16 ttSHORT(stbtt_uint8 *p) { return p[0]*256 + p[1]; }" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1287, + "column": 1, + "source_line": "static stbtt_int16 ttSHORT(stbtt_uint8 *p) { return p[0]*256 + p[1]; }" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1287, + "column": 72, + "source_line": "static stbtt_int16 ttSHORT(stbtt_uint8 *p) { return p[0]*256 + p[1]; }" + }, + "declaration_locations": [] + }, + { + "name": "ttULONG", + "result_type": { + "reference": "stbtt_uint32" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_uint8 *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_uint8" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_uint8 *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_uint8" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1288, + "column": 1, + "source_line": "static stbtt_uint32 ttULONG(stbtt_uint8 *p) { return (p[0]<<24) + (p[1]<<16) + (p[2]<<8) + p[3]; }" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1288, + "column": 1, + "source_line": "static stbtt_uint32 ttULONG(stbtt_uint8 *p) { return (p[0]<<24) + (p[1]<<16) + (p[2]<<8) + p[3]; }" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1288, + "column": 99, + "source_line": "static stbtt_uint32 ttULONG(stbtt_uint8 *p) { return (p[0]<<24) + (p[1]<<16) + (p[2]<<8) + p[3]; }" + }, + "declaration_locations": [] + }, + { + "name": "ttLONG", + "result_type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbtt_int32", + "name": "stbtt_int32", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "typedef signed int stbtt_int32" + }, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 433, + "column": 4, + "source_line": " typedef signed int stbtt_int32;" + }, + "declaration_locations": [] + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_uint8 *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_uint8" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_uint8 *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_uint8" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1289, + "column": 1, + "source_line": "static stbtt_int32 ttLONG(stbtt_uint8 *p) { return (p[0]<<24) + (p[1]<<16) + (p[2]<<8) + p[3]; }" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1289, + "column": 1, + "source_line": "static stbtt_int32 ttLONG(stbtt_uint8 *p) { return (p[0]<<24) + (p[1]<<16) + (p[2]<<8) + p[3]; }" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1289, + "column": 99, + "source_line": "static stbtt_int32 ttLONG(stbtt_uint8 *p) { return (p[0]<<24) + (p[1]<<16) + (p[2]<<8) + p[3]; }" + }, + "declaration_locations": [] + }, + { + "name": "stbtt__isfont", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "font", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_uint8 *font", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_uint8" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_uint8 *font", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_uint8" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1294, + "column": 1, + "source_line": "static int stbtt__isfont(stbtt_uint8 *font)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1294, + "column": 1, + "source_line": "static int stbtt__isfont(stbtt_uint8 *font)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1303, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbtt__find_table", + "result_type": { + "reference": "stbtt_uint32" + }, + "parameters": [ + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_uint8 *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_uint8" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_uint8 *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_uint8" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "fontstart", + "type": { + "reference": "stbtt_uint32" + }, + "declared_type": { + "reference": "stbtt_uint32" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "tag", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *tag", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *tag", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1306, + "column": 1, + "source_line": "static stbtt_uint32 stbtt__find_table(stbtt_uint8 *data, stbtt_uint32 fontstart, const char *tag)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1306, + "column": 1, + "source_line": "static stbtt_uint32 stbtt__find_table(stbtt_uint8 *data, stbtt_uint32 fontstart, const char *tag)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1317, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbtt_GetFontOffsetForIndex_internal", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "font_collection", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *font_collection", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *font_collection", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "index", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int index" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int index" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1319, + "column": 1, + "source_line": "static int stbtt_GetFontOffsetForIndex_internal(unsigned char *font_collection, int index)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1319, + "column": 1, + "source_line": "static int stbtt_GetFontOffsetForIndex_internal(unsigned char *font_collection, int index)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1336, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbtt_GetNumberOfFonts_internal", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "font_collection", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *font_collection", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *font_collection", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1338, + "column": 1, + "source_line": "static int stbtt_GetNumberOfFonts_internal(unsigned char *font_collection)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1338, + "column": 1, + "source_line": "static int stbtt_GetNumberOfFonts_internal(unsigned char *font_collection)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1352, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbtt__get_subrs", + "result_type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbtt__buf", + "name": "stbtt__buf", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "parameters": [ + { + "name": "cff", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbtt__buf cff", + "name": "stbtt__buf", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "declared_type": { + "reference": "stbtt__buf" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "fontdict", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbtt__buf fontdict", + "name": "stbtt__buf", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "declared_type": { + "reference": "stbtt__buf" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1354, + "column": 1, + "source_line": "static stbtt__buf stbtt__get_subrs(stbtt__buf cff, stbtt__buf fontdict)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1354, + "column": 1, + "source_line": "static stbtt__buf stbtt__get_subrs(stbtt__buf cff, stbtt__buf fontdict)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1365, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbtt__get_svg", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_fontinfo *info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbtt_fontinfo", + "name": "stbtt_fontinfo", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_fontinfo *info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_fontinfo" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1368, + "column": 1, + "source_line": "static int stbtt__get_svg(stbtt_fontinfo *info)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1368, + "column": 1, + "source_line": "static int stbtt__get_svg(stbtt_fontinfo *info)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1381, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbtt_InitFont_internal", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_fontinfo *info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbtt_fontinfo", + "name": "stbtt_fontinfo", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_fontinfo *info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_fontinfo" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "fontstart", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int fontstart" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int fontstart" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1383, + "column": 1, + "source_line": "static int stbtt_InitFont_internal(stbtt_fontinfo *info, unsigned char *data, int fontstart)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1383, + "column": 1, + "source_line": "static int stbtt_InitFont_internal(stbtt_fontinfo *info, unsigned char *data, int fontstart)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1494, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbtt_setvertex", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "v", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_vertex *v", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbtt_vertex", + "name": "stbtt_vertex", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_vertex *v", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_vertex" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "type", + "type": { + "reference": "stbtt_uint8" + }, + "declared_type": { + "reference": "stbtt_uint8" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "reference": "stbtt_int32" + }, + "declared_type": { + "reference": "stbtt_int32" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "reference": "stbtt_int32" + }, + "declared_type": { + "reference": "stbtt_int32" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cx", + "type": { + "reference": "stbtt_int32" + }, + "declared_type": { + "reference": "stbtt_int32" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cy", + "type": { + "reference": "stbtt_int32" + }, + "declared_type": { + "reference": "stbtt_int32" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1594, + "column": 1, + "source_line": "static void stbtt_setvertex(stbtt_vertex *v, stbtt_uint8 type, stbtt_int32 x, stbtt_int32 y, stbtt_int32 cx, stbtt_int32 cy)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1594, + "column": 1, + "source_line": "static void stbtt_setvertex(stbtt_vertex *v, stbtt_uint8 type, stbtt_int32 x, stbtt_int32 y, stbtt_int32 cx, stbtt_int32 cy)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1601, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbtt__GetGlyfOffset", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stbtt_fontinfo *info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [ + "const" + ], + "source_text": "const stbtt_fontinfo", + "name": "stbtt_fontinfo", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stbtt_fontinfo *info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_fontinfo" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "glyph_index", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int glyph_index" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int glyph_index" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1603, + "column": 1, + "source_line": "static int stbtt__GetGlyfOffset(const stbtt_fontinfo *info, int glyph_index)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1603, + "column": 1, + "source_line": "static int stbtt__GetGlyfOffset(const stbtt_fontinfo *info, int glyph_index)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1621, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbtt__GetGlyphInfoT2", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stbtt_fontinfo *info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [ + "const" + ], + "source_text": "const stbtt_fontinfo", + "name": "stbtt_fontinfo", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stbtt_fontinfo *info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_fontinfo" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "glyph_index", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int glyph_index" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int glyph_index" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x0", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x0", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x0", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y0", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y0", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y0", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x1", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x1", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x1", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y1", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y1", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y1", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2286, + "column": 1, + "source_line": "static int stbtt__GetGlyphInfoT2(const stbtt_fontinfo *info, int glyph_index, int *x0, int *y0, int *x1, int *y1)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 2286, + "column": 1, + "source_line": "static int stbtt__GetGlyphInfoT2(const stbtt_fontinfo *info, int glyph_index, int *x0, int *y0, int *x1, int *y1)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 2295, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_truetype.h", + "line": 1623, + "column": 1, + "source_line": "static int stbtt__GetGlyphInfoT2(const stbtt_fontinfo *info, int glyph_index, int *x0, int *y0, int *x1, int *y1);" + } + ] + }, + { + "name": "stbtt__close_shape", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "vertices", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_vertex *vertices", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbtt_vertex", + "name": "stbtt_vertex", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_vertex *vertices", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_vertex" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "num_vertices", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_vertices" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_vertices" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "was_off", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int was_off" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int was_off" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "start_off", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int start_off" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int start_off" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "sx", + "type": { + "reference": "stbtt_int32" + }, + "declared_type": { + "reference": "stbtt_int32" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "sy", + "type": { + "reference": "stbtt_int32" + }, + "declared_type": { + "reference": "stbtt_int32" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "scx", + "type": { + "reference": "stbtt_int32" + }, + "declared_type": { + "reference": "stbtt_int32" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "scy", + "type": { + "reference": "stbtt_int32" + }, + "declared_type": { + "reference": "stbtt_int32" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cx", + "type": { + "reference": "stbtt_int32" + }, + "declared_type": { + "reference": "stbtt_int32" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cy", + "type": { + "reference": "stbtt_int32" + }, + "declared_type": { + "reference": "stbtt_int32" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1658, + "column": 1, + "source_line": "static int stbtt__close_shape(stbtt_vertex *vertices, int num_vertices, int was_off, int start_off," + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1658, + "column": 1, + "source_line": "static int stbtt__close_shape(stbtt_vertex *vertices, int num_vertices, int was_off, int start_off," + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1672, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbtt__GetGlyphShapeTT", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stbtt_fontinfo *info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [ + "const" + ], + "source_text": "const stbtt_fontinfo", + "name": "stbtt_fontinfo", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stbtt_fontinfo *info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_fontinfo" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "glyph_index", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int glyph_index" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int glyph_index" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "pvertices", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_vertex **pvertices", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbtt_vertex", + "name": "stbtt_vertex", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_vertex **pvertices", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_vertex" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1674, + "column": 1, + "source_line": "static int stbtt__GetGlyphShapeTT(const stbtt_fontinfo *info, int glyph_index, stbtt_vertex **pvertices)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1674, + "column": 1, + "source_line": "static int stbtt__GetGlyphShapeTT(const stbtt_fontinfo *info, int glyph_index, stbtt_vertex **pvertices)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1895, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbtt__track_vertex", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "c", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__csctx *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbtt__csctx", + "name": "stbtt__csctx", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "bounds", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int bounds" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1899, + "column": 4, + "source_line": " int bounds;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "started", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int started" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1900, + "column": 4, + "source_line": " int started;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "first_x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float first_x" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1901, + "column": 4, + "source_line": " float first_x, first_y;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "first_y", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float first_y" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1901, + "column": 4, + "source_line": " float first_x, first_y;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1902, + "column": 4, + "source_line": " float x, y;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "y", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1902, + "column": 4, + "source_line": " float x, y;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "min_x", + "type": { + "reference": "stbtt_int32" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1903, + "column": 4, + "source_line": " stbtt_int32 min_x, max_x, min_y, max_y;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "max_x", + "type": { + "reference": "stbtt_int32" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1903, + "column": 4, + "source_line": " stbtt_int32 min_x, max_x, min_y, max_y;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "min_y", + "type": { + "reference": "stbtt_int32" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1903, + "column": 4, + "source_line": " stbtt_int32 min_x, max_x, min_y, max_y;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "max_y", + "type": { + "reference": "stbtt_int32" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1903, + "column": 4, + "source_line": " stbtt_int32 min_x, max_x, min_y, max_y;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "pvertices", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_vertex *pvertices", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbtt_vertex", + "name": "stbtt_vertex", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1905, + "column": 4, + "source_line": " stbtt_vertex *pvertices;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "num_vertices", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_vertices" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1906, + "column": 4, + "source_line": " int num_vertices;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_truetype.h:1897:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1897, + "column": 1, + "source_line": "typedef struct" + } + }, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1897, + "column": 1, + "source_line": "typedef struct" + }, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__csctx *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__csctx" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "reference": "stbtt_int32" + }, + "declared_type": { + "reference": "stbtt_int32" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "reference": "stbtt_int32" + }, + "declared_type": { + "reference": "stbtt_int32" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1911, + "column": 1, + "source_line": "static void stbtt__track_vertex(stbtt__csctx *c, stbtt_int32 x, stbtt_int32 y)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1911, + "column": 1, + "source_line": "static void stbtt__track_vertex(stbtt__csctx *c, stbtt_int32 x, stbtt_int32 y)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1918, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbtt__csctx_v", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "c", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__csctx *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__csctx" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__csctx *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__csctx" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "type", + "type": { + "reference": "stbtt_uint8" + }, + "declared_type": { + "reference": "stbtt_uint8" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "reference": "stbtt_int32" + }, + "declared_type": { + "reference": "stbtt_int32" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "reference": "stbtt_int32" + }, + "declared_type": { + "reference": "stbtt_int32" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cx", + "type": { + "reference": "stbtt_int32" + }, + "declared_type": { + "reference": "stbtt_int32" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cy", + "type": { + "reference": "stbtt_int32" + }, + "declared_type": { + "reference": "stbtt_int32" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cx1", + "type": { + "reference": "stbtt_int32" + }, + "declared_type": { + "reference": "stbtt_int32" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cy1", + "type": { + "reference": "stbtt_int32" + }, + "declared_type": { + "reference": "stbtt_int32" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1920, + "column": 1, + "source_line": "static void stbtt__csctx_v(stbtt__csctx *c, stbtt_uint8 type, stbtt_int32 x, stbtt_int32 y, stbtt_int32 cx, stbtt_int32 cy, stbtt_int32 cx1, stbtt_int32 cy1)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1920, + "column": 1, + "source_line": "static void stbtt__csctx_v(stbtt__csctx *c, stbtt_uint8 type, stbtt_int32 x, stbtt_int32 y, stbtt_int32 cx, stbtt_int32 cy, stbtt_int32 cx1, stbtt_int32 cy1)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1934, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbtt__csctx_close_shape", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "ctx", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__csctx *ctx", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__csctx" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__csctx *ctx", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__csctx" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1936, + "column": 1, + "source_line": "static void stbtt__csctx_close_shape(stbtt__csctx *ctx)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1936, + "column": 1, + "source_line": "static void stbtt__csctx_close_shape(stbtt__csctx *ctx)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1940, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbtt__csctx_rmove_to", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "ctx", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__csctx *ctx", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__csctx" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__csctx *ctx", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__csctx" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dx", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dx" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dx" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dy", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dy" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dy" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1942, + "column": 1, + "source_line": "static void stbtt__csctx_rmove_to(stbtt__csctx *ctx, float dx, float dy)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1942, + "column": 1, + "source_line": "static void stbtt__csctx_rmove_to(stbtt__csctx *ctx, float dx, float dy)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1948, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbtt__csctx_rline_to", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "ctx", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__csctx *ctx", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__csctx" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__csctx *ctx", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__csctx" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dx", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dx" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dx" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dy", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dy" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dy" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1950, + "column": 1, + "source_line": "static void stbtt__csctx_rline_to(stbtt__csctx *ctx, float dx, float dy)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1950, + "column": 1, + "source_line": "static void stbtt__csctx_rline_to(stbtt__csctx *ctx, float dx, float dy)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1955, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbtt__csctx_rccurve_to", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "ctx", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__csctx *ctx", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__csctx" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__csctx *ctx", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__csctx" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dx1", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dx1" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dx1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dy1", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dy1" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dy1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dx2", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dx2" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dx2" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dy2", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dy2" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dy2" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dx3", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dx3" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dx3" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dy3", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dy3" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dy3" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1957, + "column": 1, + "source_line": "static void stbtt__csctx_rccurve_to(stbtt__csctx *ctx, float dx1, float dy1, float dx2, float dy2, float dx3, float dy3)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1957, + "column": 1, + "source_line": "static void stbtt__csctx_rccurve_to(stbtt__csctx *ctx, float dx1, float dy1, float dx2, float dy2, float dx3, float dy3)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1966, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbtt__get_subr", + "result_type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbtt__buf", + "name": "stbtt__buf", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "parameters": [ + { + "name": "idx", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbtt__buf idx", + "name": "stbtt__buf", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "declared_type": { + "reference": "stbtt__buf" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1968, + "column": 1, + "source_line": "static stbtt__buf stbtt__get_subr(stbtt__buf idx, int n)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1968, + "column": 1, + "source_line": "static stbtt__buf stbtt__get_subr(stbtt__buf idx, int n)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1980, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbtt__cid_get_glyph_subrs", + "result_type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbtt__buf", + "name": "stbtt__buf", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "parameters": [ + { + "name": "info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stbtt_fontinfo *info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [ + "const" + ], + "source_text": "const stbtt_fontinfo", + "name": "stbtt_fontinfo", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stbtt_fontinfo *info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_fontinfo" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "glyph_index", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int glyph_index" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int glyph_index" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1982, + "column": 1, + "source_line": "static stbtt__buf stbtt__cid_get_glyph_subrs(const stbtt_fontinfo *info, int glyph_index)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1982, + "column": 1, + "source_line": "static stbtt__buf stbtt__cid_get_glyph_subrs(const stbtt_fontinfo *info, int glyph_index)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 2008, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbtt__run_charstring", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stbtt_fontinfo *info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [ + "const" + ], + "source_text": "const stbtt_fontinfo", + "name": "stbtt_fontinfo", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stbtt_fontinfo *info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_fontinfo" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "glyph_index", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int glyph_index" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int glyph_index" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__csctx *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__csctx" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__csctx *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__csctx" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2010, + "column": 1, + "source_line": "static int stbtt__run_charstring(const stbtt_fontinfo *info, int glyph_index, stbtt__csctx *c)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 2010, + "column": 1, + "source_line": "static int stbtt__run_charstring(const stbtt_fontinfo *info, int glyph_index, stbtt__csctx *c)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 2267, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbtt__GetGlyphShapeT2", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stbtt_fontinfo *info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [ + "const" + ], + "source_text": "const stbtt_fontinfo", + "name": "stbtt_fontinfo", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stbtt_fontinfo *info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_fontinfo" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "glyph_index", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int glyph_index" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int glyph_index" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "pvertices", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_vertex **pvertices", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbtt_vertex", + "name": "stbtt_vertex", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_vertex **pvertices", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_vertex" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2269, + "column": 1, + "source_line": "static int stbtt__GetGlyphShapeT2(const stbtt_fontinfo *info, int glyph_index, stbtt_vertex **pvertices)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 2269, + "column": 1, + "source_line": "static int stbtt__GetGlyphShapeT2(const stbtt_fontinfo *info, int glyph_index, stbtt_vertex **pvertices)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 2284, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbtt__GetGlyphKernInfoAdvance", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stbtt_fontinfo *info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [ + "const" + ], + "source_text": "const stbtt_fontinfo", + "name": "stbtt_fontinfo", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stbtt_fontinfo *info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_fontinfo" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "glyph1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int glyph1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int glyph1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "glyph2", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int glyph2" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int glyph2" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2359, + "column": 1, + "source_line": "static int stbtt__GetGlyphKernInfoAdvance(const stbtt_fontinfo *info, int glyph1, int glyph2)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 2359, + "column": 1, + "source_line": "static int stbtt__GetGlyphKernInfoAdvance(const stbtt_fontinfo *info, int glyph1, int glyph2)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 2387, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbtt__GetCoverageIndex", + "result_type": { + "reference": "stbtt_int32" + }, + "parameters": [ + { + "name": "coverageTable", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_uint8 *coverageTable", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_uint8" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_uint8 *coverageTable", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_uint8" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "glyph", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int glyph" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int glyph" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2389, + "column": 1, + "source_line": "static stbtt_int32 stbtt__GetCoverageIndex(stbtt_uint8 *coverageTable, int glyph)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 2389, + "column": 1, + "source_line": "static stbtt_int32 stbtt__GetCoverageIndex(stbtt_uint8 *coverageTable, int glyph)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 2445, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbtt__GetGlyphClass", + "result_type": { + "reference": "stbtt_int32" + }, + "parameters": [ + { + "name": "classDefTable", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_uint8 *classDefTable", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_uint8" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_uint8 *classDefTable", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_uint8" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "glyph", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int glyph" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int glyph" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2447, + "column": 1, + "source_line": "static stbtt_int32 stbtt__GetGlyphClass(stbtt_uint8 *classDefTable, int glyph)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 2447, + "column": 1, + "source_line": "static stbtt_int32 stbtt__GetGlyphClass(stbtt_uint8 *classDefTable, int glyph)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 2491, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbtt__GetGlyphGPOSInfoAdvance", + "result_type": { + "reference": "stbtt_int32" + }, + "parameters": [ + { + "name": "info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stbtt_fontinfo *info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [ + "const" + ], + "source_text": "const stbtt_fontinfo", + "name": "stbtt_fontinfo", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stbtt_fontinfo *info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_fontinfo" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "glyph1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int glyph1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int glyph1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "glyph2", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int glyph2" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int glyph2" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2496, + "column": 1, + "source_line": "static stbtt_int32 stbtt__GetGlyphGPOSInfoAdvance(const stbtt_fontinfo *info, int glyph1, int glyph2)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 2496, + "column": 1, + "source_line": "static stbtt_int32 stbtt__GetGlyphGPOSInfoAdvance(const stbtt_fontinfo *info, int glyph1, int glyph2)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 2608, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbtt__hheap_alloc", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "parameters": [ + { + "name": "hh", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__hheap *hh", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbtt__hheap", + "name": "stbtt__hheap", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": "stbtt__hheap", + "members": [ + { + "name": "head", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "struct stbtt__hheap_chunk *head", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": "stbtt__hheap_chunk", + "members": [ + { + "name": "next", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "struct stbtt__hheap_chunk *next", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "struct stbtt__hheap_chunk" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2760, + "column": 4, + "source_line": " struct stbtt__hheap_chunk *next;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": null, + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2758, + "column": 1, + "source_line": "typedef struct stbtt__hheap_chunk" + } + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2765, + "column": 4, + "source_line": " struct stbtt__hheap_chunk *head;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "first_free", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *first_free", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2766, + "column": 4, + "source_line": " void *first_free;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "num_remaining_in_head_chunk", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_remaining_in_head_chunk" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2767, + "column": 4, + "source_line": " int num_remaining_in_head_chunk;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": null, + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2763, + "column": 1, + "source_line": "typedef struct stbtt__hheap" + } + }, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2763, + "column": 1, + "source_line": "typedef struct stbtt__hheap" + }, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__hheap *hh", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__hheap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "size", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t size", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "userdata", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *userdata", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *userdata", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2770, + "column": 1, + "source_line": "static void *stbtt__hheap_alloc(stbtt__hheap *hh, size_t size, void *userdata)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 2770, + "column": 1, + "source_line": "static void *stbtt__hheap_alloc(stbtt__hheap *hh, size_t size, void *userdata)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 2789, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbtt__hheap_free", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "hh", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__hheap *hh", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__hheap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__hheap *hh", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__hheap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2791, + "column": 1, + "source_line": "static void stbtt__hheap_free(stbtt__hheap *hh, void *p)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 2791, + "column": 1, + "source_line": "static void stbtt__hheap_free(stbtt__hheap *hh, void *p)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 2795, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbtt__hheap_cleanup", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "hh", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__hheap *hh", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__hheap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__hheap *hh", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__hheap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "userdata", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *userdata", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *userdata", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2797, + "column": 1, + "source_line": "static void stbtt__hheap_cleanup(stbtt__hheap *hh, void *userdata)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 2797, + "column": 1, + "source_line": "static void stbtt__hheap_cleanup(stbtt__hheap *hh, void *userdata)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 2805, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbtt__new_active", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__active_edge", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbtt__active_edge", + "name": "stbtt__active_edge", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": "stbtt__active_edge", + "members": [ + { + "name": "next", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "struct stbtt__active_edge *next", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "struct stbtt__active_edge" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2815, + "column": 4, + "source_line": " struct stbtt__active_edge *next;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2817, + "column": 4, + "source_line": " int x,dx;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "dx", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int dx" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2817, + "column": 4, + "source_line": " int x,dx;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "ey", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float ey" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2818, + "column": 4, + "source_line": " float ey;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "direction", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int direction" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2819, + "column": 4, + "source_line": " int direction;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "fx", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float fx" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2821, + "column": 4, + "source_line": " float fx,fdx,fdy;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "fdx", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float fdx" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2821, + "column": 4, + "source_line": " float fx,fdx,fdy;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "fdy", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float fdy" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2821, + "column": 4, + "source_line": " float fx,fdx,fdy;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "direction", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float direction" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2822, + "column": 4, + "source_line": " float direction;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "sy", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float sy" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2823, + "column": 4, + "source_line": " float sy;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "ey", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float ey" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2824, + "column": 4, + "source_line": " float ey;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": null, + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2813, + "column": 1, + "source_line": "typedef struct stbtt__active_edge" + } + }, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2813, + "column": 1, + "source_line": "typedef struct stbtt__active_edge" + }, + "declaration_locations": [] + } + ] + }, + "parameters": [ + { + "name": "hh", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__hheap *hh", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__hheap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__hheap *hh", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__hheap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "e", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__edge *e", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbtt__edge", + "name": "stbtt__edge", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": "stbtt__edge", + "members": [ + { + "name": "x0", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x0" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2808, + "column": 4, + "source_line": " float x0,y0, x1,y1;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "y0", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y0" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2808, + "column": 4, + "source_line": " float x0,y0, x1,y1;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "x1", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x1" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2808, + "column": 4, + "source_line": " float x0,y0, x1,y1;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "y1", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y1" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2808, + "column": 4, + "source_line": " float x0,y0, x1,y1;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "invert", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int invert" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2809, + "column": 4, + "source_line": " int invert;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": null, + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2807, + "column": 1, + "source_line": "typedef struct stbtt__edge {" + } + }, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2807, + "column": 1, + "source_line": "typedef struct stbtt__edge {" + }, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__edge *e", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__edge" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "off_x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int off_x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int off_x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "start_point", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float start_point" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float start_point" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "userdata", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *userdata", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *userdata", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2835, + "column": 1, + "source_line": "static stbtt__active_edge *stbtt__new_active(stbtt__hheap *hh, stbtt__edge *e, int off_x, float start_point, void *userdata)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 2835, + "column": 1, + "source_line": "static stbtt__active_edge *stbtt__new_active(stbtt__hheap *hh, stbtt__edge *e, int off_x, float start_point, void *userdata)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 2855, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbtt__fill_active_edges", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "scanline", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *scanline", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *scanline", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "e", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__active_edge *e", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__active_edge" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__active_edge *e", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__active_edge" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "max_weight", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int max_weight" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int max_weight" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2882, + "column": 1, + "source_line": "static void stbtt__fill_active_edges(unsigned char *scanline, int len, stbtt__active_edge *e, int max_weight)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 2882, + "column": 1, + "source_line": "static void stbtt__fill_active_edges(unsigned char *scanline, int len, stbtt__active_edge *e, int max_weight)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 2922, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbtt__rasterize_sorted_edges", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "result", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__bitmap *result", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbtt__bitmap", + "name": "stbtt__bitmap", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__bitmap *result", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__bitmap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "e", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__edge *e", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__edge" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__edge *e", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__edge" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "vsubsample", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int vsubsample" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int vsubsample" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "off_x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int off_x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int off_x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "off_y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int off_y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int off_y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "userdata", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *userdata", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *userdata", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2924, + "column": 1, + "source_line": "static void stbtt__rasterize_sorted_edges(stbtt__bitmap *result, stbtt__edge *e, int n, int vsubsample, int off_x, int off_y, void *userdata)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 2924, + "column": 1, + "source_line": "static void stbtt__rasterize_sorted_edges(stbtt__bitmap *result, stbtt__edge *e, int n, int vsubsample, int off_x, int off_y, void *userdata)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 3022, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbtt__handle_clipped_edge", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "scanline", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *scanline", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *scanline", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "e", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__active_edge *e", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__active_edge" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__active_edge *e", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__active_edge" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x0", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x0" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y0", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y0" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x1", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x1" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y1", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y1" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y1" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3028, + "column": 1, + "source_line": "static void stbtt__handle_clipped_edge(float *scanline, int x, stbtt__active_edge *e, float x0, float y0, float x1, float y1)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 3028, + "column": 1, + "source_line": "static void stbtt__handle_clipped_edge(float *scanline, int x, stbtt__active_edge *e, float x0, float y0, float x1, float y1)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 3063, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbtt__sized_trapezoid_area", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "height", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float height" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float height" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "top_width", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float top_width" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float top_width" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "bottom_width", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float bottom_width" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float bottom_width" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3065, + "column": 1, + "source_line": "static float stbtt__sized_trapezoid_area(float height, float top_width, float bottom_width)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 3065, + "column": 1, + "source_line": "static float stbtt__sized_trapezoid_area(float height, float top_width, float bottom_width)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 3070, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbtt__position_trapezoid_area", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "height", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float height" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float height" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "tx0", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float tx0" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float tx0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "tx1", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float tx1" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float tx1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "bx0", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float bx0" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float bx0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "bx1", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float bx1" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float bx1" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3072, + "column": 1, + "source_line": "static float stbtt__position_trapezoid_area(float height, float tx0, float tx1, float bx0, float bx1)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 3072, + "column": 1, + "source_line": "static float stbtt__position_trapezoid_area(float height, float tx0, float tx1, float bx0, float bx1)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 3075, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbtt__sized_triangle_area", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "height", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float height" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float height" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "width", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float width" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float width" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3077, + "column": 1, + "source_line": "static float stbtt__sized_triangle_area(float height, float width)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 3077, + "column": 1, + "source_line": "static float stbtt__sized_triangle_area(float height, float width)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 3080, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbtt__fill_active_edges_new", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "scanline", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *scanline", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *scanline", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "scanline_fill", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *scanline_fill", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *scanline_fill", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "e", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__active_edge *e", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__active_edge" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__active_edge *e", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__active_edge" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y_top", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y_top" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y_top" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3082, + "column": 1, + "source_line": "static void stbtt__fill_active_edges_new(float *scanline, float *scanline_fill, int len, stbtt__active_edge *e, float y_top)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 3082, + "column": 1, + "source_line": "static void stbtt__fill_active_edges_new(float *scanline, float *scanline_fill, int len, stbtt__active_edge *e, float y_top)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 3294, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbtt__sort_edges_ins_sort", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__edge *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__edge" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__edge *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__edge" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3399, + "column": 1, + "source_line": "static void stbtt__sort_edges_ins_sort(stbtt__edge *p, int n)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 3399, + "column": 1, + "source_line": "static void stbtt__sort_edges_ins_sort(stbtt__edge *p, int n)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 3415, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbtt__sort_edges_quicksort", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__edge *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__edge" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__edge *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__edge" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3417, + "column": 1, + "source_line": "static void stbtt__sort_edges_quicksort(stbtt__edge *p, int n)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 3417, + "column": 1, + "source_line": "static void stbtt__sort_edges_quicksort(stbtt__edge *p, int n)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 3477, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbtt__sort_edges", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__edge *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__edge" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__edge *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__edge" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3479, + "column": 1, + "source_line": "static void stbtt__sort_edges(stbtt__edge *p, int n)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 3479, + "column": 1, + "source_line": "static void stbtt__sort_edges(stbtt__edge *p, int n)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 3483, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbtt__rasterize", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "result", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__bitmap *result", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbtt__bitmap", + "name": "stbtt__bitmap", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__bitmap *result", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__bitmap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "pts", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__point *pts", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbtt__point", + "name": "stbtt__point", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3487, + "column": 4, + "source_line": " float x,y;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "y", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3487, + "column": 4, + "source_line": " float x,y;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_truetype.h:3485:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3485, + "column": 1, + "source_line": "typedef struct" + } + }, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3485, + "column": 1, + "source_line": "typedef struct" + }, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__point *pts", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__point" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "wcount", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *wcount", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *wcount", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "windings", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int windings" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int windings" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "scale_x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float scale_x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float scale_x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "scale_y", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float scale_y" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float scale_y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "shift_x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float shift_x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float shift_x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "shift_y", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float shift_y" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float shift_y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "off_x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int off_x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int off_x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "off_y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int off_y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int off_y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "invert", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int invert" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int invert" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "userdata", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *userdata", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *userdata", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3490, + "column": 1, + "source_line": "static void stbtt__rasterize(stbtt__bitmap *result, stbtt__point *pts, int *wcount, int windings, float scale_x, float scale_y, float shift_x, float shift_y, int off_x, int off_y, int invert, void *userdata)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 3490, + "column": 1, + "source_line": "static void stbtt__rasterize(stbtt__bitmap *result, stbtt__point *pts, int *wcount, int windings, float scale_x, float scale_y, float shift_x, float shift_y, int off_x, int off_y, int invert, void *userdata)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 3545, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbtt__add_point", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "points", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__point *points", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__point" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__point *points", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__point" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3547, + "column": 1, + "source_line": "static void stbtt__add_point(stbtt__point *points, int n, float x, float y)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 3547, + "column": 1, + "source_line": "static void stbtt__add_point(stbtt__point *points, int n, float x, float y)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 3552, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbtt__tesselate_curve", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "points", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__point *points", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__point" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__point *points", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__point" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "num_points", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *num_points", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *num_points", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x0", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x0" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y0", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y0" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x1", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x1" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y1", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y1" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x2", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x2" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x2" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y2", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y2" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y2" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "objspace_flatness_squared", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float objspace_flatness_squared" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float objspace_flatness_squared" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3555, + "column": 1, + "source_line": "static int stbtt__tesselate_curve(stbtt__point *points, int *num_points, float x0, float y0, float x1, float y1, float x2, float y2, float objspace_flatness_squared, int n)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 3555, + "column": 1, + "source_line": "static int stbtt__tesselate_curve(stbtt__point *points, int *num_points, float x0, float y0, float x1, float y1, float x2, float y2, float objspace_flatness_squared, int n)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 3573, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbtt__tesselate_cubic", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "points", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__point *points", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__point" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__point *points", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__point" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "num_points", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *num_points", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *num_points", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x0", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x0" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y0", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y0" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x1", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x1" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y1", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y1" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x2", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x2" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x2" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y2", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y2" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y2" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x3", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x3" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x3" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y3", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y3" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y3" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "objspace_flatness_squared", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float objspace_flatness_squared" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float objspace_flatness_squared" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3575, + "column": 1, + "source_line": "static void stbtt__tesselate_cubic(stbtt__point *points, int *num_points, float x0, float y0, float x1, float y1, float x2, float y2, float x3, float y3, float objspace_flatness_squared, int n)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 3575, + "column": 1, + "source_line": "static void stbtt__tesselate_cubic(stbtt__point *points, int *num_points, float x0, float y0, float x1, float y1, float x2, float y2, float x3, float y3, float objspace_flatness_squared, int n)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 3615, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbtt_FlattenCurves", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__point", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__point" + } + ] + }, + "parameters": [ + { + "name": "vertices", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_vertex *vertices", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbtt_vertex", + "name": "stbtt_vertex", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_vertex *vertices", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_vertex" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "num_verts", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_verts" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_verts" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "objspace_flatness", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float objspace_flatness" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float objspace_flatness" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "contour_lengths", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int **contour_lengths", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int **contour_lengths", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "num_contours", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *num_contours", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *num_contours", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "userdata", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *userdata", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *userdata", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3618, + "column": 1, + "source_line": "static stbtt__point *stbtt_FlattenCurves(stbtt_vertex *vertices, int num_verts, float objspace_flatness, int **contour_lengths, int *num_contours, void *userdata)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 3618, + "column": 1, + "source_line": "static stbtt__point *stbtt_FlattenCurves(stbtt_vertex *vertices, int num_verts, float objspace_flatness, int **contour_lengths, int *num_contours, void *userdata)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 3693, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbtt_BakeFontBitmap_internal", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "offset", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int offset" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int offset" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "pixel_height", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float pixel_height" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float pixel_height" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "pixels", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *pixels", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *pixels", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "pw", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int pw" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int pw" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ph", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ph" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ph" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "first_char", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int first_char" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int first_char" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "num_chars", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_chars" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_chars" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "chardata", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_bakedchar *chardata", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbtt_bakedchar", + "name": "stbtt_bakedchar", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_bakedchar *chardata", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_bakedchar" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3813, + "column": 1, + "source_line": "static int stbtt_BakeFontBitmap_internal(unsigned char *data, int offset, // font location (use offset=0 for plain .ttf)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 3813, + "column": 1, + "source_line": "static int stbtt_BakeFontBitmap_internal(unsigned char *data, int offset, // font location (use offset=0 for plain .ttf)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 3857, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbrp_init_target", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "con", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbrp_context *con", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbrp_context", + "name": "stbrp_context", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "width", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int width" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3902, + "column": 4, + "source_line": " int width,height;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "height", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int height" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3902, + "column": 4, + "source_line": " int width,height;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3903, + "column": 4, + "source_line": " int x,y,bottom_y;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3903, + "column": 4, + "source_line": " int x,y,bottom_y;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "bottom_y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int bottom_y" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3903, + "column": 4, + "source_line": " int x,y,bottom_y;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_truetype.h:3900:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3900, + "column": 1, + "source_line": "typedef struct" + } + }, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3900, + "column": 1, + "source_line": "typedef struct" + }, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbrp_context *con", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbrp_context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "pw", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int pw" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int pw" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ph", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ph" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ph" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "nodes", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbrp_node *nodes", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbrp_node", + "name": "stbrp_node", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "x", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char x" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3908, + "column": 4, + "source_line": " unsigned char x;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_truetype.h:3906:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3906, + "column": 1, + "source_line": "typedef struct" + } + }, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3906, + "column": 1, + "source_line": "typedef struct" + }, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbrp_node *nodes", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbrp_node" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "num_nodes", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_nodes" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_nodes" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3917, + "column": 1, + "source_line": "static void stbrp_init_target(stbrp_context *con, int pw, int ph, stbrp_node *nodes, int num_nodes)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 3917, + "column": 1, + "source_line": "static void stbrp_init_target(stbrp_context *con, int pw, int ph, stbrp_node *nodes, int num_nodes)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 3926, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbrp_pack_rects", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "con", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbrp_context *con", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbrp_context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbrp_context *con", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbrp_context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "rects", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbrp_rect *rects", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbrp_rect", + "name": "stbrp_rect", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbrp_rect *rects", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbrp_rect" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "num_rects", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_rects" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_rects" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3928, + "column": 1, + "source_line": "static void stbrp_pack_rects(stbrp_context *con, stbrp_rect *rects, int num_rects)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 3928, + "column": 1, + "source_line": "static void stbrp_pack_rects(stbrp_context *con, stbrp_rect *rects, int num_rects)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 3947, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbtt__h_prefilter", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "pixels", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *pixels", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *pixels", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "w", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "h", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "stride_in_bytes", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int stride_in_bytes" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int stride_in_bytes" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "kernel_width", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int kernel_width" + }, + "declared_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int kernel_width" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 4012, + "column": 1, + "source_line": "static void stbtt__h_prefilter(unsigned char *pixels, int w, int h, int stride_in_bytes, unsigned int kernel_width)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 4012, + "column": 1, + "source_line": "static void stbtt__h_prefilter(unsigned char *pixels, int w, int h, int stride_in_bytes, unsigned int kernel_width)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 4072, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbtt__v_prefilter", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "pixels", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *pixels", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *pixels", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "w", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "h", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "stride_in_bytes", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int stride_in_bytes" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int stride_in_bytes" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "kernel_width", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int kernel_width" + }, + "declared_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int kernel_width" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 4074, + "column": 1, + "source_line": "static void stbtt__v_prefilter(unsigned char *pixels, int w, int h, int stride_in_bytes, unsigned int kernel_width)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 4074, + "column": 1, + "source_line": "static void stbtt__v_prefilter(unsigned char *pixels, int w, int h, int stride_in_bytes, unsigned int kernel_width)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 4134, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbtt__oversample_shift", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "oversample", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int oversample" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int oversample" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 4136, + "column": 1, + "source_line": "static float stbtt__oversample_shift(int oversample)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 4136, + "column": 1, + "source_line": "static float stbtt__oversample_shift(int oversample)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 4146, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbtt__ray_intersect_bezier", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "orig", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float orig[2]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float orig[2]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "2", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ray", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float ray[2]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float ray[2]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "2", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "q0", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float q0[2]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float q0[2]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "2", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "q1", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float q1[2]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float q1[2]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "2", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "q2", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float q2[2]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float q2[2]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "2", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "hits", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float hits[2][2]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "2", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float hits[2][2]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "2", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "2", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 4398, + "column": 1, + "source_line": "static int stbtt__ray_intersect_bezier(float orig[2], float ray[2], float q0[2], float q1[2], float q2[2], float hits[2][2])" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 4398, + "column": 1, + "source_line": "static int stbtt__ray_intersect_bezier(float orig[2], float ray[2], float q0[2], float q1[2], float q2[2], float hits[2][2])" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 4460, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "equal", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *b", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *b", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 4462, + "column": 1, + "source_line": "static int equal(float *a, float *b)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 4462, + "column": 1, + "source_line": "static int equal(float *a, float *b)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 4465, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbtt__compute_crossings_x", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "nverts", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int nverts" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int nverts" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "verts", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_vertex *verts", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbtt_vertex", + "name": "stbtt_vertex", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_vertex *verts", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_vertex" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 4467, + "column": 1, + "source_line": "static int stbtt__compute_crossings_x(float x, float y, int nverts, stbtt_vertex *verts)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 4467, + "column": 1, + "source_line": "static int stbtt__compute_crossings_x(float x, float y, int nverts, stbtt_vertex *verts)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 4533, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbtt__cuberoot", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 4535, + "column": 1, + "source_line": "static float stbtt__cuberoot( float x )" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 4535, + "column": 1, + "source_line": "static float stbtt__cuberoot( float x )" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 4541, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbtt__solve_cubic", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float a" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float a" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float b" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float b" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float c" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float c" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "r", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 4544, + "column": 1, + "source_line": "static int stbtt__solve_cubic(float a, float b, float c, float* r)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 4544, + "column": 1, + "source_line": "static int stbtt__solve_cubic(float a, float b, float c, float* r)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 4573, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbtt__CompareUTF8toUTF16_bigendian_prefix", + "result_type": { + "reference": "stbtt_int32" + }, + "parameters": [ + { + "name": "s1", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_uint8 *s1", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_uint8" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_uint8 *s1", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_uint8" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len1", + "type": { + "reference": "stbtt_int32" + }, + "declared_type": { + "reference": "stbtt_int32" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "s2", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_uint8 *s2", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_uint8" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_uint8 *s2", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_uint8" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len2", + "type": { + "reference": "stbtt_int32" + }, + "declared_type": { + "reference": "stbtt_int32" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 4778, + "column": 1, + "source_line": "static stbtt_int32 stbtt__CompareUTF8toUTF16_bigendian_prefix(stbtt_uint8 *s1, stbtt_int32 len1, stbtt_uint8 *s2, stbtt_int32 len2)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 4778, + "column": 1, + "source_line": "static stbtt_int32 stbtt__CompareUTF8toUTF16_bigendian_prefix(stbtt_uint8 *s1, stbtt_int32 len1, stbtt_uint8 *s2, stbtt_int32 len2)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 4815, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbtt_CompareUTF8toUTF16_bigendian_internal", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s1", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *s1", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *s1", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "s2", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *s2", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *s2", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len2", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len2" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len2" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 4817, + "column": 1, + "source_line": "static int stbtt_CompareUTF8toUTF16_bigendian_internal(char *s1, int len1, char *s2, int len2)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 4817, + "column": 1, + "source_line": "static int stbtt_CompareUTF8toUTF16_bigendian_internal(char *s1, int len1, char *s2, int len2)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 4820, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbtt__matchpair", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "fc", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_uint8 *fc", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_uint8" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_uint8 *fc", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_uint8" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "nm", + "type": { + "reference": "stbtt_uint32" + }, + "declared_type": { + "reference": "stbtt_uint32" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "name", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_uint8 *name", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_uint8" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_uint8 *name", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_uint8" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "nlen", + "type": { + "reference": "stbtt_int32" + }, + "declared_type": { + "reference": "stbtt_int32" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "target_id", + "type": { + "reference": "stbtt_int32" + }, + "declared_type": { + "reference": "stbtt_int32" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "next_id", + "type": { + "reference": "stbtt_int32" + }, + "declared_type": { + "reference": "stbtt_int32" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 4845, + "column": 1, + "source_line": "static int stbtt__matchpair(stbtt_uint8 *fc, stbtt_uint32 nm, stbtt_uint8 *name, stbtt_int32 nlen, stbtt_int32 target_id, stbtt_int32 next_id)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 4845, + "column": 1, + "source_line": "static int stbtt__matchpair(stbtt_uint8 *fc, stbtt_uint32 nm, stbtt_uint8 *name, stbtt_int32 nlen, stbtt_int32 target_id, stbtt_int32 next_id)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 4890, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbtt__matches", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "fc", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_uint8 *fc", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_uint8" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_uint8 *fc", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_uint8" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "offset", + "type": { + "reference": "stbtt_uint32" + }, + "declared_type": { + "reference": "stbtt_uint32" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "name", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_uint8 *name", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_uint8" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_uint8 *name", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_uint8" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "flags", + "type": { + "reference": "stbtt_int32" + }, + "declared_type": { + "reference": "stbtt_int32" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 4892, + "column": 1, + "source_line": "static int stbtt__matches(stbtt_uint8 *fc, stbtt_uint32 offset, stbtt_uint8 *name, stbtt_int32 flags)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 4892, + "column": 1, + "source_line": "static int stbtt__matches(stbtt_uint8 *fc, stbtt_uint32 offset, stbtt_uint8 *name, stbtt_int32 flags)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 4919, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbtt_FindMatchingFont_internal", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "font_collection", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *font_collection", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *font_collection", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "name_utf8", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *name_utf8", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *name_utf8", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "flags", + "type": { + "reference": "stbtt_int32" + }, + "declared_type": { + "reference": "stbtt_int32" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 4921, + "column": 1, + "source_line": "static int stbtt_FindMatchingFont_internal(unsigned char *font_collection, char *name_utf8, stbtt_int32 flags)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 4921, + "column": 1, + "source_line": "static int stbtt_FindMatchingFont_internal(unsigned char *font_collection, char *name_utf8, stbtt_int32 flags)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 4930, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + } + ], + "structs": [ + { + "reference": "struct@stb/stb_truetype.h:1897:1" + }, + { + "reference": "struct stbtt__hheap_chunk" + }, + { + "reference": "struct stbtt__hheap" + }, + { + "reference": "struct stbtt__edge" + }, + { + "reference": "struct stbtt__active_edge" + }, + { + "reference": "struct@stb/stb_truetype.h:3485:1" + }, + { + "reference": "struct@stb/stb_truetype.h:3900:1" + }, + { + "reference": "struct@stb/stb_truetype.h:3906:1" + }, + { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": "stbrp_rect", + "members": [ + { + "name": "x", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbrp_coord", + "name": "stbrp_coord", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "typedef int stbrp_coord" + }, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3887, + "column": 1, + "source_line": "typedef int stbrp_coord;" + }, + "declaration_locations": [] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3913, + "column": 4, + "source_line": " stbrp_coord x,y;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "y", + "type": { + "reference": "stbrp_coord" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3913, + "column": 4, + "source_line": " stbrp_coord x,y;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "id", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int id" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3914, + "column": 4, + "source_line": " int id,w,h,was_packed;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "w", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3914, + "column": 4, + "source_line": " int id,w,h,was_packed;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "h", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3914, + "column": 4, + "source_line": " int id,w,h,was_packed;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "was_packed", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int was_packed" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3914, + "column": 4, + "source_line": " int id,w,h,was_packed;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": null, + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3911, + "column": 1, + "source_line": "struct stbrp_rect" + } + } + ], + "unions": [], + "enums": [], + "typedefs": [ + { + "reference": "stbtt_uint8" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbtt_int8", + "name": "stbtt_int8", + "type": { + "model": "CSignedChar", + "qualifiers": [], + "source_text": "typedef signed char stbtt_int8" + }, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 429, + "column": 4, + "source_line": " typedef signed char stbtt_int8;" + }, + "declaration_locations": [] + }, + { + "reference": "stbtt_uint16" + }, + { + "reference": "stbtt_int16" + }, + { + "reference": "stbtt_uint32" + }, + { + "reference": "stbtt_int32" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbtt__check_size32", + "name": "stbtt__check_size32", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "typedef char stbtt__check_size32[sizeof(stbtt_int32)==4 ? 1 : -1]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "sizeof(stbtt_int32)==4 ? 1 : -1", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 436, + "column": 4, + "source_line": " typedef char stbtt__check_size32[sizeof(stbtt_int32)==4 ? 1 : -1];" + }, + "declaration_locations": [] + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbtt__check_size16", + "name": "stbtt__check_size16", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "typedef char stbtt__check_size16[sizeof(stbtt_int16)==2 ? 1 : -1]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "sizeof(stbtt_int16)==2 ? 1 : -1", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 437, + "column": 4, + "source_line": " typedef char stbtt__check_size16[sizeof(stbtt_int16)==2 ? 1 : -1];" + }, + "declaration_locations": [] + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbtt__test_oversample_pow2", + "name": "stbtt__test_oversample_pow2", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "typedef int stbtt__test_oversample_pow2[(STBTT_MAX_OVERSAMPLE & (STBTT_MAX_OVERSAMPLE-1)) == 0 ? 1 : -1]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "(STBTT_MAX_OVERSAMPLE & (STBTT_MAX_OVERSAMPLE-1)) == 0 ? 1 : -1", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1116, + "column": 1, + "source_line": "typedef int stbtt__test_oversample_pow2[(STBTT_MAX_OVERSAMPLE & (STBTT_MAX_OVERSAMPLE-1)) == 0 ? 1 : -1];" + }, + "declaration_locations": [] + }, + { + "reference": "stbtt__csctx" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbtt__hheap_chunk", + "name": "stbtt__hheap_chunk", + "type": { + "reference": "struct stbtt__hheap_chunk" + }, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2758, + "column": 1, + "source_line": "typedef struct stbtt__hheap_chunk" + }, + "declaration_locations": [] + }, + { + "reference": "stbtt__hheap" + }, + { + "reference": "stbtt__edge" + }, + { + "reference": "stbtt__active_edge" + }, + { + "reference": "stbtt__point" + }, + { + "reference": "stbrp_coord" + }, + { + "reference": "stbrp_context" + }, + { + "reference": "stbrp_node" + } + ], + "variables": [ + { + "name": "ttf_buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char ttf_buffer[1<<20]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "1<<20", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 281, + "column": 1, + "source_line": "unsigned char ttf_buffer[1<<20];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "temp_bitmap", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char temp_bitmap[512*512]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "512*512", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 282, + "column": 1, + "source_line": "unsigned char temp_bitmap[512*512];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "cdata", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_bakedchar cdata[96]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "96", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbtt_bakedchar", + "name": "stbtt_bakedchar", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 284, + "column": 1, + "source_line": "stbtt_bakedchar cdata[96]; // ASCII 32..126 is 95 glyphs" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "ftex", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "GLuint ftex", + "name": "GLuint", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 285, + "column": 1, + "source_line": "GLuint ftex;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char buffer[24<<20]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "24<<20", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 372, + "column": 1, + "source_line": "char buffer[24<<20];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "screen", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char screen[20][79]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "20", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "79", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 373, + "column": 1, + "source_line": "unsigned char screen[20][79];" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "macros": [ + { + "name": "STB_TRUETYPE_IMPLEMENTATION", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 278, + "column": 1, + "source_line": "#define STB_TRUETYPE_IMPLEMENTATION // force following include to generate implementation" + } + }, + { + "name": "STB_TRUETYPE_IMPLEMENTATION", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 329, + "column": 1, + "source_line": "#define STB_TRUETYPE_IMPLEMENTATION // force following include to generate implementation" + } + }, + { + "name": "STBTT_ifloor", + "value": "((int) floor(x))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 442, + "column": 4, + "source_line": " #define STBTT_ifloor(x) ((int) floor(x))" + } + }, + { + "name": "STBTT_iceil", + "value": "((int) ceil(x))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 443, + "column": 4, + "source_line": " #define STBTT_iceil(x) ((int) ceil(x))" + } + }, + { + "name": "STBTT_sqrt", + "value": "sqrt(x)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 448, + "column": 4, + "source_line": " #define STBTT_sqrt(x) sqrt(x)" + } + }, + { + "name": "STBTT_pow", + "value": "pow(x,y)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 449, + "column": 4, + "source_line": " #define STBTT_pow(x,y) pow(x,y)" + } + }, + { + "name": "STBTT_fmod", + "value": "fmod(x,y)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 454, + "column": 4, + "source_line": " #define STBTT_fmod(x,y) fmod(x,y)" + } + }, + { + "name": "STBTT_cos", + "value": "cos(x)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 459, + "column": 4, + "source_line": " #define STBTT_cos(x) cos(x)" + } + }, + { + "name": "STBTT_acos", + "value": "acos(x)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 460, + "column": 4, + "source_line": " #define STBTT_acos(x) acos(x)" + } + }, + { + "name": "STBTT_fabs", + "value": "fabs(x)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 465, + "column": 4, + "source_line": " #define STBTT_fabs(x) fabs(x)" + } + }, + { + "name": "STBTT_malloc", + "value": "((void)(u),malloc(x))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 471, + "column": 4, + "source_line": " #define STBTT_malloc(x,u) ((void)(u),malloc(x))" + } + }, + { + "name": "STBTT_free", + "value": "((void)(u),free(x))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 472, + "column": 4, + "source_line": " #define STBTT_free(x,u) ((void)(u),free(x))" + } + }, + { + "name": "STBTT_assert", + "value": "assert(x)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 477, + "column": 4, + "source_line": " #define STBTT_assert(x) assert(x)" + } + }, + { + "name": "STBTT_strlen", + "value": "strlen(x)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 482, + "column": 4, + "source_line": " #define STBTT_strlen(x) strlen(x)" + } + }, + { + "name": "STBTT_memcpy", + "value": "memcpy", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 487, + "column": 4, + "source_line": " #define STBTT_memcpy memcpy" + } + }, + { + "name": "STBTT_memset", + "value": "memset", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 488, + "column": 4, + "source_line": " #define STBTT_memset memset" + } + }, + { + "name": "__STB_INCLUDE_STB_TRUETYPE_H__", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 500, + "column": 1, + "source_line": "#define __STB_INCLUDE_STB_TRUETYPE_H__" + } + }, + { + "name": "STBTT_DEF", + "value": "static", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 503, + "column": 1, + "source_line": "#define STBTT_DEF static" + } + }, + { + "name": "STBTT_DEF", + "value": "extern", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 505, + "column": 1, + "source_line": "#define STBTT_DEF extern" + } + }, + { + "name": "STBTT_POINT_SIZE", + "value": "(-(x))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 602, + "column": 1, + "source_line": "#define STBTT_POINT_SIZE(x) (-(x))" + } + }, + { + "name": "stbtt_vertex_type", + "value": "short", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 834, + "column": 4, + "source_line": " #define stbtt_vertex_type short // can't use stbtt_int16 because that's not visible in the header file" + } + }, + { + "name": "STBTT_MACSTYLE_DONTCARE", + "value": "0", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1026, + "column": 1, + "source_line": "#define STBTT_MACSTYLE_DONTCARE 0" + } + }, + { + "name": "STBTT_MACSTYLE_BOLD", + "value": "1", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1027, + "column": 1, + "source_line": "#define STBTT_MACSTYLE_BOLD 1" + } + }, + { + "name": "STBTT_MACSTYLE_ITALIC", + "value": "2", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1028, + "column": 1, + "source_line": "#define STBTT_MACSTYLE_ITALIC 2" + } + }, + { + "name": "STBTT_MACSTYLE_UNDERSCORE", + "value": "4", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1029, + "column": 1, + "source_line": "#define STBTT_MACSTYLE_UNDERSCORE 4" + } + }, + { + "name": "STBTT_MACSTYLE_NONE", + "value": "8", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1030, + "column": 1, + "source_line": "#define STBTT_MACSTYLE_NONE 8 // <= not same as 0, this makes us check the bitfield is 0" + } + }, + { + "name": "STBTT_MAX_OVERSAMPLE", + "value": "8", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1109, + "column": 1, + "source_line": "#define STBTT_MAX_OVERSAMPLE 8" + } + }, + { + "name": "STBTT_RASTERIZER_VERSION", + "value": "2", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1119, + "column": 1, + "source_line": "#define STBTT_RASTERIZER_VERSION 2" + } + }, + { + "name": "STBTT__NOTUSED", + "value": "(void)(v)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1123, + "column": 1, + "source_line": "#define STBTT__NOTUSED(v) (void)(v)" + } + }, + { + "name": "STBTT__NOTUSED", + "value": "(void)sizeof(v)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1125, + "column": 1, + "source_line": "#define STBTT__NOTUSED(v) (void)sizeof(v)" + } + }, + { + "name": "stbtt__buf_get16", + "value": "stbtt__buf_get((b), 2)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1178, + "column": 1, + "source_line": "#define stbtt__buf_get16(b) stbtt__buf_get((b), 2)" + } + }, + { + "name": "stbtt__buf_get32", + "value": "stbtt__buf_get((b), 4)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1179, + "column": 1, + "source_line": "#define stbtt__buf_get32(b) stbtt__buf_get((b), 4)" + } + }, + { + "name": "ttBYTE", + "value": "(* (stbtt_uint8 *) (p))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1282, + "column": 1, + "source_line": "#define ttBYTE(p) (* (stbtt_uint8 *) (p))" + } + }, + { + "name": "ttCHAR", + "value": "(* (stbtt_int8 *) (p))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1283, + "column": 1, + "source_line": "#define ttCHAR(p) (* (stbtt_int8 *) (p))" + } + }, + { + "name": "ttFixed", + "value": "ttLONG(p)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1284, + "column": 1, + "source_line": "#define ttFixed(p) ttLONG(p)" + } + }, + { + "name": "stbtt_tag4", + "value": "((p)[0] == (c0) && (p)[1] == (c1) && (p)[2] == (c2) && (p)[3] == (c3))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1291, + "column": 1, + "source_line": "#define stbtt_tag4(p,c0,c1,c2,c3) ((p)[0] == (c0) && (p)[1] == (c1) && (p)[2] == (c2) && (p)[3] == (c3))" + } + }, + { + "name": "stbtt_tag", + "value": "stbtt_tag4(p,str[0],str[1],str[2],str[3])", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1292, + "column": 1, + "source_line": "#define stbtt_tag(p,str) stbtt_tag4(p,str[0],str[1],str[2],str[3])" + } + }, + { + "name": "STBTT__CSCTX_INIT", + "value": "{bounds,0, 0,0, 0,0, 0,0,0,0, NULL, 0}", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1909, + "column": 1, + "source_line": "#define STBTT__CSCTX_INIT(bounds) {bounds,0, 0,0, 0,0, 0,0,0,0, NULL, 0}" + } + }, + { + "name": "STBTT__CSERR", + "value": "(0)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2018, + "column": 1, + "source_line": "#define STBTT__CSERR(s) (0)" + } + }, + { + "name": "STBTT__CSERR", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2266, + "column": 1, + "source_line": "#undef STBTT__CSERR" + } + }, + { + "name": "STBTT_GPOS_TODO_assert", + "value": null, + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2494, + "column": 1, + "source_line": "#define STBTT_GPOS_TODO_assert(x)" + } + }, + { + "name": "STBTT_FIXSHIFT", + "value": "10", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2831, + "column": 1, + "source_line": "#define STBTT_FIXSHIFT 10" + } + }, + { + "name": "STBTT_FIX", + "value": "(1 << STBTT_FIXSHIFT)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2832, + "column": 1, + "source_line": "#define STBTT_FIX (1 << STBTT_FIXSHIFT)" + } + }, + { + "name": "STBTT_FIXMASK", + "value": "(STBTT_FIX-1)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2833, + "column": 1, + "source_line": "#define STBTT_FIXMASK (STBTT_FIX-1)" + } + }, + { + "name": "STBTT__COMPARE", + "value": "((a)->y0 < (b)->y0)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3397, + "column": 1, + "source_line": "#define STBTT__COMPARE(a,b) ((a)->y0 < (b)->y0)" + } + }, + { + "name": "STBTT__OVER_MASK", + "value": "(STBTT_MAX_OVERSAMPLE-1)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 4010, + "column": 1, + "source_line": "#define STBTT__OVER_MASK (STBTT_MAX_OVERSAMPLE-1)" + } + }, + { + "name": "STBTT_min", + "value": "((a) < (b) ? (a) : (b))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 4395, + "column": 1, + "source_line": "#define STBTT_min(a,b) ((a) < (b) ? (a) : (b))" + } + }, + { + "name": "STBTT_max", + "value": "((a) < (b) ? (b) : (a))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 4396, + "column": 1, + "source_line": "#define STBTT_max(a,b) ((a) < (b) ? (b) : (a))" + } + } + ], + "includes": [ + { + "target": "stb_truetype.h", + "kind": "local", + "resolved_path": "stb/stb_truetype.h", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 279, + "column": 1, + "source_line": "#include \"stb_truetype.h\"" + } + }, + { + "target": "stdio.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 328, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "stb_truetype.h", + "kind": "local", + "resolved_path": "stb/stb_truetype.h", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 330, + "column": 1, + "source_line": "#include \"stb_truetype.h\"" + } + }, + { + "target": "math.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 441, + "column": 4, + "source_line": " #include " + } + }, + { + "target": "math.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 447, + "column": 4, + "source_line": " #include " + } + }, + { + "target": "math.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 453, + "column": 4, + "source_line": " #include " + } + }, + { + "target": "math.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 458, + "column": 4, + "source_line": " #include " + } + }, + { + "target": "math.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 464, + "column": 4, + "source_line": " #include " + } + }, + { + "target": "stdlib.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 470, + "column": 4, + "source_line": " #include " + } + }, + { + "target": "assert.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 476, + "column": 4, + "source_line": " #include " + } + }, + { + "target": "string.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 481, + "column": 4, + "source_line": " #include " + } + }, + { + "target": "string.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 486, + "column": 4, + "source_line": " #include " + } + } + ], + "raw_directives": [ + { + "directive": "if", + "argument": "0", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 277, + "column": 1, + "source_line": "#if 0" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 320, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "0", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 327, + "column": 1, + "source_line": "#if 0" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 352, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "0", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 371, + "column": 1, + "source_line": "#if 0" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 413, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STB_TRUETYPE_IMPLEMENTATION", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 425, + "column": 1, + "source_line": "#ifdef STB_TRUETYPE_IMPLEMENTATION" + } + }, + { + "directive": "ifndef", + "argument": "stbtt_uint8", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 427, + "column": 4, + "source_line": " #ifndef stbtt_uint8" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 434, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STBTT_ifloor", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 440, + "column": 4, + "source_line": " #ifndef STBTT_ifloor" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 444, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STBTT_sqrt", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 446, + "column": 4, + "source_line": " #ifndef STBTT_sqrt" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 450, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STBTT_fmod", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 452, + "column": 4, + "source_line": " #ifndef STBTT_fmod" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 455, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STBTT_cos", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 457, + "column": 4, + "source_line": " #ifndef STBTT_cos" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 461, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STBTT_fabs", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 463, + "column": 4, + "source_line": " #ifndef STBTT_fabs" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 466, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STBTT_malloc", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 469, + "column": 4, + "source_line": " #ifndef STBTT_malloc" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 473, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STBTT_assert", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 475, + "column": 4, + "source_line": " #ifndef STBTT_assert" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 478, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STBTT_strlen", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 480, + "column": 4, + "source_line": " #ifndef STBTT_strlen" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 483, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STBTT_memcpy", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 485, + "column": 4, + "source_line": " #ifndef STBTT_memcpy" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 489, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 490, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "__STB_INCLUDE_STB_TRUETYPE_H__", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 499, + "column": 1, + "source_line": "#ifndef __STB_INCLUDE_STB_TRUETYPE_H__" + } + }, + { + "directive": "ifdef", + "argument": "STBTT_STATIC", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 502, + "column": 1, + "source_line": "#ifdef STBTT_STATIC" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 504, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 506, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "__cplusplus", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 508, + "column": 1, + "source_line": "#ifdef __cplusplus" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 510, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_RECT_PACK_VERSION", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 584, + "column": 1, + "source_line": "#ifndef STB_RECT_PACK_VERSION" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 586, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBTT_vmove", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 823, + "column": 1, + "source_line": "#ifndef STBTT_vmove // you can predefine these to use different values (but why?)" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 830, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "stbtt_vertex", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 832, + "column": 1, + "source_line": "#ifndef stbtt_vertex // you can predefine this to use different values" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 840, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "__cplusplus", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1093, + "column": 1, + "source_line": "#ifdef __cplusplus" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1095, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1097, + "column": 1, + "source_line": "#endif // __STB_INCLUDE_STB_TRUETYPE_H__" + } + }, + { + "directive": "ifdef", + "argument": "STB_TRUETYPE_IMPLEMENTATION", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1106, + "column": 1, + "source_line": "#ifdef STB_TRUETYPE_IMPLEMENTATION" + } + }, + { + "directive": "ifndef", + "argument": "STBTT_MAX_OVERSAMPLE", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1108, + "column": 1, + "source_line": "#ifndef STBTT_MAX_OVERSAMPLE" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1110, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "STBTT_MAX_OVERSAMPLE > 255", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1112, + "column": 1, + "source_line": "#if STBTT_MAX_OVERSAMPLE > 255" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1114, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBTT_RASTERIZER_VERSION", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1118, + "column": 1, + "source_line": "#ifndef STBTT_RASTERIZER_VERSION" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1120, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "_MSC_VER", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1122, + "column": 1, + "source_line": "#ifdef _MSC_VER" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1124, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1126, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "STBTT_RASTERIZER_VERSION==1", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2816, + "column": 4, + "source_line": " #if STBTT_RASTERIZER_VERSION==1" + } + }, + { + "directive": "elif", + "argument": "STBTT_RASTERIZER_VERSION==2", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2820, + "column": 4, + "source_line": " #elif STBTT_RASTERIZER_VERSION==2" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2825, + "column": 4, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2827, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "STBTT_RASTERIZER_VERSION == 1", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2830, + "column": 1, + "source_line": "#if STBTT_RASTERIZER_VERSION == 1" + } + }, + { + "directive": "elif", + "argument": "STBTT_RASTERIZER_VERSION == 2", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2856, + "column": 1, + "source_line": "#elif STBTT_RASTERIZER_VERSION == 2" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2874, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2876, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "STBTT_RASTERIZER_VERSION == 1", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2878, + "column": 1, + "source_line": "#if STBTT_RASTERIZER_VERSION == 1" + } + }, + { + "directive": "elif", + "argument": "STBTT_RASTERIZER_VERSION == 2", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3024, + "column": 1, + "source_line": "#elif STBTT_RASTERIZER_VERSION == 2" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3393, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3395, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "STBTT_RASTERIZER_VERSION == 1", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3495, + "column": 1, + "source_line": "#if STBTT_RASTERIZER_VERSION == 1" + } + }, + { + "directive": "elif", + "argument": "STBTT_RASTERIZER_VERSION == 2", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3497, + "column": 1, + "source_line": "#elif STBTT_RASTERIZER_VERSION == 2" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3499, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3501, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_RECT_PACK_VERSION", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3885, + "column": 1, + "source_line": "#ifndef STB_RECT_PACK_VERSION" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3948, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "defined(__GNUC__) || defined(__clang__)", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 4932, + "column": 1, + "source_line": "#if defined(__GNUC__) || defined(__clang__)" + } + }, + { + "directive": "pragma", + "argument": "GCC diagnostic push", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 4933, + "column": 1, + "source_line": "#pragma GCC diagnostic push" + } + }, + { + "directive": "pragma", + "argument": "GCC diagnostic ignored \"-Wcast-qual\"", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 4934, + "column": 1, + "source_line": "#pragma GCC diagnostic ignored \"-Wcast-qual\"" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 4935, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "defined(__GNUC__) || defined(__clang__)", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 4969, + "column": 1, + "source_line": "#if defined(__GNUC__) || defined(__clang__)" + } + }, + { + "directive": "pragma", + "argument": "GCC diagnostic pop", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 4970, + "column": 1, + "source_line": "#pragma GCC diagnostic pop" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 4971, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 4973, + "column": 1, + "source_line": "#endif // STB_TRUETYPE_IMPLEMENTATION" + } + } + ], + "macro_dependencies": [ + { + "name": "STBTT_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1496, + "column": 1, + "source_line": "STBTT_DEF int stbtt_FindGlyphIndex(const stbtt_fontinfo *info, int unicode_codepoint)" + }, + "source_text": "STBTT_DEF int stbtt_FindGlyphIndex(const stbtt_fontinfo *info, int unicode_codepoint)" + }, + { + "name": "STBTT_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1589, + "column": 1, + "source_line": "STBTT_DEF int stbtt_GetCodepointShape(const stbtt_fontinfo *info, int unicode_codepoint, stbtt_vertex **vertices)" + }, + "source_text": "STBTT_DEF int stbtt_GetCodepointShape(const stbtt_fontinfo *info, int unicode_codepoint, stbtt_vertex **vertices)" + }, + { + "name": "STBTT_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1625, + "column": 1, + "source_line": "STBTT_DEF int stbtt_GetGlyphBox(const stbtt_fontinfo *info, int glyph_index, int *x0, int *y0, int *x1, int *y1)" + }, + "source_text": "STBTT_DEF int stbtt_GetGlyphBox(const stbtt_fontinfo *info, int glyph_index, int *x0, int *y0, int *x1, int *y1)" + }, + { + "name": "STBTT_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1641, + "column": 1, + "source_line": "STBTT_DEF int stbtt_GetCodepointBox(const stbtt_fontinfo *info, int codepoint, int *x0, int *y0, int *x1, int *y1)" + }, + "source_text": "STBTT_DEF int stbtt_GetCodepointBox(const stbtt_fontinfo *info, int codepoint, int *x0, int *y0, int *x1, int *y1)" + }, + { + "name": "STBTT_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1646, + "column": 1, + "source_line": "STBTT_DEF int stbtt_IsGlyphEmpty(const stbtt_fontinfo *info, int glyph_index)" + }, + "source_text": "STBTT_DEF int stbtt_IsGlyphEmpty(const stbtt_fontinfo *info, int glyph_index)" + }, + { + "name": "STBTT_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2297, + "column": 1, + "source_line": "STBTT_DEF int stbtt_GetGlyphShape(const stbtt_fontinfo *info, int glyph_index, stbtt_vertex **pvertices)" + }, + "source_text": "STBTT_DEF int stbtt_GetGlyphShape(const stbtt_fontinfo *info, int glyph_index, stbtt_vertex **pvertices)" + }, + { + "name": "STBTT_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2305, + "column": 1, + "source_line": "STBTT_DEF void stbtt_GetGlyphHMetrics(const stbtt_fontinfo *info, int glyph_index, int *advanceWidth, int *leftSideBearing)" + }, + "source_text": "STBTT_DEF void stbtt_GetGlyphHMetrics(const stbtt_fontinfo *info, int glyph_index, int *advanceWidth, int *leftSideBearing)" + }, + { + "name": "STBTT_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2317, + "column": 1, + "source_line": "STBTT_DEF int stbtt_GetKerningTableLength(const stbtt_fontinfo *info)" + }, + "source_text": "STBTT_DEF int stbtt_GetKerningTableLength(const stbtt_fontinfo *info)" + }, + { + "name": "STBTT_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2332, + "column": 1, + "source_line": "STBTT_DEF int stbtt_GetKerningTable(const stbtt_fontinfo *info, stbtt_kerningentry* table, int table_length)" + }, + "source_text": "STBTT_DEF int stbtt_GetKerningTable(const stbtt_fontinfo *info, stbtt_kerningentry* table, int table_length)" + }, + { + "name": "STBTT_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2610, + "column": 1, + "source_line": "STBTT_DEF int stbtt_GetGlyphKernAdvance(const stbtt_fontinfo *info, int g1, int g2)" + }, + "source_text": "STBTT_DEF int stbtt_GetGlyphKernAdvance(const stbtt_fontinfo *info, int g1, int g2)" + }, + { + "name": "STBTT_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2622, + "column": 1, + "source_line": "STBTT_DEF int stbtt_GetCodepointKernAdvance(const stbtt_fontinfo *info, int ch1, int ch2)" + }, + "source_text": "STBTT_DEF int stbtt_GetCodepointKernAdvance(const stbtt_fontinfo *info, int ch1, int ch2)" + }, + { + "name": "STBTT_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2629, + "column": 1, + "source_line": "STBTT_DEF void stbtt_GetCodepointHMetrics(const stbtt_fontinfo *info, int codepoint, int *advanceWidth, int *leftSideBearing)" + }, + "source_text": "STBTT_DEF void stbtt_GetCodepointHMetrics(const stbtt_fontinfo *info, int codepoint, int *advanceWidth, int *leftSideBearing)" + }, + { + "name": "STBTT_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2634, + "column": 1, + "source_line": "STBTT_DEF void stbtt_GetFontVMetrics(const stbtt_fontinfo *info, int *ascent, int *descent, int *lineGap)" + }, + "source_text": "STBTT_DEF void stbtt_GetFontVMetrics(const stbtt_fontinfo *info, int *ascent, int *descent, int *lineGap)" + }, + { + "name": "STBTT_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2641, + "column": 1, + "source_line": "STBTT_DEF int stbtt_GetFontVMetricsOS2(const stbtt_fontinfo *info, int *typoAscent, int *typoDescent, int *typoLineGap)" + }, + "source_text": "STBTT_DEF int stbtt_GetFontVMetricsOS2(const stbtt_fontinfo *info, int *typoAscent, int *typoDescent, int *typoLineGap)" + }, + { + "name": "STBTT_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2652, + "column": 1, + "source_line": "STBTT_DEF void stbtt_GetFontBoundingBox(const stbtt_fontinfo *info, int *x0, int *y0, int *x1, int *y1)" + }, + "source_text": "STBTT_DEF void stbtt_GetFontBoundingBox(const stbtt_fontinfo *info, int *x0, int *y0, int *x1, int *y1)" + }, + { + "name": "STBTT_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2660, + "column": 1, + "source_line": "STBTT_DEF float stbtt_ScaleForPixelHeight(const stbtt_fontinfo *info, float height)" + }, + "source_text": "STBTT_DEF float stbtt_ScaleForPixelHeight(const stbtt_fontinfo *info, float height)" + }, + { + "name": "STBTT_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2666, + "column": 1, + "source_line": "STBTT_DEF float stbtt_ScaleForMappingEmToPixels(const stbtt_fontinfo *info, float pixels)" + }, + "source_text": "STBTT_DEF float stbtt_ScaleForMappingEmToPixels(const stbtt_fontinfo *info, float pixels)" + }, + { + "name": "STBTT_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2672, + "column": 1, + "source_line": "STBTT_DEF void stbtt_FreeShape(const stbtt_fontinfo *info, stbtt_vertex *v)" + }, + "source_text": "STBTT_DEF void stbtt_FreeShape(const stbtt_fontinfo *info, stbtt_vertex *v)" + }, + { + "name": "STBTT_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2677, + "column": 1, + "source_line": "STBTT_DEF stbtt_uint8 *stbtt_FindSVGDoc(const stbtt_fontinfo *info, int gl)" + }, + "source_text": "STBTT_DEF stbtt_uint8 *stbtt_FindSVGDoc(const stbtt_fontinfo *info, int gl)" + }, + { + "name": "STBTT_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2694, + "column": 1, + "source_line": "STBTT_DEF int stbtt_GetGlyphSVG(const stbtt_fontinfo *info, int gl, const char **svg)" + }, + "source_text": "STBTT_DEF int stbtt_GetGlyphSVG(const stbtt_fontinfo *info, int gl, const char **svg)" + }, + { + "name": "STBTT_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2711, + "column": 1, + "source_line": "STBTT_DEF int stbtt_GetCodepointSVG(const stbtt_fontinfo *info, int unicode_codepoint, const char **svg)" + }, + "source_text": "STBTT_DEF int stbtt_GetCodepointSVG(const stbtt_fontinfo *info, int unicode_codepoint, const char **svg)" + }, + { + "name": "STBTT_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2721, + "column": 1, + "source_line": "STBTT_DEF void stbtt_GetGlyphBitmapBoxSubpixel(const stbtt_fontinfo *font, int glyph, float scale_x, float scale_y,float shift_x, float shift_y, int *ix0, int *iy0, int *ix1, int *iy1)" + }, + "source_text": "STBTT_DEF void stbtt_GetGlyphBitmapBoxSubpixel(const stbtt_fontinfo *font, int glyph, float scale_x, float scale_y,float shift_x, float shift_y, int *ix0, int *iy0, int *ix1, int *iy1)" + }, + { + "name": "STBTT_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2739, + "column": 1, + "source_line": "STBTT_DEF void stbtt_GetGlyphBitmapBox(const stbtt_fontinfo *font, int glyph, float scale_x, float scale_y, int *ix0, int *iy0, int *ix1, int *iy1)" + }, + "source_text": "STBTT_DEF void stbtt_GetGlyphBitmapBox(const stbtt_fontinfo *font, int glyph, float scale_x, float scale_y, int *ix0, int *iy0, int *ix1, int *iy1)" + }, + { + "name": "STBTT_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2744, + "column": 1, + "source_line": "STBTT_DEF void stbtt_GetCodepointBitmapBoxSubpixel(const stbtt_fontinfo *font, int codepoint, float scale_x, float scale_y, float shift_x, float shift_y, int *ix0, int *iy0, int *ix1, int *iy1)" + }, + "source_text": "STBTT_DEF void stbtt_GetCodepointBitmapBoxSubpixel(const stbtt_fontinfo *font, int codepoint, float scale_x, float scale_y, float shift_x, float shift_y, int *ix0, int *iy0, int *ix1, int *iy1)" + }, + { + "name": "STBTT_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2749, + "column": 1, + "source_line": "STBTT_DEF void stbtt_GetCodepointBitmapBox(const stbtt_fontinfo *font, int codepoint, float scale_x, float scale_y, int *ix0, int *iy0, int *ix1, int *iy1)" + }, + "source_text": "STBTT_DEF void stbtt_GetCodepointBitmapBox(const stbtt_fontinfo *font, int codepoint, float scale_x, float scale_y, int *ix0, int *iy0, int *ix1, int *iy1)" + }, + { + "name": "STBTT_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3695, + "column": 1, + "source_line": "STBTT_DEF void stbtt_Rasterize(stbtt__bitmap *result, float flatness_in_pixels, stbtt_vertex *vertices, int num_verts, float scale_x, float scale_y, float shift_x, float shift_y, int x_off, int y_off, int invert, void *userdata)" + }, + "source_text": "STBTT_DEF void stbtt_Rasterize(stbtt__bitmap *result, float flatness_in_pixels, stbtt_vertex *vertices, int num_verts, float scale_x, float scale_y, float shift_x, float shift_y, int x_off, int y_off, int invert, void *userdata)" + }, + { + "name": "STBTT_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3708, + "column": 1, + "source_line": "STBTT_DEF void stbtt_FreeBitmap(unsigned char *bitmap, void *userdata)" + }, + "source_text": "STBTT_DEF void stbtt_FreeBitmap(unsigned char *bitmap, void *userdata)" + }, + { + "name": "STBTT_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3713, + "column": 1, + "source_line": "STBTT_DEF unsigned char *stbtt_GetGlyphBitmapSubpixel(const stbtt_fontinfo *info, float scale_x, float scale_y, float shift_x, float shift_y, int glyph, int *width, int *height, int *xoff, int *yoff)" + }, + "source_text": "STBTT_DEF unsigned char *stbtt_GetGlyphBitmapSubpixel(const stbtt_fontinfo *info, float scale_x, float scale_y, float shift_x, float shift_y, int glyph, int *width, int *height, int *xoff, int *yoff)" + }, + { + "name": "STBTT_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3753, + "column": 1, + "source_line": "STBTT_DEF unsigned char *stbtt_GetGlyphBitmap(const stbtt_fontinfo *info, float scale_x, float scale_y, int glyph, int *width, int *height, int *xoff, int *yoff)" + }, + "source_text": "STBTT_DEF unsigned char *stbtt_GetGlyphBitmap(const stbtt_fontinfo *info, float scale_x, float scale_y, int glyph, int *width, int *height, int *xoff, int *yoff)" + }, + { + "name": "STBTT_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3758, + "column": 1, + "source_line": "STBTT_DEF void stbtt_MakeGlyphBitmapSubpixel(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int glyph)" + }, + "source_text": "STBTT_DEF void stbtt_MakeGlyphBitmapSubpixel(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int glyph)" + }, + { + "name": "STBTT_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3777, + "column": 1, + "source_line": "STBTT_DEF void stbtt_MakeGlyphBitmap(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, int glyph)" + }, + "source_text": "STBTT_DEF void stbtt_MakeGlyphBitmap(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, int glyph)" + }, + { + "name": "STBTT_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3782, + "column": 1, + "source_line": "STBTT_DEF unsigned char *stbtt_GetCodepointBitmapSubpixel(const stbtt_fontinfo *info, float scale_x, float scale_y, float shift_x, float shift_y, int codepoint, int *width, int *height, int *xoff, int *yoff)" + }, + "source_text": "STBTT_DEF unsigned char *stbtt_GetCodepointBitmapSubpixel(const stbtt_fontinfo *info, float scale_x, float scale_y, float shift_x, float shift_y, int codepoint, int *width, int *height, int *xoff, int *yoff)" + }, + { + "name": "STBTT_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3787, + "column": 1, + "source_line": "STBTT_DEF void stbtt_MakeCodepointBitmapSubpixelPrefilter(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int oversample_x, int oversample_y, float *sub_x, float *sub_y, int codepoint)" + }, + "source_text": "STBTT_DEF void stbtt_MakeCodepointBitmapSubpixelPrefilter(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int oversample_x, int oversample_y, float *sub_x, float *sub_y, int codepoint)" + }, + { + "name": "STBTT_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3792, + "column": 1, + "source_line": "STBTT_DEF void stbtt_MakeCodepointBitmapSubpixel(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int codepoint)" + }, + "source_text": "STBTT_DEF void stbtt_MakeCodepointBitmapSubpixel(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int codepoint)" + }, + { + "name": "STBTT_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3797, + "column": 1, + "source_line": "STBTT_DEF unsigned char *stbtt_GetCodepointBitmap(const stbtt_fontinfo *info, float scale_x, float scale_y, int codepoint, int *width, int *height, int *xoff, int *yoff)" + }, + "source_text": "STBTT_DEF unsigned char *stbtt_GetCodepointBitmap(const stbtt_fontinfo *info, float scale_x, float scale_y, int codepoint, int *width, int *height, int *xoff, int *yoff)" + }, + { + "name": "STBTT_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3802, + "column": 1, + "source_line": "STBTT_DEF void stbtt_MakeCodepointBitmap(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, int codepoint)" + }, + "source_text": "STBTT_DEF void stbtt_MakeCodepointBitmap(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, int codepoint)" + }, + { + "name": "STBTT_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3859, + "column": 1, + "source_line": "STBTT_DEF void stbtt_GetBakedQuad(const stbtt_bakedchar *chardata, int pw, int ph, int char_index, float *xpos, float *ypos, stbtt_aligned_quad *q, int opengl_fillrule)" + }, + "source_text": "STBTT_DEF void stbtt_GetBakedQuad(const stbtt_bakedchar *chardata, int pw, int ph, int char_index, float *xpos, float *ypos, stbtt_aligned_quad *q, int opengl_fillrule)" + }, + { + "name": "STBTT_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3957, + "column": 1, + "source_line": "STBTT_DEF int stbtt_PackBegin(stbtt_pack_context *spc, unsigned char *pixels, int pw, int ph, int stride_in_bytes, int padding, void *alloc_context)" + }, + "source_text": "STBTT_DEF int stbtt_PackBegin(stbtt_pack_context *spc, unsigned char *pixels, int pw, int ph, int stride_in_bytes, int padding, void *alloc_context)" + }, + { + "name": "STBTT_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3989, + "column": 1, + "source_line": "STBTT_DEF void stbtt_PackEnd (stbtt_pack_context *spc)" + }, + "source_text": "STBTT_DEF void stbtt_PackEnd (stbtt_pack_context *spc)" + }, + { + "name": "STBTT_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3995, + "column": 1, + "source_line": "STBTT_DEF void stbtt_PackSetOversampling(stbtt_pack_context *spc, unsigned int h_oversample, unsigned int v_oversample)" + }, + "source_text": "STBTT_DEF void stbtt_PackSetOversampling(stbtt_pack_context *spc, unsigned int h_oversample, unsigned int v_oversample)" + }, + { + "name": "STBTT_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 4005, + "column": 1, + "source_line": "STBTT_DEF void stbtt_PackSetSkipMissingCodepoints(stbtt_pack_context *spc, int skip)" + }, + "source_text": "STBTT_DEF void stbtt_PackSetSkipMissingCodepoints(stbtt_pack_context *spc, int skip)" + }, + { + "name": "STBTT_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 4149, + "column": 1, + "source_line": "STBTT_DEF int stbtt_PackFontRangesGatherRects(stbtt_pack_context *spc, const stbtt_fontinfo *info, stbtt_pack_range *ranges, int num_ranges, stbrp_rect *rects)" + }, + "source_text": "STBTT_DEF int stbtt_PackFontRangesGatherRects(stbtt_pack_context *spc, const stbtt_fontinfo *info, stbtt_pack_range *ranges, int num_ranges, stbrp_rect *rects)" + }, + { + "name": "STBTT_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 4184, + "column": 1, + "source_line": "STBTT_DEF void stbtt_MakeGlyphBitmapSubpixelPrefilter(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int prefilter_x, int prefilter_y, float *sub_x, float *sub_y, int glyph)" + }, + "source_text": "STBTT_DEF void stbtt_MakeGlyphBitmapSubpixelPrefilter(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int prefilter_x, int prefilter_y, float *sub_x, float *sub_y, int glyph)" + }, + { + "name": "STBTT_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 4208, + "column": 1, + "source_line": "STBTT_DEF int stbtt_PackFontRangesRenderIntoRects(stbtt_pack_context *spc, const stbtt_fontinfo *info, stbtt_pack_range *ranges, int num_ranges, stbrp_rect *rects)" + }, + "source_text": "STBTT_DEF int stbtt_PackFontRangesRenderIntoRects(stbtt_pack_context *spc, const stbtt_fontinfo *info, stbtt_pack_range *ranges, int num_ranges, stbrp_rect *rects)" + }, + { + "name": "STBTT_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 4297, + "column": 1, + "source_line": "STBTT_DEF void stbtt_PackFontRangesPackRects(stbtt_pack_context *spc, stbrp_rect *rects, int num_rects)" + }, + "source_text": "STBTT_DEF void stbtt_PackFontRangesPackRects(stbtt_pack_context *spc, stbrp_rect *rects, int num_rects)" + }, + { + "name": "STBTT_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 4302, + "column": 1, + "source_line": "STBTT_DEF int stbtt_PackFontRanges(stbtt_pack_context *spc, const unsigned char *fontdata, int font_index, stbtt_pack_range *ranges, int num_ranges)" + }, + "source_text": "STBTT_DEF int stbtt_PackFontRanges(stbtt_pack_context *spc, const unsigned char *fontdata, int font_index, stbtt_pack_range *ranges, int num_ranges)" + }, + { + "name": "STBTT_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 4338, + "column": 1, + "source_line": "STBTT_DEF int stbtt_PackFontRange(stbtt_pack_context *spc, const unsigned char *fontdata, int font_index, float font_size," + }, + "source_text": "STBTT_DEF int stbtt_PackFontRange(stbtt_pack_context *spc, const unsigned char *fontdata, int font_index, float font_size,\n int first_unicode_codepoint_in_range, int num_chars_in_range, stbtt_packedchar *chardata_for_range)" + }, + { + "name": "STBTT_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 4350, + "column": 1, + "source_line": "STBTT_DEF void stbtt_GetScaledFontVMetrics(const unsigned char *fontdata, int index, float size, float *ascent, float *descent, float *lineGap)" + }, + "source_text": "STBTT_DEF void stbtt_GetScaledFontVMetrics(const unsigned char *fontdata, int index, float size, float *ascent, float *descent, float *lineGap)" + }, + { + "name": "STBTT_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 4363, + "column": 1, + "source_line": "STBTT_DEF void stbtt_GetPackedQuad(const stbtt_packedchar *chardata, int pw, int ph, int char_index, float *xpos, float *ypos, stbtt_aligned_quad *q, int align_to_integer)" + }, + "source_text": "STBTT_DEF void stbtt_GetPackedQuad(const stbtt_packedchar *chardata, int pw, int ph, int char_index, float *xpos, float *ypos, stbtt_aligned_quad *q, int align_to_integer)" + }, + { + "name": "STBTT_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 4575, + "column": 1, + "source_line": "STBTT_DEF unsigned char * stbtt_GetGlyphSDF(const stbtt_fontinfo *info, float scale, int glyph, int padding, unsigned char onedge_value, float pixel_dist_scale, int *width, int *height, int *xoff, int *yoff)" + }, + "source_text": "STBTT_DEF unsigned char * stbtt_GetGlyphSDF(const stbtt_fontinfo *info, float scale, int glyph, int padding, unsigned char onedge_value, float pixel_dist_scale, int *width, int *height, int *xoff, int *yoff)" + }, + { + "name": "STBTT_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 4762, + "column": 1, + "source_line": "STBTT_DEF unsigned char * stbtt_GetCodepointSDF(const stbtt_fontinfo *info, float scale, int codepoint, int padding, unsigned char onedge_value, float pixel_dist_scale, int *width, int *height, int *xoff, int *yoff)" + }, + "source_text": "STBTT_DEF unsigned char * stbtt_GetCodepointSDF(const stbtt_fontinfo *info, float scale, int codepoint, int padding, unsigned char onedge_value, float pixel_dist_scale, int *width, int *height, int *xoff, int *yoff)" + }, + { + "name": "STBTT_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 4767, + "column": 1, + "source_line": "STBTT_DEF void stbtt_FreeSDF(unsigned char *bitmap, void *userdata)" + }, + "source_text": "STBTT_DEF void stbtt_FreeSDF(unsigned char *bitmap, void *userdata)" + }, + { + "name": "STBTT_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 4824, + "column": 1, + "source_line": "STBTT_DEF const char *stbtt_GetFontNameString(const stbtt_fontinfo *font, int *length, int platformID, int encodingID, int languageID, int nameID)" + }, + "source_text": "STBTT_DEF const char *stbtt_GetFontNameString(const stbtt_fontinfo *font, int *length, int platformID, int encodingID, int languageID, int nameID)" + }, + { + "name": "STBTT_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 4937, + "column": 1, + "source_line": "STBTT_DEF int stbtt_BakeFontBitmap(const unsigned char *data, int offset," + }, + "source_text": "STBTT_DEF int stbtt_BakeFontBitmap(const unsigned char *data, int offset,\n float pixel_height, unsigned char *pixels, int pw, int ph,\n int first_char, int num_chars, stbtt_bakedchar *chardata)" + }, + { + "name": "STBTT_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 4944, + "column": 1, + "source_line": "STBTT_DEF int stbtt_GetFontOffsetForIndex(const unsigned char *data, int index)" + }, + "source_text": "STBTT_DEF int stbtt_GetFontOffsetForIndex(const unsigned char *data, int index)" + }, + { + "name": "STBTT_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 4949, + "column": 1, + "source_line": "STBTT_DEF int stbtt_GetNumberOfFonts(const unsigned char *data)" + }, + "source_text": "STBTT_DEF int stbtt_GetNumberOfFonts(const unsigned char *data)" + }, + { + "name": "STBTT_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 4954, + "column": 1, + "source_line": "STBTT_DEF int stbtt_InitFont(stbtt_fontinfo *info, const unsigned char *data, int offset)" + }, + "source_text": "STBTT_DEF int stbtt_InitFont(stbtt_fontinfo *info, const unsigned char *data, int offset)" + }, + { + "name": "STBTT_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 4959, + "column": 1, + "source_line": "STBTT_DEF int stbtt_FindMatchingFont(const unsigned char *fontdata, const char *name, int flags)" + }, + "source_text": "STBTT_DEF int stbtt_FindMatchingFont(const unsigned char *fontdata, const char *name, int flags)" + }, + { + "name": "STBTT_DEF", + "context": "declaration", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 4964, + "column": 1, + "source_line": "STBTT_DEF int stbtt_CompareUTF8toUTF16_bigendian(const char *s1, int len1, const char *s2, int len2)" + }, + "source_text": "STBTT_DEF int stbtt_CompareUTF8toUTF16_bigendian(const char *s1, int len1, const char *s2, int len2)" + } + ], + "diagnostics": [ + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTT_ifloor' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 442, + "column": 4, + "source_line": " #define STBTT_ifloor(x) ((int) floor(x))" + }, + "unit_kind": "macro", + "unit_name": "STBTT_ifloor" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTT_iceil' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 443, + "column": 4, + "source_line": " #define STBTT_iceil(x) ((int) ceil(x))" + }, + "unit_kind": "macro", + "unit_name": "STBTT_iceil" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTT_sqrt' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 448, + "column": 4, + "source_line": " #define STBTT_sqrt(x) sqrt(x)" + }, + "unit_kind": "macro", + "unit_name": "STBTT_sqrt" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTT_pow' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 449, + "column": 4, + "source_line": " #define STBTT_pow(x,y) pow(x,y)" + }, + "unit_kind": "macro", + "unit_name": "STBTT_pow" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTT_fmod' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 454, + "column": 4, + "source_line": " #define STBTT_fmod(x,y) fmod(x,y)" + }, + "unit_kind": "macro", + "unit_name": "STBTT_fmod" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTT_cos' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 459, + "column": 4, + "source_line": " #define STBTT_cos(x) cos(x)" + }, + "unit_kind": "macro", + "unit_name": "STBTT_cos" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTT_acos' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 460, + "column": 4, + "source_line": " #define STBTT_acos(x) acos(x)" + }, + "unit_kind": "macro", + "unit_name": "STBTT_acos" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTT_fabs' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 465, + "column": 4, + "source_line": " #define STBTT_fabs(x) fabs(x)" + }, + "unit_kind": "macro", + "unit_name": "STBTT_fabs" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTT_malloc' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 471, + "column": 4, + "source_line": " #define STBTT_malloc(x,u) ((void)(u),malloc(x))" + }, + "unit_kind": "macro", + "unit_name": "STBTT_malloc" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTT_free' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 472, + "column": 4, + "source_line": " #define STBTT_free(x,u) ((void)(u),free(x))" + }, + "unit_kind": "macro", + "unit_name": "STBTT_free" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTT_assert' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 477, + "column": 4, + "source_line": " #define STBTT_assert(x) assert(x)" + }, + "unit_kind": "macro", + "unit_name": "STBTT_assert" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTT_strlen' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 482, + "column": 4, + "source_line": " #define STBTT_strlen(x) strlen(x)" + }, + "unit_kind": "macro", + "unit_name": "STBTT_strlen" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTT_POINT_SIZE' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 602, + "column": 1, + "source_line": "#define STBTT_POINT_SIZE(x) (-(x))" + }, + "unit_kind": "macro", + "unit_name": "STBTT_POINT_SIZE" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTT__NOTUSED' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 1123, + "column": 1, + "source_line": "#define STBTT__NOTUSED(v) (void)(v)" + }, + "unit_kind": "macro", + "unit_name": "STBTT__NOTUSED" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTT__NOTUSED' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 1125, + "column": 1, + "source_line": "#define STBTT__NOTUSED(v) (void)sizeof(v)" + }, + "unit_kind": "macro", + "unit_name": "STBTT__NOTUSED" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbtt__buf_get16' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 1178, + "column": 1, + "source_line": "#define stbtt__buf_get16(b) stbtt__buf_get((b), 2)" + }, + "unit_kind": "macro", + "unit_name": "stbtt__buf_get16" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbtt__buf_get32' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 1179, + "column": 1, + "source_line": "#define stbtt__buf_get32(b) stbtt__buf_get((b), 4)" + }, + "unit_kind": "macro", + "unit_name": "stbtt__buf_get32" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'ttBYTE' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 1282, + "column": 1, + "source_line": "#define ttBYTE(p) (* (stbtt_uint8 *) (p))" + }, + "unit_kind": "macro", + "unit_name": "ttBYTE" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'ttCHAR' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 1283, + "column": 1, + "source_line": "#define ttCHAR(p) (* (stbtt_int8 *) (p))" + }, + "unit_kind": "macro", + "unit_name": "ttCHAR" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'ttFixed' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 1284, + "column": 1, + "source_line": "#define ttFixed(p) ttLONG(p)" + }, + "unit_kind": "macro", + "unit_name": "ttFixed" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbtt_tag4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 1291, + "column": 1, + "source_line": "#define stbtt_tag4(p,c0,c1,c2,c3) ((p)[0] == (c0) && (p)[1] == (c1) && (p)[2] == (c2) && (p)[3] == (c3))" + }, + "unit_kind": "macro", + "unit_name": "stbtt_tag4" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbtt_tag' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 1292, + "column": 1, + "source_line": "#define stbtt_tag(p,str) stbtt_tag4(p,str[0],str[1],str[2],str[3])" + }, + "unit_kind": "macro", + "unit_name": "stbtt_tag" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTT__CSCTX_INIT' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 1909, + "column": 1, + "source_line": "#define STBTT__CSCTX_INIT(bounds) {bounds,0, 0,0, 0,0, 0,0,0,0, NULL, 0}" + }, + "unit_kind": "macro", + "unit_name": "STBTT__CSCTX_INIT" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTT__CSERR' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 2018, + "column": 1, + "source_line": "#define STBTT__CSERR(s) (0)" + }, + "unit_kind": "macro", + "unit_name": "STBTT__CSERR" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTT_GPOS_TODO_assert' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 2494, + "column": 1, + "source_line": "#define STBTT_GPOS_TODO_assert(x)" + }, + "unit_kind": "macro", + "unit_name": "STBTT_GPOS_TODO_assert" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTT__COMPARE' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 3397, + "column": 1, + "source_line": "#define STBTT__COMPARE(a,b) ((a)->y0 < (b)->y0)" + }, + "unit_kind": "macro", + "unit_name": "STBTT__COMPARE" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTT_min' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 4395, + "column": 1, + "source_line": "#define STBTT_min(a,b) ((a) < (b) ? (a) : (b))" + }, + "unit_kind": "macro", + "unit_name": "STBTT_min" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTT_max' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 4396, + "column": 1, + "source_line": "#define STBTT_max(a,b) ((a) < (b) ? (b) : (a))" + }, + "unit_kind": "macro", + "unit_name": "STBTT_max" + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '\"C\"'.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 509, + "column": 1, + "source_line": "extern \"C\" {" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 1496, + "column": 1, + "source_line": "STBTT_DEF int stbtt_FindGlyphIndex(const stbtt_fontinfo *info, int unicode_codepoint)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 1589, + "column": 1, + "source_line": "STBTT_DEF int stbtt_GetCodepointShape(const stbtt_fontinfo *info, int unicode_codepoint, stbtt_vertex **vertices)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 1625, + "column": 1, + "source_line": "STBTT_DEF int stbtt_GetGlyphBox(const stbtt_fontinfo *info, int glyph_index, int *x0, int *y0, int *x1, int *y1)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 1641, + "column": 1, + "source_line": "STBTT_DEF int stbtt_GetCodepointBox(const stbtt_fontinfo *info, int codepoint, int *x0, int *y0, int *x1, int *y1)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 1646, + "column": 1, + "source_line": "STBTT_DEF int stbtt_IsGlyphEmpty(const stbtt_fontinfo *info, int glyph_index)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 2297, + "column": 1, + "source_line": "STBTT_DEF int stbtt_GetGlyphShape(const stbtt_fontinfo *info, int glyph_index, stbtt_vertex **pvertices)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 2305, + "column": 1, + "source_line": "STBTT_DEF void stbtt_GetGlyphHMetrics(const stbtt_fontinfo *info, int glyph_index, int *advanceWidth, int *leftSideBearing)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 2317, + "column": 1, + "source_line": "STBTT_DEF int stbtt_GetKerningTableLength(const stbtt_fontinfo *info)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 2332, + "column": 1, + "source_line": "STBTT_DEF int stbtt_GetKerningTable(const stbtt_fontinfo *info, stbtt_kerningentry* table, int table_length)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 2610, + "column": 1, + "source_line": "STBTT_DEF int stbtt_GetGlyphKernAdvance(const stbtt_fontinfo *info, int g1, int g2)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 2622, + "column": 1, + "source_line": "STBTT_DEF int stbtt_GetCodepointKernAdvance(const stbtt_fontinfo *info, int ch1, int ch2)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 2629, + "column": 1, + "source_line": "STBTT_DEF void stbtt_GetCodepointHMetrics(const stbtt_fontinfo *info, int codepoint, int *advanceWidth, int *leftSideBearing)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 2634, + "column": 1, + "source_line": "STBTT_DEF void stbtt_GetFontVMetrics(const stbtt_fontinfo *info, int *ascent, int *descent, int *lineGap)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 2641, + "column": 1, + "source_line": "STBTT_DEF int stbtt_GetFontVMetricsOS2(const stbtt_fontinfo *info, int *typoAscent, int *typoDescent, int *typoLineGap)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 2652, + "column": 1, + "source_line": "STBTT_DEF void stbtt_GetFontBoundingBox(const stbtt_fontinfo *info, int *x0, int *y0, int *x1, int *y1)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 2660, + "column": 1, + "source_line": "STBTT_DEF float stbtt_ScaleForPixelHeight(const stbtt_fontinfo *info, float height)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 2666, + "column": 1, + "source_line": "STBTT_DEF float stbtt_ScaleForMappingEmToPixels(const stbtt_fontinfo *info, float pixels)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 2672, + "column": 1, + "source_line": "STBTT_DEF void stbtt_FreeShape(const stbtt_fontinfo *info, stbtt_vertex *v)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 2677, + "column": 1, + "source_line": "STBTT_DEF stbtt_uint8 *stbtt_FindSVGDoc(const stbtt_fontinfo *info, int gl)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 2694, + "column": 1, + "source_line": "STBTT_DEF int stbtt_GetGlyphSVG(const stbtt_fontinfo *info, int gl, const char **svg)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 2711, + "column": 1, + "source_line": "STBTT_DEF int stbtt_GetCodepointSVG(const stbtt_fontinfo *info, int unicode_codepoint, const char **svg)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 2721, + "column": 1, + "source_line": "STBTT_DEF void stbtt_GetGlyphBitmapBoxSubpixel(const stbtt_fontinfo *font, int glyph, float scale_x, float scale_y,float shift_x, float shift_y, int *ix0, int *iy0, int *ix1, int *iy1)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 2739, + "column": 1, + "source_line": "STBTT_DEF void stbtt_GetGlyphBitmapBox(const stbtt_fontinfo *font, int glyph, float scale_x, float scale_y, int *ix0, int *iy0, int *ix1, int *iy1)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 2744, + "column": 1, + "source_line": "STBTT_DEF void stbtt_GetCodepointBitmapBoxSubpixel(const stbtt_fontinfo *font, int codepoint, float scale_x, float scale_y, float shift_x, float shift_y, int *ix0, int *iy0, int *ix1, int *iy1)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 2749, + "column": 1, + "source_line": "STBTT_DEF void stbtt_GetCodepointBitmapBox(const stbtt_fontinfo *font, int codepoint, float scale_x, float scale_y, int *ix0, int *iy0, int *ix1, int *iy1)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 3695, + "column": 1, + "source_line": "STBTT_DEF void stbtt_Rasterize(stbtt__bitmap *result, float flatness_in_pixels, stbtt_vertex *vertices, int num_verts, float scale_x, float scale_y, float shift_x, float shift_y, int x_off, int y_off, int invert, void *userdata)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 3708, + "column": 1, + "source_line": "STBTT_DEF void stbtt_FreeBitmap(unsigned char *bitmap, void *userdata)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 3713, + "column": 1, + "source_line": "STBTT_DEF unsigned char *stbtt_GetGlyphBitmapSubpixel(const stbtt_fontinfo *info, float scale_x, float scale_y, float shift_x, float shift_y, int glyph, int *width, int *height, int *xoff, int *yoff)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 3753, + "column": 1, + "source_line": "STBTT_DEF unsigned char *stbtt_GetGlyphBitmap(const stbtt_fontinfo *info, float scale_x, float scale_y, int glyph, int *width, int *height, int *xoff, int *yoff)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 3758, + "column": 1, + "source_line": "STBTT_DEF void stbtt_MakeGlyphBitmapSubpixel(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int glyph)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 3777, + "column": 1, + "source_line": "STBTT_DEF void stbtt_MakeGlyphBitmap(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, int glyph)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 3782, + "column": 1, + "source_line": "STBTT_DEF unsigned char *stbtt_GetCodepointBitmapSubpixel(const stbtt_fontinfo *info, float scale_x, float scale_y, float shift_x, float shift_y, int codepoint, int *width, int *height, int *xoff, int *yoff)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 3787, + "column": 1, + "source_line": "STBTT_DEF void stbtt_MakeCodepointBitmapSubpixelPrefilter(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int oversample_x, int oversample_y, float *sub_x, float *sub_y, int codepoint)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 3792, + "column": 1, + "source_line": "STBTT_DEF void stbtt_MakeCodepointBitmapSubpixel(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int codepoint)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 3797, + "column": 1, + "source_line": "STBTT_DEF unsigned char *stbtt_GetCodepointBitmap(const stbtt_fontinfo *info, float scale_x, float scale_y, int codepoint, int *width, int *height, int *xoff, int *yoff)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 3802, + "column": 1, + "source_line": "STBTT_DEF void stbtt_MakeCodepointBitmap(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, int codepoint)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 3859, + "column": 1, + "source_line": "STBTT_DEF void stbtt_GetBakedQuad(const stbtt_bakedchar *chardata, int pw, int ph, int char_index, float *xpos, float *ypos, stbtt_aligned_quad *q, int opengl_fillrule)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 3957, + "column": 1, + "source_line": "STBTT_DEF int stbtt_PackBegin(stbtt_pack_context *spc, unsigned char *pixels, int pw, int ph, int stride_in_bytes, int padding, void *alloc_context)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 3989, + "column": 1, + "source_line": "STBTT_DEF void stbtt_PackEnd (stbtt_pack_context *spc)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 3995, + "column": 1, + "source_line": "STBTT_DEF void stbtt_PackSetOversampling(stbtt_pack_context *spc, unsigned int h_oversample, unsigned int v_oversample)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 4005, + "column": 1, + "source_line": "STBTT_DEF void stbtt_PackSetSkipMissingCodepoints(stbtt_pack_context *spc, int skip)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 4149, + "column": 1, + "source_line": "STBTT_DEF int stbtt_PackFontRangesGatherRects(stbtt_pack_context *spc, const stbtt_fontinfo *info, stbtt_pack_range *ranges, int num_ranges, stbrp_rect *rects)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 4184, + "column": 1, + "source_line": "STBTT_DEF void stbtt_MakeGlyphBitmapSubpixelPrefilter(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int prefilter_x, int prefilter_y, float *sub_x, float *sub_y, int glyph)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 4208, + "column": 1, + "source_line": "STBTT_DEF int stbtt_PackFontRangesRenderIntoRects(stbtt_pack_context *spc, const stbtt_fontinfo *info, stbtt_pack_range *ranges, int num_ranges, stbrp_rect *rects)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 4297, + "column": 1, + "source_line": "STBTT_DEF void stbtt_PackFontRangesPackRects(stbtt_pack_context *spc, stbrp_rect *rects, int num_rects)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 4302, + "column": 1, + "source_line": "STBTT_DEF int stbtt_PackFontRanges(stbtt_pack_context *spc, const unsigned char *fontdata, int font_index, stbtt_pack_range *ranges, int num_ranges)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 4338, + "column": 1, + "source_line": "STBTT_DEF int stbtt_PackFontRange(stbtt_pack_context *spc, const unsigned char *fontdata, int font_index, float font_size," + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 4350, + "column": 1, + "source_line": "STBTT_DEF void stbtt_GetScaledFontVMetrics(const unsigned char *fontdata, int index, float size, float *ascent, float *descent, float *lineGap)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 4363, + "column": 1, + "source_line": "STBTT_DEF void stbtt_GetPackedQuad(const stbtt_packedchar *chardata, int pw, int ph, int char_index, float *xpos, float *ypos, stbtt_aligned_quad *q, int align_to_integer)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 4575, + "column": 1, + "source_line": "STBTT_DEF unsigned char * stbtt_GetGlyphSDF(const stbtt_fontinfo *info, float scale, int glyph, int padding, unsigned char onedge_value, float pixel_dist_scale, int *width, int *height, int *xoff, int *yoff)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 4762, + "column": 1, + "source_line": "STBTT_DEF unsigned char * stbtt_GetCodepointSDF(const stbtt_fontinfo *info, float scale, int codepoint, int padding, unsigned char onedge_value, float pixel_dist_scale, int *width, int *height, int *xoff, int *yoff)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 4767, + "column": 1, + "source_line": "STBTT_DEF void stbtt_FreeSDF(unsigned char *bitmap, void *userdata)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 4824, + "column": 1, + "source_line": "STBTT_DEF const char *stbtt_GetFontNameString(const stbtt_fontinfo *font, int *length, int platformID, int encodingID, int languageID, int nameID)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 4937, + "column": 1, + "source_line": "STBTT_DEF int stbtt_BakeFontBitmap(const unsigned char *data, int offset," + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 4944, + "column": 1, + "source_line": "STBTT_DEF int stbtt_GetFontOffsetForIndex(const unsigned char *data, int index)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 4949, + "column": 1, + "source_line": "STBTT_DEF int stbtt_GetNumberOfFonts(const unsigned char *data)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 4954, + "column": 1, + "source_line": "STBTT_DEF int stbtt_InitFont(stbtt_fontinfo *info, const unsigned char *data, int offset)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 4959, + "column": 1, + "source_line": "STBTT_DEF int stbtt_FindMatchingFont(const unsigned char *fontdata, const char *name, int flags)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 4964, + "column": 1, + "source_line": "STBTT_DEF int stbtt_CompareUTF8toUTF16_bigendian(const char *s1, int len1, const char *s2, int len2)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_CONFLICTING_VARIABLE_DECLARATION", + "message": "Conflicting declarations for variable 'ttf_buffer'.", + "severity": "error", + "location": { + "filename": "stb/stb_truetype.h", + "line": 332, + "column": 1, + "source_line": "char ttf_buffer[1<<25];" + }, + "unit_kind": "variable", + "unit_name": "ttf_buffer" + }, + { + "code": "C_DUPLICATE_FUNCTION_DEFINITION", + "message": "Duplicate definition for function 'main'.", + "severity": "error", + "location": { + "filename": "stb/stb_truetype.h", + "line": 375, + "column": 1, + "source_line": "int main(int arg, char **argv)" + }, + "unit_kind": "function", + "unit_name": "main" + }, + { + "code": "C_DUPLICATE_FUNCTION_DEFINITION", + "message": "Duplicate definition for function 'stbtt__new_active'.", + "severity": "error", + "location": { + "filename": "stb/stb_truetype.h", + "line": 2857, + "column": 1, + "source_line": "static stbtt__active_edge *stbtt__new_active(stbtt__hheap *hh, stbtt__edge *e, int off_x, float start_point, void *userdata)" + }, + "unit_kind": "function", + "unit_name": "stbtt__new_active" + }, + { + "code": "C_DUPLICATE_FUNCTION_DEFINITION", + "message": "Duplicate definition for function 'stbtt__rasterize_sorted_edges'.", + "severity": "error", + "location": { + "filename": "stb/stb_truetype.h", + "line": 3297, + "column": 1, + "source_line": "static void stbtt__rasterize_sorted_edges(stbtt__bitmap *result, stbtt__edge *e, int n, int vsubsample, int off_x, int off_y, void *userdata)" + }, + "unit_kind": "function", + "unit_name": "stbtt__rasterize_sorted_edges" + } + ] + } + }, + "functions": { + "my_stbtt_initfont": { + "name": "my_stbtt_initfont", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 287, + "column": 1, + "source_line": "void my_stbtt_initfont(void)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 287, + "column": 1, + "source_line": "void my_stbtt_initfont(void)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 297, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "my_stbtt_print": { + "name": "my_stbtt_print", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "text", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *text", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *text", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 299, + "column": 1, + "source_line": "void my_stbtt_print(float x, float y, char *text)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 299, + "column": 1, + "source_line": "void my_stbtt_print(float x, float y, char *text)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 319, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "main": { + "name": "main", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "argc", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int argc" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int argc" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "argv", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char **argv", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char **argv", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 334, + "column": 1, + "source_line": "int main(int argc, char **argv)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 334, + "column": 1, + "source_line": "int main(int argc, char **argv)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 351, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbtt__buf_get8": { + "name": "stbtt__buf_get8", + "result_type": { + "reference": "stbtt_uint8" + }, + "parameters": [ + { + "name": "b", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__buf *b", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__buf" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__buf *b", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__buf" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1133, + "column": 1, + "source_line": "static stbtt_uint8 stbtt__buf_get8(stbtt__buf *b)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1133, + "column": 1, + "source_line": "static stbtt_uint8 stbtt__buf_get8(stbtt__buf *b)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1138, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbtt__buf_peek8": { + "name": "stbtt__buf_peek8", + "result_type": { + "reference": "stbtt_uint8" + }, + "parameters": [ + { + "name": "b", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__buf *b", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__buf" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__buf *b", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__buf" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1140, + "column": 1, + "source_line": "static stbtt_uint8 stbtt__buf_peek8(stbtt__buf *b)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1140, + "column": 1, + "source_line": "static stbtt_uint8 stbtt__buf_peek8(stbtt__buf *b)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1145, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbtt__buf_seek": { + "name": "stbtt__buf_seek", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "b", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__buf *b", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__buf" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__buf *b", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__buf" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "o", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int o" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int o" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1147, + "column": 1, + "source_line": "static void stbtt__buf_seek(stbtt__buf *b, int o)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1147, + "column": 1, + "source_line": "static void stbtt__buf_seek(stbtt__buf *b, int o)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1151, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbtt__buf_skip": { + "name": "stbtt__buf_skip", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "b", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__buf *b", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__buf" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__buf *b", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__buf" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "o", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int o" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int o" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1153, + "column": 1, + "source_line": "static void stbtt__buf_skip(stbtt__buf *b, int o)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1153, + "column": 1, + "source_line": "static void stbtt__buf_skip(stbtt__buf *b, int o)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1156, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbtt__buf_get": { + "name": "stbtt__buf_get", + "result_type": { + "reference": "stbtt_uint32" + }, + "parameters": [ + { + "name": "b", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__buf *b", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__buf" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__buf *b", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__buf" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1158, + "column": 1, + "source_line": "static stbtt_uint32 stbtt__buf_get(stbtt__buf *b, int n)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1158, + "column": 1, + "source_line": "static stbtt_uint32 stbtt__buf_get(stbtt__buf *b, int n)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1166, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbtt__new_buf": { + "name": "stbtt__new_buf", + "result_type": { + "reference": "stbtt__buf" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const void *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [ + "const" + ], + "source_text": "const void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const void *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [ + "const" + ], + "source_text": "const void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "size", + "type": { + "reference": "size_t" + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1168, + "column": 1, + "source_line": "static stbtt__buf stbtt__new_buf(const void *p, size_t size)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1168, + "column": 1, + "source_line": "static stbtt__buf stbtt__new_buf(const void *p, size_t size)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1176, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbtt__buf_range": { + "name": "stbtt__buf_range", + "result_type": { + "reference": "stbtt__buf" + }, + "parameters": [ + { + "name": "b", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stbtt__buf *b", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__buf" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stbtt__buf *b", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__buf" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "o", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int o" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int o" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "s", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int s" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int s" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1181, + "column": 1, + "source_line": "static stbtt__buf stbtt__buf_range(const stbtt__buf *b, int o, int s)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1181, + "column": 1, + "source_line": "static stbtt__buf stbtt__buf_range(const stbtt__buf *b, int o, int s)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1188, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbtt__cff_get_index": { + "name": "stbtt__cff_get_index", + "result_type": { + "reference": "stbtt__buf" + }, + "parameters": [ + { + "name": "b", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__buf *b", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__buf" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__buf *b", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__buf" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1190, + "column": 1, + "source_line": "static stbtt__buf stbtt__cff_get_index(stbtt__buf *b)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1190, + "column": 1, + "source_line": "static stbtt__buf stbtt__cff_get_index(stbtt__buf *b)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1202, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbtt__cff_int": { + "name": "stbtt__cff_int", + "result_type": { + "reference": "stbtt_uint32" + }, + "parameters": [ + { + "name": "b", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__buf *b", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__buf" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__buf *b", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__buf" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1204, + "column": 1, + "source_line": "static stbtt_uint32 stbtt__cff_int(stbtt__buf *b)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1204, + "column": 1, + "source_line": "static stbtt_uint32 stbtt__cff_int(stbtt__buf *b)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1214, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbtt__cff_skip_operand": { + "name": "stbtt__cff_skip_operand", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "b", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__buf *b", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__buf" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__buf *b", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__buf" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1216, + "column": 1, + "source_line": "static void stbtt__cff_skip_operand(stbtt__buf *b) {" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1216, + "column": 1, + "source_line": "static void stbtt__cff_skip_operand(stbtt__buf *b) {" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1229, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbtt__dict_get": { + "name": "stbtt__dict_get", + "result_type": { + "reference": "stbtt__buf" + }, + "parameters": [ + { + "name": "b", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__buf *b", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__buf" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__buf *b", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__buf" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "key", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int key" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int key" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1231, + "column": 1, + "source_line": "static stbtt__buf stbtt__dict_get(stbtt__buf *b, int key)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1231, + "column": 1, + "source_line": "static stbtt__buf stbtt__dict_get(stbtt__buf *b, int key)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1244, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbtt__dict_get_ints": { + "name": "stbtt__dict_get_ints", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "b", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__buf *b", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__buf" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__buf *b", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__buf" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "key", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int key" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int key" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "outcount", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int outcount" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int outcount" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "out", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_uint32 *out", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_uint32" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_uint32 *out", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_uint32" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1246, + "column": 1, + "source_line": "static void stbtt__dict_get_ints(stbtt__buf *b, int key, int outcount, stbtt_uint32 *out)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1246, + "column": 1, + "source_line": "static void stbtt__dict_get_ints(stbtt__buf *b, int key, int outcount, stbtt_uint32 *out)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1252, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbtt__cff_index_count": { + "name": "stbtt__cff_index_count", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "b", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__buf *b", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__buf" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__buf *b", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__buf" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1254, + "column": 1, + "source_line": "static int stbtt__cff_index_count(stbtt__buf *b)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1254, + "column": 1, + "source_line": "static int stbtt__cff_index_count(stbtt__buf *b)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1258, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbtt__cff_index_get": { + "name": "stbtt__cff_index_get", + "result_type": { + "reference": "stbtt__buf" + }, + "parameters": [ + { + "name": "b", + "type": { + "reference": "stbtt__buf" + }, + "declared_type": { + "reference": "stbtt__buf" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "i", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int i" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int i" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1260, + "column": 1, + "source_line": "static stbtt__buf stbtt__cff_index_get(stbtt__buf b, int i)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1260, + "column": 1, + "source_line": "static stbtt__buf stbtt__cff_index_get(stbtt__buf b, int i)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1272, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "ttUSHORT": { + "name": "ttUSHORT", + "result_type": { + "reference": "stbtt_uint16" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_uint8 *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_uint8" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_uint8 *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_uint8" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1286, + "column": 1, + "source_line": "static stbtt_uint16 ttUSHORT(stbtt_uint8 *p) { return p[0]*256 + p[1]; }" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1286, + "column": 1, + "source_line": "static stbtt_uint16 ttUSHORT(stbtt_uint8 *p) { return p[0]*256 + p[1]; }" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1286, + "column": 72, + "source_line": "static stbtt_uint16 ttUSHORT(stbtt_uint8 *p) { return p[0]*256 + p[1]; }" + }, + "declaration_locations": [] + }, + "ttSHORT": { + "name": "ttSHORT", + "result_type": { + "reference": "stbtt_int16" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_uint8 *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_uint8" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_uint8 *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_uint8" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1287, + "column": 1, + "source_line": "static stbtt_int16 ttSHORT(stbtt_uint8 *p) { return p[0]*256 + p[1]; }" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1287, + "column": 1, + "source_line": "static stbtt_int16 ttSHORT(stbtt_uint8 *p) { return p[0]*256 + p[1]; }" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1287, + "column": 72, + "source_line": "static stbtt_int16 ttSHORT(stbtt_uint8 *p) { return p[0]*256 + p[1]; }" + }, + "declaration_locations": [] + }, + "ttULONG": { + "name": "ttULONG", + "result_type": { + "reference": "stbtt_uint32" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_uint8 *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_uint8" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_uint8 *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_uint8" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1288, + "column": 1, + "source_line": "static stbtt_uint32 ttULONG(stbtt_uint8 *p) { return (p[0]<<24) + (p[1]<<16) + (p[2]<<8) + p[3]; }" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1288, + "column": 1, + "source_line": "static stbtt_uint32 ttULONG(stbtt_uint8 *p) { return (p[0]<<24) + (p[1]<<16) + (p[2]<<8) + p[3]; }" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1288, + "column": 99, + "source_line": "static stbtt_uint32 ttULONG(stbtt_uint8 *p) { return (p[0]<<24) + (p[1]<<16) + (p[2]<<8) + p[3]; }" + }, + "declaration_locations": [] + }, + "ttLONG": { + "name": "ttLONG", + "result_type": { + "reference": "stbtt_int32" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_uint8 *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_uint8" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_uint8 *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_uint8" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1289, + "column": 1, + "source_line": "static stbtt_int32 ttLONG(stbtt_uint8 *p) { return (p[0]<<24) + (p[1]<<16) + (p[2]<<8) + p[3]; }" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1289, + "column": 1, + "source_line": "static stbtt_int32 ttLONG(stbtt_uint8 *p) { return (p[0]<<24) + (p[1]<<16) + (p[2]<<8) + p[3]; }" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1289, + "column": 99, + "source_line": "static stbtt_int32 ttLONG(stbtt_uint8 *p) { return (p[0]<<24) + (p[1]<<16) + (p[2]<<8) + p[3]; }" + }, + "declaration_locations": [] + }, + "stbtt__isfont": { + "name": "stbtt__isfont", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "font", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_uint8 *font", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_uint8" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_uint8 *font", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_uint8" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1294, + "column": 1, + "source_line": "static int stbtt__isfont(stbtt_uint8 *font)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1294, + "column": 1, + "source_line": "static int stbtt__isfont(stbtt_uint8 *font)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1303, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbtt__find_table": { + "name": "stbtt__find_table", + "result_type": { + "reference": "stbtt_uint32" + }, + "parameters": [ + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_uint8 *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_uint8" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_uint8 *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_uint8" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "fontstart", + "type": { + "reference": "stbtt_uint32" + }, + "declared_type": { + "reference": "stbtt_uint32" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "tag", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *tag", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *tag", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1306, + "column": 1, + "source_line": "static stbtt_uint32 stbtt__find_table(stbtt_uint8 *data, stbtt_uint32 fontstart, const char *tag)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1306, + "column": 1, + "source_line": "static stbtt_uint32 stbtt__find_table(stbtt_uint8 *data, stbtt_uint32 fontstart, const char *tag)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1317, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbtt_GetFontOffsetForIndex_internal": { + "name": "stbtt_GetFontOffsetForIndex_internal", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "font_collection", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *font_collection", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *font_collection", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "index", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int index" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int index" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1319, + "column": 1, + "source_line": "static int stbtt_GetFontOffsetForIndex_internal(unsigned char *font_collection, int index)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1319, + "column": 1, + "source_line": "static int stbtt_GetFontOffsetForIndex_internal(unsigned char *font_collection, int index)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1336, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbtt_GetNumberOfFonts_internal": { + "name": "stbtt_GetNumberOfFonts_internal", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "font_collection", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *font_collection", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *font_collection", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1338, + "column": 1, + "source_line": "static int stbtt_GetNumberOfFonts_internal(unsigned char *font_collection)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1338, + "column": 1, + "source_line": "static int stbtt_GetNumberOfFonts_internal(unsigned char *font_collection)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1352, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbtt__get_subrs": { + "name": "stbtt__get_subrs", + "result_type": { + "reference": "stbtt__buf" + }, + "parameters": [ + { + "name": "cff", + "type": { + "reference": "stbtt__buf" + }, + "declared_type": { + "reference": "stbtt__buf" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "fontdict", + "type": { + "reference": "stbtt__buf" + }, + "declared_type": { + "reference": "stbtt__buf" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1354, + "column": 1, + "source_line": "static stbtt__buf stbtt__get_subrs(stbtt__buf cff, stbtt__buf fontdict)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1354, + "column": 1, + "source_line": "static stbtt__buf stbtt__get_subrs(stbtt__buf cff, stbtt__buf fontdict)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1365, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbtt__get_svg": { + "name": "stbtt__get_svg", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_fontinfo *info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_fontinfo" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_fontinfo *info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_fontinfo" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1368, + "column": 1, + "source_line": "static int stbtt__get_svg(stbtt_fontinfo *info)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1368, + "column": 1, + "source_line": "static int stbtt__get_svg(stbtt_fontinfo *info)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1381, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbtt_InitFont_internal": { + "name": "stbtt_InitFont_internal", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_fontinfo *info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_fontinfo" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_fontinfo *info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_fontinfo" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "fontstart", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int fontstart" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int fontstart" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1383, + "column": 1, + "source_line": "static int stbtt_InitFont_internal(stbtt_fontinfo *info, unsigned char *data, int fontstart)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1383, + "column": 1, + "source_line": "static int stbtt_InitFont_internal(stbtt_fontinfo *info, unsigned char *data, int fontstart)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1494, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbtt_setvertex": { + "name": "stbtt_setvertex", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "v", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_vertex *v", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_vertex" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_vertex *v", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_vertex" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "type", + "type": { + "reference": "stbtt_uint8" + }, + "declared_type": { + "reference": "stbtt_uint8" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "reference": "stbtt_int32" + }, + "declared_type": { + "reference": "stbtt_int32" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "reference": "stbtt_int32" + }, + "declared_type": { + "reference": "stbtt_int32" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cx", + "type": { + "reference": "stbtt_int32" + }, + "declared_type": { + "reference": "stbtt_int32" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cy", + "type": { + "reference": "stbtt_int32" + }, + "declared_type": { + "reference": "stbtt_int32" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1594, + "column": 1, + "source_line": "static void stbtt_setvertex(stbtt_vertex *v, stbtt_uint8 type, stbtt_int32 x, stbtt_int32 y, stbtt_int32 cx, stbtt_int32 cy)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1594, + "column": 1, + "source_line": "static void stbtt_setvertex(stbtt_vertex *v, stbtt_uint8 type, stbtt_int32 x, stbtt_int32 y, stbtt_int32 cx, stbtt_int32 cy)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1601, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbtt__GetGlyfOffset": { + "name": "stbtt__GetGlyfOffset", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stbtt_fontinfo *info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_fontinfo" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stbtt_fontinfo *info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_fontinfo" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "glyph_index", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int glyph_index" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int glyph_index" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1603, + "column": 1, + "source_line": "static int stbtt__GetGlyfOffset(const stbtt_fontinfo *info, int glyph_index)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1603, + "column": 1, + "source_line": "static int stbtt__GetGlyfOffset(const stbtt_fontinfo *info, int glyph_index)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1621, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbtt__GetGlyphInfoT2": { + "name": "stbtt__GetGlyphInfoT2", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stbtt_fontinfo *info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_fontinfo" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stbtt_fontinfo *info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_fontinfo" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "glyph_index", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int glyph_index" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int glyph_index" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x0", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x0", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x0", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y0", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y0", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y0", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x1", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x1", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *x1", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y1", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y1", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *y1", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2286, + "column": 1, + "source_line": "static int stbtt__GetGlyphInfoT2(const stbtt_fontinfo *info, int glyph_index, int *x0, int *y0, int *x1, int *y1)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 2286, + "column": 1, + "source_line": "static int stbtt__GetGlyphInfoT2(const stbtt_fontinfo *info, int glyph_index, int *x0, int *y0, int *x1, int *y1)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 2295, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "stb/stb_truetype.h", + "line": 1623, + "column": 1, + "source_line": "static int stbtt__GetGlyphInfoT2(const stbtt_fontinfo *info, int glyph_index, int *x0, int *y0, int *x1, int *y1);" + } + ] + }, + "stbtt__close_shape": { + "name": "stbtt__close_shape", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "vertices", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_vertex *vertices", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_vertex" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_vertex *vertices", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_vertex" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "num_vertices", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_vertices" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_vertices" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "was_off", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int was_off" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int was_off" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "start_off", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int start_off" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int start_off" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "sx", + "type": { + "reference": "stbtt_int32" + }, + "declared_type": { + "reference": "stbtt_int32" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "sy", + "type": { + "reference": "stbtt_int32" + }, + "declared_type": { + "reference": "stbtt_int32" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "scx", + "type": { + "reference": "stbtt_int32" + }, + "declared_type": { + "reference": "stbtt_int32" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "scy", + "type": { + "reference": "stbtt_int32" + }, + "declared_type": { + "reference": "stbtt_int32" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cx", + "type": { + "reference": "stbtt_int32" + }, + "declared_type": { + "reference": "stbtt_int32" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cy", + "type": { + "reference": "stbtt_int32" + }, + "declared_type": { + "reference": "stbtt_int32" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1658, + "column": 1, + "source_line": "static int stbtt__close_shape(stbtt_vertex *vertices, int num_vertices, int was_off, int start_off," + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1658, + "column": 1, + "source_line": "static int stbtt__close_shape(stbtt_vertex *vertices, int num_vertices, int was_off, int start_off," + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1672, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbtt__GetGlyphShapeTT": { + "name": "stbtt__GetGlyphShapeTT", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stbtt_fontinfo *info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_fontinfo" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stbtt_fontinfo *info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_fontinfo" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "glyph_index", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int glyph_index" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int glyph_index" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "pvertices", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_vertex **pvertices", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_vertex" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_vertex **pvertices", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_vertex" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1674, + "column": 1, + "source_line": "static int stbtt__GetGlyphShapeTT(const stbtt_fontinfo *info, int glyph_index, stbtt_vertex **pvertices)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1674, + "column": 1, + "source_line": "static int stbtt__GetGlyphShapeTT(const stbtt_fontinfo *info, int glyph_index, stbtt_vertex **pvertices)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1895, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbtt__track_vertex": { + "name": "stbtt__track_vertex", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "c", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__csctx *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__csctx" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__csctx *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__csctx" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "reference": "stbtt_int32" + }, + "declared_type": { + "reference": "stbtt_int32" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "reference": "stbtt_int32" + }, + "declared_type": { + "reference": "stbtt_int32" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1911, + "column": 1, + "source_line": "static void stbtt__track_vertex(stbtt__csctx *c, stbtt_int32 x, stbtt_int32 y)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1911, + "column": 1, + "source_line": "static void stbtt__track_vertex(stbtt__csctx *c, stbtt_int32 x, stbtt_int32 y)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1918, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbtt__csctx_v": { + "name": "stbtt__csctx_v", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "c", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__csctx *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__csctx" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__csctx *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__csctx" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "type", + "type": { + "reference": "stbtt_uint8" + }, + "declared_type": { + "reference": "stbtt_uint8" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "reference": "stbtt_int32" + }, + "declared_type": { + "reference": "stbtt_int32" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "reference": "stbtt_int32" + }, + "declared_type": { + "reference": "stbtt_int32" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cx", + "type": { + "reference": "stbtt_int32" + }, + "declared_type": { + "reference": "stbtt_int32" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cy", + "type": { + "reference": "stbtt_int32" + }, + "declared_type": { + "reference": "stbtt_int32" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cx1", + "type": { + "reference": "stbtt_int32" + }, + "declared_type": { + "reference": "stbtt_int32" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "cy1", + "type": { + "reference": "stbtt_int32" + }, + "declared_type": { + "reference": "stbtt_int32" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1920, + "column": 1, + "source_line": "static void stbtt__csctx_v(stbtt__csctx *c, stbtt_uint8 type, stbtt_int32 x, stbtt_int32 y, stbtt_int32 cx, stbtt_int32 cy, stbtt_int32 cx1, stbtt_int32 cy1)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1920, + "column": 1, + "source_line": "static void stbtt__csctx_v(stbtt__csctx *c, stbtt_uint8 type, stbtt_int32 x, stbtt_int32 y, stbtt_int32 cx, stbtt_int32 cy, stbtt_int32 cx1, stbtt_int32 cy1)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1934, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbtt__csctx_close_shape": { + "name": "stbtt__csctx_close_shape", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "ctx", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__csctx *ctx", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__csctx" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__csctx *ctx", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__csctx" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1936, + "column": 1, + "source_line": "static void stbtt__csctx_close_shape(stbtt__csctx *ctx)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1936, + "column": 1, + "source_line": "static void stbtt__csctx_close_shape(stbtt__csctx *ctx)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1940, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbtt__csctx_rmove_to": { + "name": "stbtt__csctx_rmove_to", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "ctx", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__csctx *ctx", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__csctx" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__csctx *ctx", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__csctx" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dx", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dx" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dx" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dy", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dy" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dy" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1942, + "column": 1, + "source_line": "static void stbtt__csctx_rmove_to(stbtt__csctx *ctx, float dx, float dy)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1942, + "column": 1, + "source_line": "static void stbtt__csctx_rmove_to(stbtt__csctx *ctx, float dx, float dy)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1948, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbtt__csctx_rline_to": { + "name": "stbtt__csctx_rline_to", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "ctx", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__csctx *ctx", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__csctx" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__csctx *ctx", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__csctx" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dx", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dx" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dx" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dy", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dy" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dy" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1950, + "column": 1, + "source_line": "static void stbtt__csctx_rline_to(stbtt__csctx *ctx, float dx, float dy)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1950, + "column": 1, + "source_line": "static void stbtt__csctx_rline_to(stbtt__csctx *ctx, float dx, float dy)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1955, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbtt__csctx_rccurve_to": { + "name": "stbtt__csctx_rccurve_to", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "ctx", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__csctx *ctx", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__csctx" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__csctx *ctx", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__csctx" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dx1", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dx1" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dx1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dy1", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dy1" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dy1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dx2", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dx2" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dx2" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dy2", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dy2" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dy2" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dx3", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dx3" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dx3" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dy3", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dy3" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float dy3" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1957, + "column": 1, + "source_line": "static void stbtt__csctx_rccurve_to(stbtt__csctx *ctx, float dx1, float dy1, float dx2, float dy2, float dx3, float dy3)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1957, + "column": 1, + "source_line": "static void stbtt__csctx_rccurve_to(stbtt__csctx *ctx, float dx1, float dy1, float dx2, float dy2, float dx3, float dy3)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1966, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbtt__get_subr": { + "name": "stbtt__get_subr", + "result_type": { + "reference": "stbtt__buf" + }, + "parameters": [ + { + "name": "idx", + "type": { + "reference": "stbtt__buf" + }, + "declared_type": { + "reference": "stbtt__buf" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1968, + "column": 1, + "source_line": "static stbtt__buf stbtt__get_subr(stbtt__buf idx, int n)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1968, + "column": 1, + "source_line": "static stbtt__buf stbtt__get_subr(stbtt__buf idx, int n)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 1980, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbtt__cid_get_glyph_subrs": { + "name": "stbtt__cid_get_glyph_subrs", + "result_type": { + "reference": "stbtt__buf" + }, + "parameters": [ + { + "name": "info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stbtt_fontinfo *info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_fontinfo" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stbtt_fontinfo *info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_fontinfo" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "glyph_index", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int glyph_index" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int glyph_index" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1982, + "column": 1, + "source_line": "static stbtt__buf stbtt__cid_get_glyph_subrs(const stbtt_fontinfo *info, int glyph_index)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 1982, + "column": 1, + "source_line": "static stbtt__buf stbtt__cid_get_glyph_subrs(const stbtt_fontinfo *info, int glyph_index)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 2008, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbtt__run_charstring": { + "name": "stbtt__run_charstring", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stbtt_fontinfo *info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_fontinfo" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stbtt_fontinfo *info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_fontinfo" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "glyph_index", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int glyph_index" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int glyph_index" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__csctx *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__csctx" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__csctx *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__csctx" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2010, + "column": 1, + "source_line": "static int stbtt__run_charstring(const stbtt_fontinfo *info, int glyph_index, stbtt__csctx *c)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 2010, + "column": 1, + "source_line": "static int stbtt__run_charstring(const stbtt_fontinfo *info, int glyph_index, stbtt__csctx *c)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 2267, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbtt__GetGlyphShapeT2": { + "name": "stbtt__GetGlyphShapeT2", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stbtt_fontinfo *info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_fontinfo" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stbtt_fontinfo *info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_fontinfo" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "glyph_index", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int glyph_index" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int glyph_index" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "pvertices", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_vertex **pvertices", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_vertex" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_vertex **pvertices", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_vertex" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2269, + "column": 1, + "source_line": "static int stbtt__GetGlyphShapeT2(const stbtt_fontinfo *info, int glyph_index, stbtt_vertex **pvertices)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 2269, + "column": 1, + "source_line": "static int stbtt__GetGlyphShapeT2(const stbtt_fontinfo *info, int glyph_index, stbtt_vertex **pvertices)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 2284, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbtt__GetGlyphKernInfoAdvance": { + "name": "stbtt__GetGlyphKernInfoAdvance", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stbtt_fontinfo *info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_fontinfo" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stbtt_fontinfo *info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_fontinfo" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "glyph1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int glyph1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int glyph1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "glyph2", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int glyph2" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int glyph2" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2359, + "column": 1, + "source_line": "static int stbtt__GetGlyphKernInfoAdvance(const stbtt_fontinfo *info, int glyph1, int glyph2)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 2359, + "column": 1, + "source_line": "static int stbtt__GetGlyphKernInfoAdvance(const stbtt_fontinfo *info, int glyph1, int glyph2)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 2387, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbtt__GetCoverageIndex": { + "name": "stbtt__GetCoverageIndex", + "result_type": { + "reference": "stbtt_int32" + }, + "parameters": [ + { + "name": "coverageTable", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_uint8 *coverageTable", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_uint8" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_uint8 *coverageTable", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_uint8" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "glyph", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int glyph" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int glyph" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2389, + "column": 1, + "source_line": "static stbtt_int32 stbtt__GetCoverageIndex(stbtt_uint8 *coverageTable, int glyph)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 2389, + "column": 1, + "source_line": "static stbtt_int32 stbtt__GetCoverageIndex(stbtt_uint8 *coverageTable, int glyph)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 2445, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbtt__GetGlyphClass": { + "name": "stbtt__GetGlyphClass", + "result_type": { + "reference": "stbtt_int32" + }, + "parameters": [ + { + "name": "classDefTable", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_uint8 *classDefTable", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_uint8" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_uint8 *classDefTable", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_uint8" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "glyph", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int glyph" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int glyph" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2447, + "column": 1, + "source_line": "static stbtt_int32 stbtt__GetGlyphClass(stbtt_uint8 *classDefTable, int glyph)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 2447, + "column": 1, + "source_line": "static stbtt_int32 stbtt__GetGlyphClass(stbtt_uint8 *classDefTable, int glyph)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 2491, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbtt__GetGlyphGPOSInfoAdvance": { + "name": "stbtt__GetGlyphGPOSInfoAdvance", + "result_type": { + "reference": "stbtt_int32" + }, + "parameters": [ + { + "name": "info", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stbtt_fontinfo *info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_fontinfo" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stbtt_fontinfo *info", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_fontinfo" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "glyph1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int glyph1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int glyph1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "glyph2", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int glyph2" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int glyph2" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2496, + "column": 1, + "source_line": "static stbtt_int32 stbtt__GetGlyphGPOSInfoAdvance(const stbtt_fontinfo *info, int glyph1, int glyph2)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 2496, + "column": 1, + "source_line": "static stbtt_int32 stbtt__GetGlyphGPOSInfoAdvance(const stbtt_fontinfo *info, int glyph1, int glyph2)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 2608, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbtt__hheap_alloc": { + "name": "stbtt__hheap_alloc", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "parameters": [ + { + "name": "hh", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__hheap *hh", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__hheap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__hheap *hh", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__hheap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "size", + "type": { + "reference": "size_t" + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "userdata", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *userdata", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *userdata", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2770, + "column": 1, + "source_line": "static void *stbtt__hheap_alloc(stbtt__hheap *hh, size_t size, void *userdata)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 2770, + "column": 1, + "source_line": "static void *stbtt__hheap_alloc(stbtt__hheap *hh, size_t size, void *userdata)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 2789, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbtt__hheap_free": { + "name": "stbtt__hheap_free", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "hh", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__hheap *hh", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__hheap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__hheap *hh", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__hheap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2791, + "column": 1, + "source_line": "static void stbtt__hheap_free(stbtt__hheap *hh, void *p)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 2791, + "column": 1, + "source_line": "static void stbtt__hheap_free(stbtt__hheap *hh, void *p)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 2795, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbtt__hheap_cleanup": { + "name": "stbtt__hheap_cleanup", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "hh", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__hheap *hh", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__hheap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__hheap *hh", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__hheap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "userdata", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *userdata", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *userdata", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2797, + "column": 1, + "source_line": "static void stbtt__hheap_cleanup(stbtt__hheap *hh, void *userdata)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 2797, + "column": 1, + "source_line": "static void stbtt__hheap_cleanup(stbtt__hheap *hh, void *userdata)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 2805, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbtt__new_active": { + "name": "stbtt__new_active", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__active_edge", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__active_edge" + } + ] + }, + "parameters": [ + { + "name": "hh", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__hheap *hh", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__hheap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__hheap *hh", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__hheap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "e", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__edge *e", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__edge" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__edge *e", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__edge" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "off_x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int off_x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int off_x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "start_point", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float start_point" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float start_point" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "userdata", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *userdata", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *userdata", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2835, + "column": 1, + "source_line": "static stbtt__active_edge *stbtt__new_active(stbtt__hheap *hh, stbtt__edge *e, int off_x, float start_point, void *userdata)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 2835, + "column": 1, + "source_line": "static stbtt__active_edge *stbtt__new_active(stbtt__hheap *hh, stbtt__edge *e, int off_x, float start_point, void *userdata)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 2855, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbtt__fill_active_edges": { + "name": "stbtt__fill_active_edges", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "scanline", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *scanline", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *scanline", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "e", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__active_edge *e", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__active_edge" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__active_edge *e", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__active_edge" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "max_weight", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int max_weight" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int max_weight" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2882, + "column": 1, + "source_line": "static void stbtt__fill_active_edges(unsigned char *scanline, int len, stbtt__active_edge *e, int max_weight)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 2882, + "column": 1, + "source_line": "static void stbtt__fill_active_edges(unsigned char *scanline, int len, stbtt__active_edge *e, int max_weight)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 2922, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbtt__rasterize_sorted_edges": { + "name": "stbtt__rasterize_sorted_edges", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "result", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__bitmap *result", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__bitmap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__bitmap *result", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__bitmap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "e", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__edge *e", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__edge" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__edge *e", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__edge" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "vsubsample", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int vsubsample" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int vsubsample" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "off_x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int off_x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int off_x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "off_y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int off_y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int off_y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "userdata", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *userdata", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *userdata", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2924, + "column": 1, + "source_line": "static void stbtt__rasterize_sorted_edges(stbtt__bitmap *result, stbtt__edge *e, int n, int vsubsample, int off_x, int off_y, void *userdata)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 2924, + "column": 1, + "source_line": "static void stbtt__rasterize_sorted_edges(stbtt__bitmap *result, stbtt__edge *e, int n, int vsubsample, int off_x, int off_y, void *userdata)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 3022, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbtt__handle_clipped_edge": { + "name": "stbtt__handle_clipped_edge", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "scanline", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *scanline", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *scanline", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "e", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__active_edge *e", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__active_edge" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__active_edge *e", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__active_edge" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x0", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x0" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y0", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y0" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x1", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x1" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y1", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y1" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y1" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3028, + "column": 1, + "source_line": "static void stbtt__handle_clipped_edge(float *scanline, int x, stbtt__active_edge *e, float x0, float y0, float x1, float y1)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 3028, + "column": 1, + "source_line": "static void stbtt__handle_clipped_edge(float *scanline, int x, stbtt__active_edge *e, float x0, float y0, float x1, float y1)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 3063, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbtt__sized_trapezoid_area": { + "name": "stbtt__sized_trapezoid_area", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "height", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float height" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float height" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "top_width", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float top_width" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float top_width" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "bottom_width", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float bottom_width" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float bottom_width" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3065, + "column": 1, + "source_line": "static float stbtt__sized_trapezoid_area(float height, float top_width, float bottom_width)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 3065, + "column": 1, + "source_line": "static float stbtt__sized_trapezoid_area(float height, float top_width, float bottom_width)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 3070, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbtt__position_trapezoid_area": { + "name": "stbtt__position_trapezoid_area", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "height", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float height" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float height" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "tx0", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float tx0" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float tx0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "tx1", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float tx1" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float tx1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "bx0", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float bx0" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float bx0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "bx1", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float bx1" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float bx1" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3072, + "column": 1, + "source_line": "static float stbtt__position_trapezoid_area(float height, float tx0, float tx1, float bx0, float bx1)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 3072, + "column": 1, + "source_line": "static float stbtt__position_trapezoid_area(float height, float tx0, float tx1, float bx0, float bx1)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 3075, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbtt__sized_triangle_area": { + "name": "stbtt__sized_triangle_area", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "height", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float height" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float height" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "width", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float width" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float width" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3077, + "column": 1, + "source_line": "static float stbtt__sized_triangle_area(float height, float width)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 3077, + "column": 1, + "source_line": "static float stbtt__sized_triangle_area(float height, float width)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 3080, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbtt__fill_active_edges_new": { + "name": "stbtt__fill_active_edges_new", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "scanline", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *scanline", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *scanline", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "scanline_fill", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *scanline_fill", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *scanline_fill", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "e", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__active_edge *e", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__active_edge" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__active_edge *e", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__active_edge" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y_top", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y_top" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y_top" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3082, + "column": 1, + "source_line": "static void stbtt__fill_active_edges_new(float *scanline, float *scanline_fill, int len, stbtt__active_edge *e, float y_top)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 3082, + "column": 1, + "source_line": "static void stbtt__fill_active_edges_new(float *scanline, float *scanline_fill, int len, stbtt__active_edge *e, float y_top)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 3294, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbtt__sort_edges_ins_sort": { + "name": "stbtt__sort_edges_ins_sort", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__edge *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__edge" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__edge *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__edge" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3399, + "column": 1, + "source_line": "static void stbtt__sort_edges_ins_sort(stbtt__edge *p, int n)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 3399, + "column": 1, + "source_line": "static void stbtt__sort_edges_ins_sort(stbtt__edge *p, int n)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 3415, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbtt__sort_edges_quicksort": { + "name": "stbtt__sort_edges_quicksort", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__edge *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__edge" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__edge *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__edge" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3417, + "column": 1, + "source_line": "static void stbtt__sort_edges_quicksort(stbtt__edge *p, int n)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 3417, + "column": 1, + "source_line": "static void stbtt__sort_edges_quicksort(stbtt__edge *p, int n)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 3477, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbtt__sort_edges": { + "name": "stbtt__sort_edges", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__edge *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__edge" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__edge *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__edge" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3479, + "column": 1, + "source_line": "static void stbtt__sort_edges(stbtt__edge *p, int n)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 3479, + "column": 1, + "source_line": "static void stbtt__sort_edges(stbtt__edge *p, int n)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 3483, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbtt__rasterize": { + "name": "stbtt__rasterize", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "result", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__bitmap *result", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__bitmap" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__bitmap *result", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__bitmap" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "pts", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__point *pts", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__point" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__point *pts", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__point" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "wcount", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *wcount", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *wcount", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "windings", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int windings" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int windings" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "scale_x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float scale_x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float scale_x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "scale_y", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float scale_y" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float scale_y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "shift_x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float shift_x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float shift_x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "shift_y", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float shift_y" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float shift_y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "off_x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int off_x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int off_x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "off_y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int off_y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int off_y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "invert", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int invert" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int invert" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "userdata", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *userdata", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *userdata", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3490, + "column": 1, + "source_line": "static void stbtt__rasterize(stbtt__bitmap *result, stbtt__point *pts, int *wcount, int windings, float scale_x, float scale_y, float shift_x, float shift_y, int off_x, int off_y, int invert, void *userdata)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 3490, + "column": 1, + "source_line": "static void stbtt__rasterize(stbtt__bitmap *result, stbtt__point *pts, int *wcount, int windings, float scale_x, float scale_y, float shift_x, float shift_y, int off_x, int off_y, int invert, void *userdata)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 3545, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbtt__add_point": { + "name": "stbtt__add_point", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "points", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__point *points", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__point" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__point *points", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__point" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3547, + "column": 1, + "source_line": "static void stbtt__add_point(stbtt__point *points, int n, float x, float y)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 3547, + "column": 1, + "source_line": "static void stbtt__add_point(stbtt__point *points, int n, float x, float y)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 3552, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbtt__tesselate_curve": { + "name": "stbtt__tesselate_curve", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "points", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__point *points", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__point" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__point *points", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__point" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "num_points", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *num_points", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *num_points", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x0", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x0" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y0", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y0" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x1", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x1" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y1", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y1" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x2", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x2" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x2" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y2", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y2" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y2" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "objspace_flatness_squared", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float objspace_flatness_squared" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float objspace_flatness_squared" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3555, + "column": 1, + "source_line": "static int stbtt__tesselate_curve(stbtt__point *points, int *num_points, float x0, float y0, float x1, float y1, float x2, float y2, float objspace_flatness_squared, int n)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 3555, + "column": 1, + "source_line": "static int stbtt__tesselate_curve(stbtt__point *points, int *num_points, float x0, float y0, float x1, float y1, float x2, float y2, float objspace_flatness_squared, int n)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 3573, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbtt__tesselate_cubic": { + "name": "stbtt__tesselate_cubic", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "points", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__point *points", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__point" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__point *points", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__point" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "num_points", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *num_points", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *num_points", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x0", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x0" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y0", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y0" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x1", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x1" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y1", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y1" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x2", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x2" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x2" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y2", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y2" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y2" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x3", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x3" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x3" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y3", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y3" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y3" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "objspace_flatness_squared", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float objspace_flatness_squared" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float objspace_flatness_squared" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3575, + "column": 1, + "source_line": "static void stbtt__tesselate_cubic(stbtt__point *points, int *num_points, float x0, float y0, float x1, float y1, float x2, float y2, float x3, float y3, float objspace_flatness_squared, int n)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 3575, + "column": 1, + "source_line": "static void stbtt__tesselate_cubic(stbtt__point *points, int *num_points, float x0, float y0, float x1, float y1, float x2, float y2, float x3, float y3, float objspace_flatness_squared, int n)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 3615, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbtt_FlattenCurves": { + "name": "stbtt_FlattenCurves", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt__point", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt__point" + } + ] + }, + "parameters": [ + { + "name": "vertices", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_vertex *vertices", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_vertex" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_vertex *vertices", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_vertex" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "num_verts", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_verts" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_verts" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "objspace_flatness", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float objspace_flatness" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float objspace_flatness" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "contour_lengths", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int **contour_lengths", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int **contour_lengths", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "num_contours", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *num_contours", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *num_contours", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "userdata", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *userdata", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *userdata", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3618, + "column": 1, + "source_line": "static stbtt__point *stbtt_FlattenCurves(stbtt_vertex *vertices, int num_verts, float objspace_flatness, int **contour_lengths, int *num_contours, void *userdata)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 3618, + "column": 1, + "source_line": "static stbtt__point *stbtt_FlattenCurves(stbtt_vertex *vertices, int num_verts, float objspace_flatness, int **contour_lengths, int *num_contours, void *userdata)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 3693, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbtt_BakeFontBitmap_internal": { + "name": "stbtt_BakeFontBitmap_internal", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "offset", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int offset" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int offset" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "pixel_height", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float pixel_height" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float pixel_height" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "pixels", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *pixels", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *pixels", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "pw", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int pw" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int pw" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ph", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ph" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ph" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "first_char", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int first_char" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int first_char" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "num_chars", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_chars" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_chars" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "chardata", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_bakedchar *chardata", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_bakedchar" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_bakedchar *chardata", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_bakedchar" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3813, + "column": 1, + "source_line": "static int stbtt_BakeFontBitmap_internal(unsigned char *data, int offset, // font location (use offset=0 for plain .ttf)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 3813, + "column": 1, + "source_line": "static int stbtt_BakeFontBitmap_internal(unsigned char *data, int offset, // font location (use offset=0 for plain .ttf)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 3857, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbrp_init_target": { + "name": "stbrp_init_target", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "con", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbrp_context *con", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbrp_context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbrp_context *con", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbrp_context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "pw", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int pw" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int pw" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ph", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ph" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ph" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "nodes", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbrp_node *nodes", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbrp_node" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbrp_node *nodes", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbrp_node" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "num_nodes", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_nodes" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_nodes" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3917, + "column": 1, + "source_line": "static void stbrp_init_target(stbrp_context *con, int pw, int ph, stbrp_node *nodes, int num_nodes)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 3917, + "column": 1, + "source_line": "static void stbrp_init_target(stbrp_context *con, int pw, int ph, stbrp_node *nodes, int num_nodes)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 3926, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbrp_pack_rects": { + "name": "stbrp_pack_rects", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "con", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbrp_context *con", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbrp_context" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbrp_context *con", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbrp_context" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "rects", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbrp_rect *rects", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbrp_rect" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbrp_rect *rects", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbrp_rect" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "num_rects", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_rects" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_rects" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3928, + "column": 1, + "source_line": "static void stbrp_pack_rects(stbrp_context *con, stbrp_rect *rects, int num_rects)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 3928, + "column": 1, + "source_line": "static void stbrp_pack_rects(stbrp_context *con, stbrp_rect *rects, int num_rects)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 3947, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbtt__h_prefilter": { + "name": "stbtt__h_prefilter", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "pixels", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *pixels", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *pixels", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "w", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "h", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "stride_in_bytes", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int stride_in_bytes" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int stride_in_bytes" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "kernel_width", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int kernel_width" + }, + "declared_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int kernel_width" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 4012, + "column": 1, + "source_line": "static void stbtt__h_prefilter(unsigned char *pixels, int w, int h, int stride_in_bytes, unsigned int kernel_width)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 4012, + "column": 1, + "source_line": "static void stbtt__h_prefilter(unsigned char *pixels, int w, int h, int stride_in_bytes, unsigned int kernel_width)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 4072, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbtt__v_prefilter": { + "name": "stbtt__v_prefilter", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "pixels", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *pixels", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *pixels", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "w", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int w" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "h", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int h" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "stride_in_bytes", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int stride_in_bytes" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int stride_in_bytes" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "kernel_width", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int kernel_width" + }, + "declared_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int kernel_width" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 4074, + "column": 1, + "source_line": "static void stbtt__v_prefilter(unsigned char *pixels, int w, int h, int stride_in_bytes, unsigned int kernel_width)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 4074, + "column": 1, + "source_line": "static void stbtt__v_prefilter(unsigned char *pixels, int w, int h, int stride_in_bytes, unsigned int kernel_width)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 4134, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbtt__oversample_shift": { + "name": "stbtt__oversample_shift", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "oversample", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int oversample" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int oversample" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 4136, + "column": 1, + "source_line": "static float stbtt__oversample_shift(int oversample)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 4136, + "column": 1, + "source_line": "static float stbtt__oversample_shift(int oversample)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 4146, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbtt__ray_intersect_bezier": { + "name": "stbtt__ray_intersect_bezier", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "orig", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float orig[2]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float orig[2]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "2", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ray", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float ray[2]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float ray[2]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "2", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "q0", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float q0[2]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float q0[2]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "2", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "q1", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float q1[2]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float q1[2]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "2", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "q2", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float q2[2]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float q2[2]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "2", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "hits", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float hits[2][2]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "2", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float hits[2][2]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "2", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "2", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 4398, + "column": 1, + "source_line": "static int stbtt__ray_intersect_bezier(float orig[2], float ray[2], float q0[2], float q1[2], float q2[2], float hits[2][2])" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 4398, + "column": 1, + "source_line": "static int stbtt__ray_intersect_bezier(float orig[2], float ray[2], float q0[2], float q1[2], float q2[2], float hits[2][2])" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 4460, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "equal": { + "name": "equal", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *a", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *b", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *b", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 4462, + "column": 1, + "source_line": "static int equal(float *a, float *b)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 4462, + "column": 1, + "source_line": "static int equal(float *a, float *b)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 4465, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbtt__compute_crossings_x": { + "name": "stbtt__compute_crossings_x", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "nverts", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int nverts" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int nverts" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "verts", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_vertex *verts", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_vertex" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_vertex *verts", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_vertex" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 4467, + "column": 1, + "source_line": "static int stbtt__compute_crossings_x(float x, float y, int nverts, stbtt_vertex *verts)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 4467, + "column": 1, + "source_line": "static int stbtt__compute_crossings_x(float x, float y, int nverts, stbtt_vertex *verts)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 4533, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbtt__cuberoot": { + "name": "stbtt__cuberoot", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 4535, + "column": 1, + "source_line": "static float stbtt__cuberoot( float x )" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 4535, + "column": 1, + "source_line": "static float stbtt__cuberoot( float x )" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 4541, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbtt__solve_cubic": { + "name": "stbtt__solve_cubic", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float a" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float a" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float b" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float b" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float c" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float c" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "r", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float * r", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 4544, + "column": 1, + "source_line": "static int stbtt__solve_cubic(float a, float b, float c, float* r)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 4544, + "column": 1, + "source_line": "static int stbtt__solve_cubic(float a, float b, float c, float* r)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 4573, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbtt__CompareUTF8toUTF16_bigendian_prefix": { + "name": "stbtt__CompareUTF8toUTF16_bigendian_prefix", + "result_type": { + "reference": "stbtt_int32" + }, + "parameters": [ + { + "name": "s1", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_uint8 *s1", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_uint8" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_uint8 *s1", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_uint8" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len1", + "type": { + "reference": "stbtt_int32" + }, + "declared_type": { + "reference": "stbtt_int32" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "s2", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_uint8 *s2", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_uint8" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_uint8 *s2", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_uint8" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len2", + "type": { + "reference": "stbtt_int32" + }, + "declared_type": { + "reference": "stbtt_int32" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 4778, + "column": 1, + "source_line": "static stbtt_int32 stbtt__CompareUTF8toUTF16_bigendian_prefix(stbtt_uint8 *s1, stbtt_int32 len1, stbtt_uint8 *s2, stbtt_int32 len2)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 4778, + "column": 1, + "source_line": "static stbtt_int32 stbtt__CompareUTF8toUTF16_bigendian_prefix(stbtt_uint8 *s1, stbtt_int32 len1, stbtt_uint8 *s2, stbtt_int32 len2)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 4815, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbtt_CompareUTF8toUTF16_bigendian_internal": { + "name": "stbtt_CompareUTF8toUTF16_bigendian_internal", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "s1", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *s1", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *s1", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "s2", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *s2", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *s2", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len2", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len2" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len2" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 4817, + "column": 1, + "source_line": "static int stbtt_CompareUTF8toUTF16_bigendian_internal(char *s1, int len1, char *s2, int len2)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 4817, + "column": 1, + "source_line": "static int stbtt_CompareUTF8toUTF16_bigendian_internal(char *s1, int len1, char *s2, int len2)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 4820, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbtt__matchpair": { + "name": "stbtt__matchpair", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "fc", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_uint8 *fc", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_uint8" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_uint8 *fc", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_uint8" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "nm", + "type": { + "reference": "stbtt_uint32" + }, + "declared_type": { + "reference": "stbtt_uint32" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "name", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_uint8 *name", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_uint8" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_uint8 *name", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_uint8" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "nlen", + "type": { + "reference": "stbtt_int32" + }, + "declared_type": { + "reference": "stbtt_int32" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "target_id", + "type": { + "reference": "stbtt_int32" + }, + "declared_type": { + "reference": "stbtt_int32" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "next_id", + "type": { + "reference": "stbtt_int32" + }, + "declared_type": { + "reference": "stbtt_int32" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 4845, + "column": 1, + "source_line": "static int stbtt__matchpair(stbtt_uint8 *fc, stbtt_uint32 nm, stbtt_uint8 *name, stbtt_int32 nlen, stbtt_int32 target_id, stbtt_int32 next_id)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 4845, + "column": 1, + "source_line": "static int stbtt__matchpair(stbtt_uint8 *fc, stbtt_uint32 nm, stbtt_uint8 *name, stbtt_int32 nlen, stbtt_int32 target_id, stbtt_int32 next_id)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 4890, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbtt__matches": { + "name": "stbtt__matches", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "fc", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_uint8 *fc", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_uint8" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_uint8 *fc", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_uint8" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "offset", + "type": { + "reference": "stbtt_uint32" + }, + "declared_type": { + "reference": "stbtt_uint32" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "name", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_uint8 *name", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_uint8" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_uint8 *name", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbtt_uint8" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "flags", + "type": { + "reference": "stbtt_int32" + }, + "declared_type": { + "reference": "stbtt_int32" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 4892, + "column": 1, + "source_line": "static int stbtt__matches(stbtt_uint8 *fc, stbtt_uint32 offset, stbtt_uint8 *name, stbtt_int32 flags)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 4892, + "column": 1, + "source_line": "static int stbtt__matches(stbtt_uint8 *fc, stbtt_uint32 offset, stbtt_uint8 *name, stbtt_int32 flags)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 4919, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbtt_FindMatchingFont_internal": { + "name": "stbtt_FindMatchingFont_internal", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "font_collection", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *font_collection", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *font_collection", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "name_utf8", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *name_utf8", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *name_utf8", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "flags", + "type": { + "reference": "stbtt_int32" + }, + "declared_type": { + "reference": "stbtt_int32" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 4921, + "column": 1, + "source_line": "static int stbtt_FindMatchingFont_internal(unsigned char *font_collection, char *name_utf8, stbtt_int32 flags)" + }, + "start": { + "filename": "stb/stb_truetype.h", + "line": 4921, + "column": 1, + "source_line": "static int stbtt_FindMatchingFont_internal(unsigned char *font_collection, char *name_utf8, stbtt_int32 flags)" + }, + "end": { + "filename": "stb/stb_truetype.h", + "line": 4930, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + } + }, + "structs": { + "stbtt__hheap_chunk": { + "reference": "struct stbtt__hheap_chunk" + }, + "stbtt__hheap": { + "reference": "struct stbtt__hheap" + }, + "stbtt__edge": { + "reference": "struct stbtt__edge" + }, + "stbtt__active_edge": { + "reference": "struct stbtt__active_edge" + }, + "stbrp_rect": { + "reference": "struct stbrp_rect" + } + }, + "unions": {}, + "enums": {}, + "typedefs": { + "stbtt_uint8": { + "reference": "stbtt_uint8" + }, + "stbtt_int8": { + "reference": "stbtt_int8" + }, + "stbtt_uint16": { + "reference": "stbtt_uint16" + }, + "stbtt_int16": { + "reference": "stbtt_int16" + }, + "stbtt_uint32": { + "reference": "stbtt_uint32" + }, + "stbtt_int32": { + "reference": "stbtt_int32" + }, + "stbtt__check_size32": { + "reference": "stbtt__check_size32" + }, + "stbtt__check_size16": { + "reference": "stbtt__check_size16" + }, + "stbtt__test_oversample_pow2": { + "reference": "stbtt__test_oversample_pow2" + }, + "stbtt__csctx": { + "reference": "stbtt__csctx" + }, + "stbtt__hheap_chunk": { + "reference": "stbtt__hheap_chunk" + }, + "stbtt__hheap": { + "reference": "stbtt__hheap" + }, + "stbtt__edge": { + "reference": "stbtt__edge" + }, + "stbtt__active_edge": { + "reference": "stbtt__active_edge" + }, + "stbtt__point": { + "reference": "stbtt__point" + }, + "stbrp_coord": { + "reference": "stbrp_coord" + }, + "stbrp_context": { + "reference": "stbrp_context" + }, + "stbrp_node": { + "reference": "stbrp_node" + } + }, + "variables": { + "ttf_buffer": { + "name": "ttf_buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char ttf_buffer[1<<20]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "1<<20", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 281, + "column": 1, + "source_line": "unsigned char ttf_buffer[1<<20];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + "temp_bitmap": { + "name": "temp_bitmap", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char temp_bitmap[512*512]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "512*512", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 282, + "column": 1, + "source_line": "unsigned char temp_bitmap[512*512];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + "cdata": { + "name": "cdata", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbtt_bakedchar cdata[96]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "96", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "reference": "stbtt_bakedchar" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 284, + "column": 1, + "source_line": "stbtt_bakedchar cdata[96]; // ASCII 32..126 is 95 glyphs" + }, + "callback_policy": null, + "declaration_locations": [] + }, + "ftex": { + "name": "ftex", + "type": { + "reference": "GLuint" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 285, + "column": 1, + "source_line": "GLuint ftex;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + "buffer": { + "name": "buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char buffer[24<<20]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "24<<20", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 372, + "column": 1, + "source_line": "char buffer[24<<20];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + "screen": { + "name": "screen", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char screen[20][79]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "20", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "79", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 373, + "column": 1, + "source_line": "unsigned char screen[20][79];" + }, + "callback_policy": null, + "declaration_locations": [] + } + }, + "macros": { + "STB_TRUETYPE_IMPLEMENTATION": { + "name": "STB_TRUETYPE_IMPLEMENTATION", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 329, + "column": 1, + "source_line": "#define STB_TRUETYPE_IMPLEMENTATION // force following include to generate implementation" + } + }, + "STBTT_ifloor": { + "name": "STBTT_ifloor", + "value": "((int) floor(x))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 442, + "column": 4, + "source_line": " #define STBTT_ifloor(x) ((int) floor(x))" + } + }, + "STBTT_iceil": { + "name": "STBTT_iceil", + "value": "((int) ceil(x))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 443, + "column": 4, + "source_line": " #define STBTT_iceil(x) ((int) ceil(x))" + } + }, + "STBTT_sqrt": { + "name": "STBTT_sqrt", + "value": "sqrt(x)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 448, + "column": 4, + "source_line": " #define STBTT_sqrt(x) sqrt(x)" + } + }, + "STBTT_pow": { + "name": "STBTT_pow", + "value": "pow(x,y)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 449, + "column": 4, + "source_line": " #define STBTT_pow(x,y) pow(x,y)" + } + }, + "STBTT_fmod": { + "name": "STBTT_fmod", + "value": "fmod(x,y)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 454, + "column": 4, + "source_line": " #define STBTT_fmod(x,y) fmod(x,y)" + } + }, + "STBTT_cos": { + "name": "STBTT_cos", + "value": "cos(x)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 459, + "column": 4, + "source_line": " #define STBTT_cos(x) cos(x)" + } + }, + "STBTT_acos": { + "name": "STBTT_acos", + "value": "acos(x)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 460, + "column": 4, + "source_line": " #define STBTT_acos(x) acos(x)" + } + }, + "STBTT_fabs": { + "name": "STBTT_fabs", + "value": "fabs(x)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 465, + "column": 4, + "source_line": " #define STBTT_fabs(x) fabs(x)" + } + }, + "STBTT_malloc": { + "name": "STBTT_malloc", + "value": "((void)(u),malloc(x))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 471, + "column": 4, + "source_line": " #define STBTT_malloc(x,u) ((void)(u),malloc(x))" + } + }, + "STBTT_free": { + "name": "STBTT_free", + "value": "((void)(u),free(x))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 472, + "column": 4, + "source_line": " #define STBTT_free(x,u) ((void)(u),free(x))" + } + }, + "STBTT_assert": { + "name": "STBTT_assert", + "value": "assert(x)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 477, + "column": 4, + "source_line": " #define STBTT_assert(x) assert(x)" + } + }, + "STBTT_strlen": { + "name": "STBTT_strlen", + "value": "strlen(x)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 482, + "column": 4, + "source_line": " #define STBTT_strlen(x) strlen(x)" + } + }, + "STBTT_memcpy": { + "name": "STBTT_memcpy", + "value": "memcpy", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 487, + "column": 4, + "source_line": " #define STBTT_memcpy memcpy" + } + }, + "STBTT_memset": { + "name": "STBTT_memset", + "value": "memset", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 488, + "column": 4, + "source_line": " #define STBTT_memset memset" + } + }, + "__STB_INCLUDE_STB_TRUETYPE_H__": { + "name": "__STB_INCLUDE_STB_TRUETYPE_H__", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 500, + "column": 1, + "source_line": "#define __STB_INCLUDE_STB_TRUETYPE_H__" + } + }, + "STBTT_DEF": { + "name": "STBTT_DEF", + "value": "extern", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 505, + "column": 1, + "source_line": "#define STBTT_DEF extern" + } + }, + "STBTT_POINT_SIZE": { + "name": "STBTT_POINT_SIZE", + "value": "(-(x))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 602, + "column": 1, + "source_line": "#define STBTT_POINT_SIZE(x) (-(x))" + } + }, + "stbtt_vertex_type": { + "name": "stbtt_vertex_type", + "value": "short", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 834, + "column": 4, + "source_line": " #define stbtt_vertex_type short // can't use stbtt_int16 because that's not visible in the header file" + } + }, + "STBTT_MACSTYLE_DONTCARE": { + "name": "STBTT_MACSTYLE_DONTCARE", + "value": "0", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1026, + "column": 1, + "source_line": "#define STBTT_MACSTYLE_DONTCARE 0" + } + }, + "STBTT_MACSTYLE_BOLD": { + "name": "STBTT_MACSTYLE_BOLD", + "value": "1", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1027, + "column": 1, + "source_line": "#define STBTT_MACSTYLE_BOLD 1" + } + }, + "STBTT_MACSTYLE_ITALIC": { + "name": "STBTT_MACSTYLE_ITALIC", + "value": "2", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1028, + "column": 1, + "source_line": "#define STBTT_MACSTYLE_ITALIC 2" + } + }, + "STBTT_MACSTYLE_UNDERSCORE": { + "name": "STBTT_MACSTYLE_UNDERSCORE", + "value": "4", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1029, + "column": 1, + "source_line": "#define STBTT_MACSTYLE_UNDERSCORE 4" + } + }, + "STBTT_MACSTYLE_NONE": { + "name": "STBTT_MACSTYLE_NONE", + "value": "8", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1030, + "column": 1, + "source_line": "#define STBTT_MACSTYLE_NONE 8 // <= not same as 0, this makes us check the bitfield is 0" + } + }, + "STBTT_MAX_OVERSAMPLE": { + "name": "STBTT_MAX_OVERSAMPLE", + "value": "8", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1109, + "column": 1, + "source_line": "#define STBTT_MAX_OVERSAMPLE 8" + } + }, + "STBTT_RASTERIZER_VERSION": { + "name": "STBTT_RASTERIZER_VERSION", + "value": "2", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1119, + "column": 1, + "source_line": "#define STBTT_RASTERIZER_VERSION 2" + } + }, + "STBTT__NOTUSED": { + "name": "STBTT__NOTUSED", + "value": "(void)sizeof(v)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1125, + "column": 1, + "source_line": "#define STBTT__NOTUSED(v) (void)sizeof(v)" + } + }, + "stbtt__buf_get16": { + "name": "stbtt__buf_get16", + "value": "stbtt__buf_get((b), 2)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1178, + "column": 1, + "source_line": "#define stbtt__buf_get16(b) stbtt__buf_get((b), 2)" + } + }, + "stbtt__buf_get32": { + "name": "stbtt__buf_get32", + "value": "stbtt__buf_get((b), 4)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1179, + "column": 1, + "source_line": "#define stbtt__buf_get32(b) stbtt__buf_get((b), 4)" + } + }, + "ttBYTE": { + "name": "ttBYTE", + "value": "(* (stbtt_uint8 *) (p))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1282, + "column": 1, + "source_line": "#define ttBYTE(p) (* (stbtt_uint8 *) (p))" + } + }, + "ttCHAR": { + "name": "ttCHAR", + "value": "(* (stbtt_int8 *) (p))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1283, + "column": 1, + "source_line": "#define ttCHAR(p) (* (stbtt_int8 *) (p))" + } + }, + "ttFixed": { + "name": "ttFixed", + "value": "ttLONG(p)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1284, + "column": 1, + "source_line": "#define ttFixed(p) ttLONG(p)" + } + }, + "stbtt_tag4": { + "name": "stbtt_tag4", + "value": "((p)[0] == (c0) && (p)[1] == (c1) && (p)[2] == (c2) && (p)[3] == (c3))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1291, + "column": 1, + "source_line": "#define stbtt_tag4(p,c0,c1,c2,c3) ((p)[0] == (c0) && (p)[1] == (c1) && (p)[2] == (c2) && (p)[3] == (c3))" + } + }, + "stbtt_tag": { + "name": "stbtt_tag", + "value": "stbtt_tag4(p,str[0],str[1],str[2],str[3])", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1292, + "column": 1, + "source_line": "#define stbtt_tag(p,str) stbtt_tag4(p,str[0],str[1],str[2],str[3])" + } + }, + "STBTT__CSCTX_INIT": { + "name": "STBTT__CSCTX_INIT", + "value": "{bounds,0, 0,0, 0,0, 0,0,0,0, NULL, 0}", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 1909, + "column": 1, + "source_line": "#define STBTT__CSCTX_INIT(bounds) {bounds,0, 0,0, 0,0, 0,0,0,0, NULL, 0}" + } + }, + "STBTT__CSERR": { + "name": "STBTT__CSERR", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2266, + "column": 1, + "source_line": "#undef STBTT__CSERR" + } + }, + "STBTT_GPOS_TODO_assert": { + "name": "STBTT_GPOS_TODO_assert", + "value": null, + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2494, + "column": 1, + "source_line": "#define STBTT_GPOS_TODO_assert(x)" + } + }, + "STBTT_FIXSHIFT": { + "name": "STBTT_FIXSHIFT", + "value": "10", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2831, + "column": 1, + "source_line": "#define STBTT_FIXSHIFT 10" + } + }, + "STBTT_FIX": { + "name": "STBTT_FIX", + "value": "(1 << STBTT_FIXSHIFT)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2832, + "column": 1, + "source_line": "#define STBTT_FIX (1 << STBTT_FIXSHIFT)" + } + }, + "STBTT_FIXMASK": { + "name": "STBTT_FIXMASK", + "value": "(STBTT_FIX-1)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 2833, + "column": 1, + "source_line": "#define STBTT_FIXMASK (STBTT_FIX-1)" + } + }, + "STBTT__COMPARE": { + "name": "STBTT__COMPARE", + "value": "((a)->y0 < (b)->y0)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 3397, + "column": 1, + "source_line": "#define STBTT__COMPARE(a,b) ((a)->y0 < (b)->y0)" + } + }, + "STBTT__OVER_MASK": { + "name": "STBTT__OVER_MASK", + "value": "(STBTT_MAX_OVERSAMPLE-1)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 4010, + "column": 1, + "source_line": "#define STBTT__OVER_MASK (STBTT_MAX_OVERSAMPLE-1)" + } + }, + "STBTT_min": { + "name": "STBTT_min", + "value": "((a) < (b) ? (a) : (b))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 4395, + "column": 1, + "source_line": "#define STBTT_min(a,b) ((a) < (b) ? (a) : (b))" + } + }, + "STBTT_max": { + "name": "STBTT_max", + "value": "((a) < (b) ? (b) : (a))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 4396, + "column": 1, + "source_line": "#define STBTT_max(a,b) ((a) < (b) ? (b) : (a))" + } + } + }, + "includes": { + "stb/stb_truetype.h:stb_truetype.h": { + "target": "stb_truetype.h", + "kind": "local", + "resolved_path": "stb/stb_truetype.h", + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 330, + "column": 1, + "source_line": "#include \"stb_truetype.h\"" + } + }, + "stb/stb_truetype.h:stdio.h": { + "target": "stdio.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 328, + "column": 1, + "source_line": "#include " + } + }, + "stb/stb_truetype.h:math.h": { + "target": "math.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 464, + "column": 4, + "source_line": " #include " + } + }, + "stb/stb_truetype.h:stdlib.h": { + "target": "stdlib.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 470, + "column": 4, + "source_line": " #include " + } + }, + "stb/stb_truetype.h:assert.h": { + "target": "assert.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 476, + "column": 4, + "source_line": " #include " + } + }, + "stb/stb_truetype.h:string.h": { + "target": "string.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_truetype.h", + "line": 486, + "column": 4, + "source_line": " #include " + } + } + }, + "functions_by_file": { + "stb/stb_truetype.h": [ + "my_stbtt_initfont", + "my_stbtt_print", + "main", + "stbtt__buf_get8", + "stbtt__buf_peek8", + "stbtt__buf_seek", + "stbtt__buf_skip", + "stbtt__buf_get", + "stbtt__new_buf", + "stbtt__buf_range", + "stbtt__cff_get_index", + "stbtt__cff_int", + "stbtt__cff_skip_operand", + "stbtt__dict_get", + "stbtt__dict_get_ints", + "stbtt__cff_index_count", + "stbtt__cff_index_get", + "ttUSHORT", + "ttSHORT", + "ttULONG", + "ttLONG", + "stbtt__isfont", + "stbtt__find_table", + "stbtt_GetFontOffsetForIndex_internal", + "stbtt_GetNumberOfFonts_internal", + "stbtt__get_subrs", + "stbtt__get_svg", + "stbtt_InitFont_internal", + "stbtt_setvertex", + "stbtt__GetGlyfOffset", + "stbtt__GetGlyphInfoT2", + "stbtt__close_shape", + "stbtt__GetGlyphShapeTT", + "stbtt__track_vertex", + "stbtt__csctx_v", + "stbtt__csctx_close_shape", + "stbtt__csctx_rmove_to", + "stbtt__csctx_rline_to", + "stbtt__csctx_rccurve_to", + "stbtt__get_subr", + "stbtt__cid_get_glyph_subrs", + "stbtt__run_charstring", + "stbtt__GetGlyphShapeT2", + "stbtt__GetGlyphKernInfoAdvance", + "stbtt__GetCoverageIndex", + "stbtt__GetGlyphClass", + "stbtt__GetGlyphGPOSInfoAdvance", + "stbtt__hheap_alloc", + "stbtt__hheap_free", + "stbtt__hheap_cleanup", + "stbtt__new_active", + "stbtt__fill_active_edges", + "stbtt__rasterize_sorted_edges", + "stbtt__handle_clipped_edge", + "stbtt__sized_trapezoid_area", + "stbtt__position_trapezoid_area", + "stbtt__sized_triangle_area", + "stbtt__fill_active_edges_new", + "stbtt__sort_edges_ins_sort", + "stbtt__sort_edges_quicksort", + "stbtt__sort_edges", + "stbtt__rasterize", + "stbtt__add_point", + "stbtt__tesselate_curve", + "stbtt__tesselate_cubic", + "stbtt_FlattenCurves", + "stbtt_BakeFontBitmap_internal", + "stbrp_init_target", + "stbrp_pack_rects", + "stbtt__h_prefilter", + "stbtt__v_prefilter", + "stbtt__oversample_shift", + "stbtt__ray_intersect_bezier", + "equal", + "stbtt__compute_crossings_x", + "stbtt__cuberoot", + "stbtt__solve_cubic", + "stbtt__CompareUTF8toUTF16_bigendian_prefix", + "stbtt_CompareUTF8toUTF16_bigendian_internal", + "stbtt__matchpair", + "stbtt__matches", + "stbtt_FindMatchingFont_internal" + ] + }, + "enum_constants": {}, + "include_graph": { + "stb/stb_truetype.h": [ + "stb/stb_truetype.h" + ] + }, + "system_includes": { + "stb/stb_truetype.h": [ + "assert.h", + "math.h", + "stdio.h", + "stdlib.h", + "string.h" + ] + }, + "unresolved_includes": { + "stb/stb_truetype.h": [] + }, + "header_source_pairs": { + "stb/stb_truetype.h": [] + }, + "diagnostics": [ + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTT_ifloor' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 442, + "column": 4, + "source_line": " #define STBTT_ifloor(x) ((int) floor(x))" + }, + "unit_kind": "macro", + "unit_name": "STBTT_ifloor" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTT_iceil' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 443, + "column": 4, + "source_line": " #define STBTT_iceil(x) ((int) ceil(x))" + }, + "unit_kind": "macro", + "unit_name": "STBTT_iceil" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTT_sqrt' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 448, + "column": 4, + "source_line": " #define STBTT_sqrt(x) sqrt(x)" + }, + "unit_kind": "macro", + "unit_name": "STBTT_sqrt" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTT_pow' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 449, + "column": 4, + "source_line": " #define STBTT_pow(x,y) pow(x,y)" + }, + "unit_kind": "macro", + "unit_name": "STBTT_pow" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTT_fmod' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 454, + "column": 4, + "source_line": " #define STBTT_fmod(x,y) fmod(x,y)" + }, + "unit_kind": "macro", + "unit_name": "STBTT_fmod" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTT_cos' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 459, + "column": 4, + "source_line": " #define STBTT_cos(x) cos(x)" + }, + "unit_kind": "macro", + "unit_name": "STBTT_cos" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTT_acos' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 460, + "column": 4, + "source_line": " #define STBTT_acos(x) acos(x)" + }, + "unit_kind": "macro", + "unit_name": "STBTT_acos" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTT_fabs' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 465, + "column": 4, + "source_line": " #define STBTT_fabs(x) fabs(x)" + }, + "unit_kind": "macro", + "unit_name": "STBTT_fabs" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTT_malloc' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 471, + "column": 4, + "source_line": " #define STBTT_malloc(x,u) ((void)(u),malloc(x))" + }, + "unit_kind": "macro", + "unit_name": "STBTT_malloc" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTT_free' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 472, + "column": 4, + "source_line": " #define STBTT_free(x,u) ((void)(u),free(x))" + }, + "unit_kind": "macro", + "unit_name": "STBTT_free" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTT_assert' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 477, + "column": 4, + "source_line": " #define STBTT_assert(x) assert(x)" + }, + "unit_kind": "macro", + "unit_name": "STBTT_assert" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTT_strlen' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 482, + "column": 4, + "source_line": " #define STBTT_strlen(x) strlen(x)" + }, + "unit_kind": "macro", + "unit_name": "STBTT_strlen" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTT_POINT_SIZE' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 602, + "column": 1, + "source_line": "#define STBTT_POINT_SIZE(x) (-(x))" + }, + "unit_kind": "macro", + "unit_name": "STBTT_POINT_SIZE" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTT__NOTUSED' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 1123, + "column": 1, + "source_line": "#define STBTT__NOTUSED(v) (void)(v)" + }, + "unit_kind": "macro", + "unit_name": "STBTT__NOTUSED" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTT__NOTUSED' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 1125, + "column": 1, + "source_line": "#define STBTT__NOTUSED(v) (void)sizeof(v)" + }, + "unit_kind": "macro", + "unit_name": "STBTT__NOTUSED" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbtt__buf_get16' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 1178, + "column": 1, + "source_line": "#define stbtt__buf_get16(b) stbtt__buf_get((b), 2)" + }, + "unit_kind": "macro", + "unit_name": "stbtt__buf_get16" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbtt__buf_get32' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 1179, + "column": 1, + "source_line": "#define stbtt__buf_get32(b) stbtt__buf_get((b), 4)" + }, + "unit_kind": "macro", + "unit_name": "stbtt__buf_get32" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'ttBYTE' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 1282, + "column": 1, + "source_line": "#define ttBYTE(p) (* (stbtt_uint8 *) (p))" + }, + "unit_kind": "macro", + "unit_name": "ttBYTE" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'ttCHAR' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 1283, + "column": 1, + "source_line": "#define ttCHAR(p) (* (stbtt_int8 *) (p))" + }, + "unit_kind": "macro", + "unit_name": "ttCHAR" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'ttFixed' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 1284, + "column": 1, + "source_line": "#define ttFixed(p) ttLONG(p)" + }, + "unit_kind": "macro", + "unit_name": "ttFixed" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbtt_tag4' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 1291, + "column": 1, + "source_line": "#define stbtt_tag4(p,c0,c1,c2,c3) ((p)[0] == (c0) && (p)[1] == (c1) && (p)[2] == (c2) && (p)[3] == (c3))" + }, + "unit_kind": "macro", + "unit_name": "stbtt_tag4" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbtt_tag' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 1292, + "column": 1, + "source_line": "#define stbtt_tag(p,str) stbtt_tag4(p,str[0],str[1],str[2],str[3])" + }, + "unit_kind": "macro", + "unit_name": "stbtt_tag" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTT__CSCTX_INIT' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 1909, + "column": 1, + "source_line": "#define STBTT__CSCTX_INIT(bounds) {bounds,0, 0,0, 0,0, 0,0,0,0, NULL, 0}" + }, + "unit_kind": "macro", + "unit_name": "STBTT__CSCTX_INIT" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTT__CSERR' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 2018, + "column": 1, + "source_line": "#define STBTT__CSERR(s) (0)" + }, + "unit_kind": "macro", + "unit_name": "STBTT__CSERR" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTT_GPOS_TODO_assert' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 2494, + "column": 1, + "source_line": "#define STBTT_GPOS_TODO_assert(x)" + }, + "unit_kind": "macro", + "unit_name": "STBTT_GPOS_TODO_assert" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTT__COMPARE' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 3397, + "column": 1, + "source_line": "#define STBTT__COMPARE(a,b) ((a)->y0 < (b)->y0)" + }, + "unit_kind": "macro", + "unit_name": "STBTT__COMPARE" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTT_min' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 4395, + "column": 1, + "source_line": "#define STBTT_min(a,b) ((a) < (b) ? (a) : (b))" + }, + "unit_kind": "macro", + "unit_name": "STBTT_min" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBTT_max' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 4396, + "column": 1, + "source_line": "#define STBTT_max(a,b) ((a) < (b) ? (b) : (a))" + }, + "unit_kind": "macro", + "unit_name": "STBTT_max" + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '\"C\"'.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 509, + "column": 1, + "source_line": "extern \"C\" {" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 1496, + "column": 1, + "source_line": "STBTT_DEF int stbtt_FindGlyphIndex(const stbtt_fontinfo *info, int unicode_codepoint)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 1589, + "column": 1, + "source_line": "STBTT_DEF int stbtt_GetCodepointShape(const stbtt_fontinfo *info, int unicode_codepoint, stbtt_vertex **vertices)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 1625, + "column": 1, + "source_line": "STBTT_DEF int stbtt_GetGlyphBox(const stbtt_fontinfo *info, int glyph_index, int *x0, int *y0, int *x1, int *y1)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 1641, + "column": 1, + "source_line": "STBTT_DEF int stbtt_GetCodepointBox(const stbtt_fontinfo *info, int codepoint, int *x0, int *y0, int *x1, int *y1)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 1646, + "column": 1, + "source_line": "STBTT_DEF int stbtt_IsGlyphEmpty(const stbtt_fontinfo *info, int glyph_index)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 2297, + "column": 1, + "source_line": "STBTT_DEF int stbtt_GetGlyphShape(const stbtt_fontinfo *info, int glyph_index, stbtt_vertex **pvertices)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 2305, + "column": 1, + "source_line": "STBTT_DEF void stbtt_GetGlyphHMetrics(const stbtt_fontinfo *info, int glyph_index, int *advanceWidth, int *leftSideBearing)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 2317, + "column": 1, + "source_line": "STBTT_DEF int stbtt_GetKerningTableLength(const stbtt_fontinfo *info)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 2332, + "column": 1, + "source_line": "STBTT_DEF int stbtt_GetKerningTable(const stbtt_fontinfo *info, stbtt_kerningentry* table, int table_length)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 2610, + "column": 1, + "source_line": "STBTT_DEF int stbtt_GetGlyphKernAdvance(const stbtt_fontinfo *info, int g1, int g2)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 2622, + "column": 1, + "source_line": "STBTT_DEF int stbtt_GetCodepointKernAdvance(const stbtt_fontinfo *info, int ch1, int ch2)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 2629, + "column": 1, + "source_line": "STBTT_DEF void stbtt_GetCodepointHMetrics(const stbtt_fontinfo *info, int codepoint, int *advanceWidth, int *leftSideBearing)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 2634, + "column": 1, + "source_line": "STBTT_DEF void stbtt_GetFontVMetrics(const stbtt_fontinfo *info, int *ascent, int *descent, int *lineGap)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 2641, + "column": 1, + "source_line": "STBTT_DEF int stbtt_GetFontVMetricsOS2(const stbtt_fontinfo *info, int *typoAscent, int *typoDescent, int *typoLineGap)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 2652, + "column": 1, + "source_line": "STBTT_DEF void stbtt_GetFontBoundingBox(const stbtt_fontinfo *info, int *x0, int *y0, int *x1, int *y1)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 2660, + "column": 1, + "source_line": "STBTT_DEF float stbtt_ScaleForPixelHeight(const stbtt_fontinfo *info, float height)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 2666, + "column": 1, + "source_line": "STBTT_DEF float stbtt_ScaleForMappingEmToPixels(const stbtt_fontinfo *info, float pixels)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 2672, + "column": 1, + "source_line": "STBTT_DEF void stbtt_FreeShape(const stbtt_fontinfo *info, stbtt_vertex *v)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 2677, + "column": 1, + "source_line": "STBTT_DEF stbtt_uint8 *stbtt_FindSVGDoc(const stbtt_fontinfo *info, int gl)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 2694, + "column": 1, + "source_line": "STBTT_DEF int stbtt_GetGlyphSVG(const stbtt_fontinfo *info, int gl, const char **svg)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 2711, + "column": 1, + "source_line": "STBTT_DEF int stbtt_GetCodepointSVG(const stbtt_fontinfo *info, int unicode_codepoint, const char **svg)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 2721, + "column": 1, + "source_line": "STBTT_DEF void stbtt_GetGlyphBitmapBoxSubpixel(const stbtt_fontinfo *font, int glyph, float scale_x, float scale_y,float shift_x, float shift_y, int *ix0, int *iy0, int *ix1, int *iy1)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 2739, + "column": 1, + "source_line": "STBTT_DEF void stbtt_GetGlyphBitmapBox(const stbtt_fontinfo *font, int glyph, float scale_x, float scale_y, int *ix0, int *iy0, int *ix1, int *iy1)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 2744, + "column": 1, + "source_line": "STBTT_DEF void stbtt_GetCodepointBitmapBoxSubpixel(const stbtt_fontinfo *font, int codepoint, float scale_x, float scale_y, float shift_x, float shift_y, int *ix0, int *iy0, int *ix1, int *iy1)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 2749, + "column": 1, + "source_line": "STBTT_DEF void stbtt_GetCodepointBitmapBox(const stbtt_fontinfo *font, int codepoint, float scale_x, float scale_y, int *ix0, int *iy0, int *ix1, int *iy1)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 3695, + "column": 1, + "source_line": "STBTT_DEF void stbtt_Rasterize(stbtt__bitmap *result, float flatness_in_pixels, stbtt_vertex *vertices, int num_verts, float scale_x, float scale_y, float shift_x, float shift_y, int x_off, int y_off, int invert, void *userdata)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 3708, + "column": 1, + "source_line": "STBTT_DEF void stbtt_FreeBitmap(unsigned char *bitmap, void *userdata)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 3713, + "column": 1, + "source_line": "STBTT_DEF unsigned char *stbtt_GetGlyphBitmapSubpixel(const stbtt_fontinfo *info, float scale_x, float scale_y, float shift_x, float shift_y, int glyph, int *width, int *height, int *xoff, int *yoff)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 3753, + "column": 1, + "source_line": "STBTT_DEF unsigned char *stbtt_GetGlyphBitmap(const stbtt_fontinfo *info, float scale_x, float scale_y, int glyph, int *width, int *height, int *xoff, int *yoff)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 3758, + "column": 1, + "source_line": "STBTT_DEF void stbtt_MakeGlyphBitmapSubpixel(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int glyph)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 3777, + "column": 1, + "source_line": "STBTT_DEF void stbtt_MakeGlyphBitmap(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, int glyph)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 3782, + "column": 1, + "source_line": "STBTT_DEF unsigned char *stbtt_GetCodepointBitmapSubpixel(const stbtt_fontinfo *info, float scale_x, float scale_y, float shift_x, float shift_y, int codepoint, int *width, int *height, int *xoff, int *yoff)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 3787, + "column": 1, + "source_line": "STBTT_DEF void stbtt_MakeCodepointBitmapSubpixelPrefilter(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int oversample_x, int oversample_y, float *sub_x, float *sub_y, int codepoint)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 3792, + "column": 1, + "source_line": "STBTT_DEF void stbtt_MakeCodepointBitmapSubpixel(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int codepoint)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 3797, + "column": 1, + "source_line": "STBTT_DEF unsigned char *stbtt_GetCodepointBitmap(const stbtt_fontinfo *info, float scale_x, float scale_y, int codepoint, int *width, int *height, int *xoff, int *yoff)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 3802, + "column": 1, + "source_line": "STBTT_DEF void stbtt_MakeCodepointBitmap(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, int codepoint)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 3859, + "column": 1, + "source_line": "STBTT_DEF void stbtt_GetBakedQuad(const stbtt_bakedchar *chardata, int pw, int ph, int char_index, float *xpos, float *ypos, stbtt_aligned_quad *q, int opengl_fillrule)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 3957, + "column": 1, + "source_line": "STBTT_DEF int stbtt_PackBegin(stbtt_pack_context *spc, unsigned char *pixels, int pw, int ph, int stride_in_bytes, int padding, void *alloc_context)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 3989, + "column": 1, + "source_line": "STBTT_DEF void stbtt_PackEnd (stbtt_pack_context *spc)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 3995, + "column": 1, + "source_line": "STBTT_DEF void stbtt_PackSetOversampling(stbtt_pack_context *spc, unsigned int h_oversample, unsigned int v_oversample)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 4005, + "column": 1, + "source_line": "STBTT_DEF void stbtt_PackSetSkipMissingCodepoints(stbtt_pack_context *spc, int skip)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 4149, + "column": 1, + "source_line": "STBTT_DEF int stbtt_PackFontRangesGatherRects(stbtt_pack_context *spc, const stbtt_fontinfo *info, stbtt_pack_range *ranges, int num_ranges, stbrp_rect *rects)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 4184, + "column": 1, + "source_line": "STBTT_DEF void stbtt_MakeGlyphBitmapSubpixelPrefilter(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int prefilter_x, int prefilter_y, float *sub_x, float *sub_y, int glyph)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 4208, + "column": 1, + "source_line": "STBTT_DEF int stbtt_PackFontRangesRenderIntoRects(stbtt_pack_context *spc, const stbtt_fontinfo *info, stbtt_pack_range *ranges, int num_ranges, stbrp_rect *rects)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 4297, + "column": 1, + "source_line": "STBTT_DEF void stbtt_PackFontRangesPackRects(stbtt_pack_context *spc, stbrp_rect *rects, int num_rects)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 4302, + "column": 1, + "source_line": "STBTT_DEF int stbtt_PackFontRanges(stbtt_pack_context *spc, const unsigned char *fontdata, int font_index, stbtt_pack_range *ranges, int num_ranges)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 4338, + "column": 1, + "source_line": "STBTT_DEF int stbtt_PackFontRange(stbtt_pack_context *spc, const unsigned char *fontdata, int font_index, float font_size," + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 4350, + "column": 1, + "source_line": "STBTT_DEF void stbtt_GetScaledFontVMetrics(const unsigned char *fontdata, int index, float size, float *ascent, float *descent, float *lineGap)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 4363, + "column": 1, + "source_line": "STBTT_DEF void stbtt_GetPackedQuad(const stbtt_packedchar *chardata, int pw, int ph, int char_index, float *xpos, float *ypos, stbtt_aligned_quad *q, int align_to_integer)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 4575, + "column": 1, + "source_line": "STBTT_DEF unsigned char * stbtt_GetGlyphSDF(const stbtt_fontinfo *info, float scale, int glyph, int padding, unsigned char onedge_value, float pixel_dist_scale, int *width, int *height, int *xoff, int *yoff)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 4762, + "column": 1, + "source_line": "STBTT_DEF unsigned char * stbtt_GetCodepointSDF(const stbtt_fontinfo *info, float scale, int codepoint, int padding, unsigned char onedge_value, float pixel_dist_scale, int *width, int *height, int *xoff, int *yoff)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 4767, + "column": 1, + "source_line": "STBTT_DEF void stbtt_FreeSDF(unsigned char *bitmap, void *userdata)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 4824, + "column": 1, + "source_line": "STBTT_DEF const char *stbtt_GetFontNameString(const stbtt_fontinfo *font, int *length, int platformID, int encodingID, int languageID, int nameID)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 4937, + "column": 1, + "source_line": "STBTT_DEF int stbtt_BakeFontBitmap(const unsigned char *data, int offset," + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 4944, + "column": 1, + "source_line": "STBTT_DEF int stbtt_GetFontOffsetForIndex(const unsigned char *data, int index)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 4949, + "column": 1, + "source_line": "STBTT_DEF int stbtt_GetNumberOfFonts(const unsigned char *data)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 4954, + "column": 1, + "source_line": "STBTT_DEF int stbtt_InitFont(stbtt_fontinfo *info, const unsigned char *data, int offset)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 4959, + "column": 1, + "source_line": "STBTT_DEF int stbtt_FindMatchingFont(const unsigned char *fontdata, const char *name, int flags)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBTT_DEF'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_truetype.h", + "line": 4964, + "column": 1, + "source_line": "STBTT_DEF int stbtt_CompareUTF8toUTF16_bigendian(const char *s1, int len1, const char *s2, int len2)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBTT_DEF" + }, + { + "code": "C_CONFLICTING_VARIABLE_DECLARATION", + "message": "Conflicting declarations for variable 'ttf_buffer'.", + "severity": "error", + "location": { + "filename": "stb/stb_truetype.h", + "line": 332, + "column": 1, + "source_line": "char ttf_buffer[1<<25];" + }, + "unit_kind": "variable", + "unit_name": "ttf_buffer" + }, + { + "code": "C_DUPLICATE_FUNCTION_DEFINITION", + "message": "Duplicate definition for function 'main'.", + "severity": "error", + "location": { + "filename": "stb/stb_truetype.h", + "line": 375, + "column": 1, + "source_line": "int main(int arg, char **argv)" + }, + "unit_kind": "function", + "unit_name": "main" + }, + { + "code": "C_DUPLICATE_FUNCTION_DEFINITION", + "message": "Duplicate definition for function 'stbtt__new_active'.", + "severity": "error", + "location": { + "filename": "stb/stb_truetype.h", + "line": 2857, + "column": 1, + "source_line": "static stbtt__active_edge *stbtt__new_active(stbtt__hheap *hh, stbtt__edge *e, int off_x, float start_point, void *userdata)" + }, + "unit_kind": "function", + "unit_name": "stbtt__new_active" + }, + { + "code": "C_DUPLICATE_FUNCTION_DEFINITION", + "message": "Duplicate definition for function 'stbtt__rasterize_sorted_edges'.", + "severity": "error", + "location": { + "filename": "stb/stb_truetype.h", + "line": 3297, + "column": 1, + "source_line": "static void stbtt__rasterize_sorted_edges(stbtt__bitmap *result, stbtt__edge *e, int n, int vsubsample, int off_x, int off_y, void *userdata)" + }, + "unit_kind": "function", + "unit_name": "stbtt__rasterize_sorted_edges" + } + ] +} diff --git a/tests/parser/c/fixtures/stb/stb_vorbis.json b/tests/parser/c/fixtures/stb/stb_vorbis.json new file mode 100644 index 000000000..d8950af19 --- /dev/null +++ b/tests/parser/c/fixtures/stb/stb_vorbis.json @@ -0,0 +1,36550 @@ +{ + "files": { + "stb/stb_vorbis.c": { + "filename": "stb/stb_vorbis.c", + "language": "c", + "parser_status": "partial", + "preprocessing": "raw", + "functions": [ + { + "name": "error", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "vorb", + "name": "vorb", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": "stb_vorbis", + "members": [ + { + "name": "sample_rate", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int sample_rate" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 788, + "column": 4, + "source_line": " unsigned int sample_rate;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "channels", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int channels" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 789, + "column": 4, + "source_line": " int channels;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "setup_memory_required", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int setup_memory_required" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 791, + "column": 4, + "source_line": " unsigned int setup_memory_required;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "temp_memory_required", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int temp_memory_required" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 792, + "column": 4, + "source_line": " unsigned int temp_memory_required;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "setup_temp_memory_required", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int setup_temp_memory_required" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 793, + "column": 4, + "source_line": " unsigned int setup_temp_memory_required;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "vendor", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *vendor", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 795, + "column": 4, + "source_line": " char *vendor;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "comment_list_length", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int comment_list_length" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 796, + "column": 4, + "source_line": " int comment_list_length;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "comment_list", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char **comment_list", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 797, + "column": 4, + "source_line": " char **comment_list;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "FILE *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "FILE", + "name": "FILE", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 801, + "column": 4, + "source_line": " FILE *f;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "f_start", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "uint32", + "name": "uint32", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "typedef unsigned int uint32" + }, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 648, + "column": 1, + "source_line": "typedef unsigned int uint32;" + }, + "declaration_locations": [] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 802, + "column": 4, + "source_line": " uint32 f_start;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "close_on_free", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int close_on_free" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 803, + "column": 4, + "source_line": " int close_on_free;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "stream", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint8 *stream", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "uint8", + "name": "uint8", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "typedef unsigned char uint8" + }, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 644, + "column": 1, + "source_line": "typedef unsigned char uint8;" + }, + "declaration_locations": [] + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 806, + "column": 4, + "source_line": " uint8 *stream;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "stream_start", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint8 *stream_start", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint8" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 807, + "column": 4, + "source_line": " uint8 *stream_start;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "stream_end", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint8 *stream_end", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint8" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 808, + "column": 4, + "source_line": " uint8 *stream_end;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "stream_len", + "type": { + "reference": "uint32" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 810, + "column": 4, + "source_line": " uint32 stream_len;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "push_mode", + "type": { + "reference": "uint8" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 812, + "column": 4, + "source_line": " uint8 push_mode;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "first_audio_page_offset", + "type": { + "reference": "uint32" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 815, + "column": 4, + "source_line": " uint32 first_audio_page_offset;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "p_first", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "ProbedPage", + "name": "ProbedPage", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "page_start", + "type": { + "reference": "uint32" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 781, + "column": 4, + "source_line": " uint32 page_start, page_end;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "page_end", + "type": { + "reference": "uint32" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 781, + "column": 4, + "source_line": " uint32 page_start, page_end;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "last_decoded_sample", + "type": { + "reference": "uint32" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 782, + "column": 4, + "source_line": " uint32 last_decoded_sample;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_vorbis.c:779:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 779, + "column": 1, + "source_line": "typedef struct" + } + }, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 779, + "column": 1, + "source_line": "typedef struct" + }, + "declaration_locations": [] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 819, + "column": 4, + "source_line": " ProbedPage p_first, p_last;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "p_last", + "type": { + "reference": "ProbedPage" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 819, + "column": 4, + "source_line": " ProbedPage p_first, p_last;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "alloc", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stb_vorbis_alloc alloc", + "name": "stb_vorbis_alloc", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 822, + "column": 4, + "source_line": " stb_vorbis_alloc alloc;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "setup_offset", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int setup_offset" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 823, + "column": 4, + "source_line": " int setup_offset;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "temp_offset", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int temp_offset" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 824, + "column": 4, + "source_line": " int temp_offset;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "eof", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int eof" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 827, + "column": 4, + "source_line": " int eof;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "error", + "type": { + "model": "CEnum", + "qualifiers": [], + "source_text": "enum STBVorbisError error", + "name": "STBVorbisError", + "constants": [], + "anonymous_id": null, + "source_location": null + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 828, + "column": 4, + "source_line": " enum STBVorbisError error;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "blocksize", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int blocksize[2]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "2", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 833, + "column": 4, + "source_line": " int blocksize[2];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "blocksize_0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int blocksize_0" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 834, + "column": 4, + "source_line": " int blocksize_0, blocksize_1;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "blocksize_1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int blocksize_1" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 834, + "column": 4, + "source_line": " int blocksize_0, blocksize_1;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "codebook_count", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int codebook_count" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 835, + "column": 4, + "source_line": " int codebook_count;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "codebooks", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "Codebook *codebooks", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "Codebook", + "name": "Codebook", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "dimensions", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int dimensions" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 682, + "column": 4, + "source_line": " int dimensions, entries;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "entries", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int entries" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 682, + "column": 4, + "source_line": " int dimensions, entries;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "codeword_lengths", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint8 *codeword_lengths", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint8" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 683, + "column": 4, + "source_line": " uint8 *codeword_lengths;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "minimum_value", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float minimum_value" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 684, + "column": 4, + "source_line": " float minimum_value;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "delta_value", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float delta_value" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 685, + "column": 4, + "source_line": " float delta_value;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "value_bits", + "type": { + "reference": "uint8" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 686, + "column": 4, + "source_line": " uint8 value_bits;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "lookup_type", + "type": { + "reference": "uint8" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 687, + "column": 4, + "source_line": " uint8 lookup_type;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "sequence_p", + "type": { + "reference": "uint8" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 688, + "column": 4, + "source_line": " uint8 sequence_p;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "sparse", + "type": { + "reference": "uint8" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 689, + "column": 4, + "source_line": " uint8 sparse;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "lookup_values", + "type": { + "reference": "uint32" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 690, + "column": 4, + "source_line": " uint32 lookup_values;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "multiplicands", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "codetype *multiplicands", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "codetype", + "name": "codetype", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "typedef float codetype" + }, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 656, + "column": 1, + "source_line": "typedef float codetype;" + }, + "declaration_locations": [] + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 691, + "column": 4, + "source_line": " codetype *multiplicands;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "codewords", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint32 *codewords", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint32" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 692, + "column": 4, + "source_line": " uint32 *codewords;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "fast_huffman", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int16 fast_huffman[FAST_HUFFMAN_TABLE_SIZE]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "FAST_HUFFMAN_TABLE_SIZE", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "int16", + "name": "int16", + "type": { + "model": "CShort", + "qualifiers": [], + "source_text": "typedef signed short int16" + }, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 647, + "column": 1, + "source_line": "typedef signed short int16;" + }, + "declaration_locations": [] + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 694, + "column": 5, + "source_line": " int16 fast_huffman[FAST_HUFFMAN_TABLE_SIZE];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "fast_huffman", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int32 fast_huffman[FAST_HUFFMAN_TABLE_SIZE]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "FAST_HUFFMAN_TABLE_SIZE", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "int32", + "name": "int32", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "typedef signed int int32" + }, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 649, + "column": 1, + "source_line": "typedef signed int int32;" + }, + "declaration_locations": [] + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 696, + "column": 5, + "source_line": " int32 fast_huffman[FAST_HUFFMAN_TABLE_SIZE];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "sorted_codewords", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint32 *sorted_codewords", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint32" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 698, + "column": 4, + "source_line": " uint32 *sorted_codewords;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "sorted_values", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *sorted_values", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 699, + "column": 4, + "source_line": " int *sorted_values;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "sorted_entries", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int sorted_entries" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 700, + "column": 4, + "source_line": " int sorted_entries;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_vorbis.c:680:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 680, + "column": 1, + "source_line": "typedef struct" + } + }, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 680, + "column": 1, + "source_line": "typedef struct" + }, + "declaration_locations": [] + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 836, + "column": 4, + "source_line": " Codebook *codebooks;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "floor_count", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int floor_count" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 837, + "column": 4, + "source_line": " int floor_count;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "floor_types", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint16 floor_types[64]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "64", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "uint16", + "name": "uint16", + "type": { + "model": "CUnsignedShort", + "qualifiers": [], + "source_text": "typedef unsigned short uint16" + }, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 646, + "column": 1, + "source_line": "typedef unsigned short uint16;" + }, + "declaration_locations": [] + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 838, + "column": 4, + "source_line": " uint16 floor_types[64]; // varies" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "floor_config", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "Floor *floor_config", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "Floor", + "name": "Floor", + "type": { + "model": "CUnion", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "floor0", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "Floor0", + "name": "Floor0", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "order", + "type": { + "reference": "uint8" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 705, + "column": 4, + "source_line": " uint8 order;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "rate", + "type": { + "reference": "uint16" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 706, + "column": 4, + "source_line": " uint16 rate;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "bark_map_size", + "type": { + "reference": "uint16" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 707, + "column": 4, + "source_line": " uint16 bark_map_size;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "amplitude_bits", + "type": { + "reference": "uint8" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 708, + "column": 4, + "source_line": " uint8 amplitude_bits;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "amplitude_offset", + "type": { + "reference": "uint8" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 709, + "column": 4, + "source_line": " uint8 amplitude_offset;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "number_of_books", + "type": { + "reference": "uint8" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 710, + "column": 4, + "source_line": " uint8 number_of_books;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "book_list", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint8 book_list[16]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "16", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "reference": "uint8" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 711, + "column": 4, + "source_line": " uint8 book_list[16]; // varies" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_vorbis.c:703:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 703, + "column": 1, + "source_line": "typedef struct" + } + }, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 703, + "column": 1, + "source_line": "typedef struct" + }, + "declaration_locations": [] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 732, + "column": 4, + "source_line": " Floor0 floor0;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "floor1", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "Floor1", + "name": "Floor1", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "partitions", + "type": { + "reference": "uint8" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 716, + "column": 4, + "source_line": " uint8 partitions;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "partition_class_list", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint8 partition_class_list[32]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "32", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "reference": "uint8" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 717, + "column": 4, + "source_line": " uint8 partition_class_list[32]; // varies" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "class_dimensions", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint8 class_dimensions[16]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "16", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "reference": "uint8" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 718, + "column": 4, + "source_line": " uint8 class_dimensions[16]; // varies" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "class_subclasses", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint8 class_subclasses[16]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "16", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "reference": "uint8" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 719, + "column": 4, + "source_line": " uint8 class_subclasses[16]; // varies" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "class_masterbooks", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint8 class_masterbooks[16]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "16", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "reference": "uint8" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 720, + "column": 4, + "source_line": " uint8 class_masterbooks[16]; // varies" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "subclass_books", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int16 subclass_books[16][8]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "16", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "8", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "reference": "int16" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 721, + "column": 4, + "source_line": " int16 subclass_books[16][8]; // varies" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "Xlist", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint16 Xlist[31*8+2]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "31*8+2", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "reference": "uint16" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 722, + "column": 4, + "source_line": " uint16 Xlist[31*8+2]; // varies" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "sorted_order", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint8 sorted_order[31*8+2]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "31*8+2", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "reference": "uint8" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 723, + "column": 4, + "source_line": " uint8 sorted_order[31*8+2];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "neighbors", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint8 neighbors[31*8+2][2]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "31*8+2", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "2", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "reference": "uint8" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 724, + "column": 4, + "source_line": " uint8 neighbors[31*8+2][2];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "floor1_multiplier", + "type": { + "reference": "uint8" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 725, + "column": 4, + "source_line": " uint8 floor1_multiplier;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "rangebits", + "type": { + "reference": "uint8" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 726, + "column": 4, + "source_line": " uint8 rangebits;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "values", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int values" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 727, + "column": 4, + "source_line": " int values;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_vorbis.c:714:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 714, + "column": 1, + "source_line": "typedef struct" + } + }, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 714, + "column": 1, + "source_line": "typedef struct" + }, + "declaration_locations": [] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 733, + "column": 4, + "source_line": " Floor1 floor1;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "union@stb/stb_vorbis.c:730:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 730, + "column": 1, + "source_line": "typedef union" + } + }, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 730, + "column": 1, + "source_line": "typedef union" + }, + "declaration_locations": [] + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 839, + "column": 4, + "source_line": " Floor *floor_config;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "residue_count", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int residue_count" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 840, + "column": 4, + "source_line": " int residue_count;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "residue_types", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint16 residue_types[64]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "64", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "reference": "uint16" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 841, + "column": 4, + "source_line": " uint16 residue_types[64]; // varies" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "residue_config", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "Residue *residue_config", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "Residue", + "name": "Residue", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "begin", + "type": { + "reference": "uint32" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 738, + "column": 4, + "source_line": " uint32 begin, end;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "end", + "type": { + "reference": "uint32" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 738, + "column": 4, + "source_line": " uint32 begin, end;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "part_size", + "type": { + "reference": "uint32" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 739, + "column": 4, + "source_line": " uint32 part_size;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "classifications", + "type": { + "reference": "uint8" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 740, + "column": 4, + "source_line": " uint8 classifications;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "classbook", + "type": { + "reference": "uint8" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 741, + "column": 4, + "source_line": " uint8 classbook;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "classdata", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint8 **classdata", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint8" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 742, + "column": 4, + "source_line": " uint8 **classdata;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "residue_books", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int16 (*residue_books)[8]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "8", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "reference": "int16" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 743, + "column": 4, + "source_line": " int16 (*residue_books)[8];" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_vorbis.c:736:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 736, + "column": 1, + "source_line": "typedef struct" + } + }, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 736, + "column": 1, + "source_line": "typedef struct" + }, + "declaration_locations": [] + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 842, + "column": 4, + "source_line": " Residue *residue_config;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "mapping_count", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mapping_count" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 843, + "column": 4, + "source_line": " int mapping_count;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "mapping", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "Mapping *mapping", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "Mapping", + "name": "Mapping", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "coupling_steps", + "type": { + "reference": "uint16" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 755, + "column": 4, + "source_line": " uint16 coupling_steps;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "chan", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "MappingChannel *chan", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "MappingChannel", + "name": "MappingChannel", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "magnitude", + "type": { + "reference": "uint8" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 748, + "column": 4, + "source_line": " uint8 magnitude;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "angle", + "type": { + "reference": "uint8" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 749, + "column": 4, + "source_line": " uint8 angle;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "mux", + "type": { + "reference": "uint8" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 750, + "column": 4, + "source_line": " uint8 mux;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_vorbis.c:746:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 746, + "column": 1, + "source_line": "typedef struct" + } + }, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 746, + "column": 1, + "source_line": "typedef struct" + }, + "declaration_locations": [] + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 756, + "column": 4, + "source_line": " MappingChannel *chan;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "submaps", + "type": { + "reference": "uint8" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 757, + "column": 4, + "source_line": " uint8 submaps;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "submap_floor", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint8 submap_floor[15]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "15", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "reference": "uint8" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 758, + "column": 4, + "source_line": " uint8 submap_floor[15]; // varies" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "submap_residue", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint8 submap_residue[15]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "15", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "reference": "uint8" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 759, + "column": 4, + "source_line": " uint8 submap_residue[15]; // varies" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_vorbis.c:753:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 753, + "column": 1, + "source_line": "typedef struct" + } + }, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 753, + "column": 1, + "source_line": "typedef struct" + }, + "declaration_locations": [] + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 844, + "column": 4, + "source_line": " Mapping *mapping;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "mode_count", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mode_count" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 845, + "column": 4, + "source_line": " int mode_count;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "mode_config", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "Mode mode_config[64]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "64", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "Mode", + "name": "Mode", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "blockflag", + "type": { + "reference": "uint8" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 764, + "column": 4, + "source_line": " uint8 blockflag;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "mapping", + "type": { + "reference": "uint8" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 765, + "column": 4, + "source_line": " uint8 mapping;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "windowtype", + "type": { + "reference": "uint16" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 766, + "column": 4, + "source_line": " uint16 windowtype;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "transformtype", + "type": { + "reference": "uint16" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 767, + "column": 4, + "source_line": " uint16 transformtype;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_vorbis.c:762:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 762, + "column": 1, + "source_line": "typedef struct" + } + }, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 762, + "column": 1, + "source_line": "typedef struct" + }, + "declaration_locations": [] + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 846, + "column": 4, + "source_line": " Mode mode_config[64]; // varies" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "total_samples", + "type": { + "reference": "uint32" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 848, + "column": 4, + "source_line": " uint32 total_samples;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "channel_buffers", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *channel_buffers[STB_VORBIS_MAX_CHANNELS]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STB_VORBIS_MAX_CHANNELS", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 851, + "column": 4, + "source_line": " float *channel_buffers[STB_VORBIS_MAX_CHANNELS];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "outputs", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *outputs [STB_VORBIS_MAX_CHANNELS]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STB_VORBIS_MAX_CHANNELS", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 852, + "column": 4, + "source_line": " float *outputs [STB_VORBIS_MAX_CHANNELS];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "previous_window", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *previous_window[STB_VORBIS_MAX_CHANNELS]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STB_VORBIS_MAX_CHANNELS", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 854, + "column": 4, + "source_line": " float *previous_window[STB_VORBIS_MAX_CHANNELS];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "previous_length", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int previous_length" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 855, + "column": 4, + "source_line": " int previous_length;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "finalY", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int16 *finalY[STB_VORBIS_MAX_CHANNELS]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STB_VORBIS_MAX_CHANNELS", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "int16" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 858, + "column": 4, + "source_line": " int16 *finalY[STB_VORBIS_MAX_CHANNELS];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "floor_buffers", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *floor_buffers[STB_VORBIS_MAX_CHANNELS]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STB_VORBIS_MAX_CHANNELS", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 860, + "column": 4, + "source_line": " float *floor_buffers[STB_VORBIS_MAX_CHANNELS];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "current_loc", + "type": { + "reference": "uint32" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 863, + "column": 4, + "source_line": " uint32 current_loc; // sample location of next frame to decode" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "current_loc_valid", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int current_loc_valid" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 864, + "column": 4, + "source_line": " int current_loc_valid;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "A", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *A[2]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "2", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 869, + "column": 4, + "source_line": " float *A[2],*B[2],*C[2];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "B", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *B[2]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "2", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 869, + "column": 4, + "source_line": " float *A[2],*B[2],*C[2];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "C", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *C[2]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "2", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 869, + "column": 4, + "source_line": " float *A[2],*B[2],*C[2];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "window", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *window[2]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "2", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 870, + "column": 4, + "source_line": " float *window[2];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "bit_reverse", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint16 *bit_reverse[2]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "2", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint16" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 871, + "column": 4, + "source_line": " uint16 *bit_reverse[2];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "serial", + "type": { + "reference": "uint32" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 874, + "column": 4, + "source_line": " uint32 serial; // stream serial number for verification" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "last_page", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int last_page" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 875, + "column": 4, + "source_line": " int last_page;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "segment_count", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int segment_count" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 876, + "column": 4, + "source_line": " int segment_count;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "segments", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint8 segments[255]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "255", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "reference": "uint8" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 877, + "column": 4, + "source_line": " uint8 segments[255];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "page_flag", + "type": { + "reference": "uint8" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 878, + "column": 4, + "source_line": " uint8 page_flag;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "bytes_in_seg", + "type": { + "reference": "uint8" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 879, + "column": 4, + "source_line": " uint8 bytes_in_seg;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "first_decode", + "type": { + "reference": "uint8" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 880, + "column": 4, + "source_line": " uint8 first_decode;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "next_seg", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int next_seg" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 881, + "column": 4, + "source_line": " int next_seg;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "last_seg", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int last_seg" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 882, + "column": 4, + "source_line": " int last_seg; // flag that we're on the last segment" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "last_seg_which", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int last_seg_which" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 883, + "column": 4, + "source_line": " int last_seg_which; // what was the segment number of the last seg?" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "acc", + "type": { + "reference": "uint32" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 884, + "column": 4, + "source_line": " uint32 acc;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "valid_bits", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int valid_bits" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 885, + "column": 4, + "source_line": " int valid_bits;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "packet_bytes", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int packet_bytes" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 886, + "column": 4, + "source_line": " int packet_bytes;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "end_seg_with_known_loc", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int end_seg_with_known_loc" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 887, + "column": 4, + "source_line": " int end_seg_with_known_loc;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "known_loc_for_packet", + "type": { + "reference": "uint32" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 888, + "column": 4, + "source_line": " uint32 known_loc_for_packet;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "discard_samples_deferred", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int discard_samples_deferred" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 889, + "column": 4, + "source_line": " int discard_samples_deferred;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "samples_output", + "type": { + "reference": "uint32" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 890, + "column": 4, + "source_line": " uint32 samples_output;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "page_crc_tests", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int page_crc_tests" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 893, + "column": 4, + "source_line": " int page_crc_tests; // only in push_mode: number of tests active; -1 if not searching" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "scan", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "CRCscan scan[STB_VORBIS_PUSHDATA_CRC_COUNT]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STB_VORBIS_PUSHDATA_CRC_COUNT", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "CRCscan", + "name": "CRCscan", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "goal_crc", + "type": { + "reference": "uint32" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 772, + "column": 4, + "source_line": " uint32 goal_crc; // expected crc if match" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "bytes_left", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int bytes_left" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 773, + "column": 4, + "source_line": " int bytes_left; // bytes left in packet" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "crc_so_far", + "type": { + "reference": "uint32" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 774, + "column": 4, + "source_line": " uint32 crc_so_far; // running crc" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "bytes_done", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int bytes_done" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 775, + "column": 4, + "source_line": " int bytes_done; // bytes processed in _current_ chunk" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "sample_loc", + "type": { + "reference": "uint32" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 776, + "column": 4, + "source_line": " uint32 sample_loc; // granule pos encoded in page" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_vorbis.c:770:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 770, + "column": 1, + "source_line": "typedef struct" + } + }, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 770, + "column": 1, + "source_line": "typedef struct" + }, + "declaration_locations": [] + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 895, + "column": 4, + "source_line": " CRCscan scan[STB_VORBIS_PUSHDATA_CRC_COUNT];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "channel_buffer_start", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int channel_buffer_start" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 899, + "column": 4, + "source_line": " int channel_buffer_start;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "channel_buffer_end", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int channel_buffer_end" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 900, + "column": 4, + "source_line": " int channel_buffer_end;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": null, + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 785, + "column": 1, + "source_line": "struct stb_vorbis" + } + }, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 911, + "column": 1, + "source_line": "typedef struct stb_vorbis vorb;" + }, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "e", + "type": { + "model": "CEnum", + "qualifiers": [], + "source_text": "enum STBVorbisError e", + "name": "STBVorbisError", + "constants": [], + "anonymous_id": null, + "source_location": null + }, + "declared_type": { + "reference": "enum STBVorbisError" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 913, + "column": 1, + "source_line": "static int error(vorb *f, enum STBVorbisError e)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 913, + "column": 1, + "source_line": "static int error(vorb *f, enum STBVorbisError e)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 920, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "make_block_array", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "parameters": [ + { + "name": "mem", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *mem", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *mem", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "count", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int count" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int count" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "size", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int size" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int size" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 938, + "column": 1, + "source_line": "static void *make_block_array(void *mem, int count, int size)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 938, + "column": 1, + "source_line": "static void *make_block_array(void *mem, int count, int size)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 948, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "setup_malloc", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "sz", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int sz" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int sz" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 950, + "column": 1, + "source_line": "static void *setup_malloc(vorb *f, int sz)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 950, + "column": 1, + "source_line": "static void *setup_malloc(vorb *f, int sz)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 961, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "setup_free", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 963, + "column": 1, + "source_line": "static void setup_free(vorb *f, void *p)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 963, + "column": 1, + "source_line": "static void setup_free(vorb *f, void *p)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 967, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "setup_temp_malloc", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "sz", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int sz" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int sz" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 969, + "column": 1, + "source_line": "static void *setup_temp_malloc(vorb *f, int sz)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 969, + "column": 1, + "source_line": "static void *setup_temp_malloc(vorb *f, int sz)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 978, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "setup_temp_free", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "sz", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int sz" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int sz" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 980, + "column": 1, + "source_line": "static void setup_temp_free(vorb *f, void *p, int sz)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 980, + "column": 1, + "source_line": "static void setup_temp_free(vorb *f, void *p, int sz)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 987, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "crc32_init", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 992, + "column": 1, + "source_line": "static void crc32_init(void)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 992, + "column": 1, + "source_line": "static void crc32_init(void)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1001, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "bit_reverse", + "result_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int" + }, + "parameters": [ + { + "name": "n", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int n" + }, + "declared_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int n" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1010, + "column": 1, + "source_line": "static unsigned int bit_reverse(unsigned int n)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1010, + "column": 1, + "source_line": "static unsigned int bit_reverse(unsigned int n)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1017, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "square", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1019, + "column": 1, + "source_line": "static float square(float x)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1019, + "column": 1, + "source_line": "static float square(float x)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1022, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "ilog", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "n", + "type": { + "reference": "int32" + }, + "declared_type": { + "reference": "int32" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1027, + "column": 1, + "source_line": "static int ilog(int32 n)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1027, + "column": 1, + "source_line": "static int ilog(int32 n)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1043, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "float32_unpack", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "x", + "type": { + "reference": "uint32" + }, + "declared_type": { + "reference": "uint32" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1057, + "column": 1, + "source_line": "static float float32_unpack(uint32 x)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1057, + "column": 1, + "source_line": "static float float32_unpack(uint32 x)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1065, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "add_entry", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "c", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "Codebook *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "Codebook" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "Codebook *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "Codebook" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "huff_code", + "type": { + "reference": "uint32" + }, + "declared_type": { + "reference": "uint32" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "symbol", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int symbol" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int symbol" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "count", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int count" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int count" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "values", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint32 *values", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint32" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint32 *values", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint32" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1075, + "column": 1, + "source_line": "static void add_entry(Codebook *c, uint32 huff_code, int symbol, int count, int len, uint32 *values)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1075, + "column": 1, + "source_line": "static void add_entry(Codebook *c, uint32 huff_code, int symbol, int count, int len, uint32 *values)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1084, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "compute_codewords", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "c", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "Codebook *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "Codebook" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "Codebook *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "Codebook" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint8 *len", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint8" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint8 *len", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint8" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "values", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint32 *values", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint32" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint32 *values", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint32" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1086, + "column": 1, + "source_line": "static int compute_codewords(Codebook *c, uint8 *len, int n, uint32 *values)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1086, + "column": 1, + "source_line": "static int compute_codewords(Codebook *c, uint8 *len, int n, uint32 *values)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1130, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "compute_accelerated_huffman", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "c", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "Codebook *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "Codebook" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "Codebook *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "Codebook" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1134, + "column": 1, + "source_line": "static void compute_accelerated_huffman(Codebook *c)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1134, + "column": 1, + "source_line": "static void compute_accelerated_huffman(Codebook *c)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1154, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "include_in_sort", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "c", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "Codebook *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "Codebook" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "Codebook *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "Codebook" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "reference": "uint8" + }, + "declared_type": { + "reference": "uint8" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1169, + "column": 1, + "source_line": "static int include_in_sort(Codebook *c, uint8 len)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1169, + "column": 1, + "source_line": "static int include_in_sort(Codebook *c, uint8 len)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1175, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "compute_sorted_huffman", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "c", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "Codebook *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "Codebook" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "Codebook *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "Codebook" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "lengths", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint8 *lengths", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint8" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint8 *lengths", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint8" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "values", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint32 *values", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint32" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint32 *values", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint32" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1179, + "column": 1, + "source_line": "static void compute_sorted_huffman(Codebook *c, uint8 *lengths, uint32 *values)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1179, + "column": 1, + "source_line": "static void compute_sorted_huffman(Codebook *c, uint8 *lengths, uint32 *values)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1230, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "vorbis_validate", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint8 *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint8" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint8 *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint8" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1233, + "column": 1, + "source_line": "static int vorbis_validate(uint8 *data)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1233, + "column": 1, + "source_line": "static int vorbis_validate(uint8 *data)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1237, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "lookup1_values", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "entries", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int entries" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int entries" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dim", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int dim" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int dim" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1241, + "column": 1, + "source_line": "static int lookup1_values(int entries, int dim)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1241, + "column": 1, + "source_line": "static int lookup1_values(int entries, int dim)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1251, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "compute_twiddle_factors", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "A", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *A", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *A", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "B", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *B", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *B", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "C", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *C", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *C", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1254, + "column": 1, + "source_line": "static void compute_twiddle_factors(int n, float *A, float *B, float *C)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1254, + "column": 1, + "source_line": "static void compute_twiddle_factors(int n, float *A, float *B, float *C)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1269, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "compute_window", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "window", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *window", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *window", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1271, + "column": 1, + "source_line": "static void compute_window(int n, float *window)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1271, + "column": 1, + "source_line": "static void compute_window(int n, float *window)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1276, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "compute_bitreverse", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "rev", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint16 *rev", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint16" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint16 *rev", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint16" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1278, + "column": 1, + "source_line": "static void compute_bitreverse(int n, uint16 *rev)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1278, + "column": 1, + "source_line": "static void compute_bitreverse(int n, uint16 *rev)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1284, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "init_blocksize", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1286, + "column": 1, + "source_line": "static int init_blocksize(vorb *f, int b, int n)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1286, + "column": 1, + "source_line": "static int init_blocksize(vorb *f, int b, int n)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1301, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "neighbors", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint16 *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint16" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint16 *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint16" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "plow", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *plow", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *plow", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "phigh", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *phigh", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *phigh", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1303, + "column": 1, + "source_line": "static void neighbors(uint16 *x, int n, int *plow, int *phigh)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1303, + "column": 1, + "source_line": "static void neighbors(uint16 *x, int n, int *plow, int *phigh)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1312, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "get8", + "result_type": { + "reference": "uint8" + }, + "parameters": [ + { + "name": "z", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1337, + "column": 1, + "source_line": "static uint8 get8(vorb *z)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1337, + "column": 1, + "source_line": "static uint8 get8(vorb *z)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1351, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "get32", + "result_type": { + "reference": "uint32" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1353, + "column": 1, + "source_line": "static uint32 get32(vorb *f)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1353, + "column": 1, + "source_line": "static uint32 get32(vorb *f)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1361, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "getn", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "z", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint8 *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint8" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint8 *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint8" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1363, + "column": 1, + "source_line": "static int getn(vorb *z, uint8 *data, int n)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1363, + "column": 1, + "source_line": "static int getn(vorb *z, uint8 *data, int n)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1380, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "skip", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "z", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1382, + "column": 1, + "source_line": "static void skip(vorb *z, int n)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1382, + "column": 1, + "source_line": "static void skip(vorb *z, int n)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1395, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "set_file_offset", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stb_vorbis", + "name": "stb_vorbis", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "loc", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int loc" + }, + "declared_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int loc" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1397, + "column": 1, + "source_line": "static int set_file_offset(stb_vorbis *f, unsigned int loc)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1397, + "column": 1, + "source_line": "static int set_file_offset(stb_vorbis *f, unsigned int loc)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1426, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "capture_pattern", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1431, + "column": 1, + "source_line": "static int capture_pattern(vorb *f)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1431, + "column": 1, + "source_line": "static int capture_pattern(vorb *f)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1438, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "start_page_no_capturepattern", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1444, + "column": 1, + "source_line": "static int start_page_no_capturepattern(vorb *f)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1444, + "column": 1, + "source_line": "static int start_page_no_capturepattern(vorb *f)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1495, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "start_page", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1497, + "column": 1, + "source_line": "static int start_page(vorb *f)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1497, + "column": 1, + "source_line": "static int start_page(vorb *f)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1501, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "start_packet", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1503, + "column": 1, + "source_line": "static int start_packet(vorb *f)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1503, + "column": 1, + "source_line": "static int start_packet(vorb *f)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1516, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "maybe_start_packet", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1518, + "column": 1, + "source_line": "static int maybe_start_packet(vorb *f)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1518, + "column": 1, + "source_line": "static int maybe_start_packet(vorb *f)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1537, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "next_segment", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1539, + "column": 1, + "source_line": "static int next_segment(vorb *f)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1539, + "column": 1, + "source_line": "static int next_segment(vorb *f)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1558, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "get8_packet_raw", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1563, + "column": 1, + "source_line": "static int get8_packet_raw(vorb *f)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1563, + "column": 1, + "source_line": "static int get8_packet_raw(vorb *f)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1573, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "get8_packet", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1575, + "column": 1, + "source_line": "static int get8_packet(vorb *f)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1575, + "column": 1, + "source_line": "static int get8_packet(vorb *f)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1580, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "get32_packet", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1582, + "column": 1, + "source_line": "static int get32_packet(vorb *f)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1582, + "column": 1, + "source_line": "static int get32_packet(vorb *f)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1590, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "flush_packet", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1592, + "column": 1, + "source_line": "static void flush_packet(vorb *f)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1592, + "column": 1, + "source_line": "static void flush_packet(vorb *f)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1595, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "get_bits", + "result_type": { + "reference": "uint32" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1599, + "column": 1, + "source_line": "static uint32 get_bits(vorb *f, int n)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1599, + "column": 1, + "source_line": "static uint32 get_bits(vorb *f, int n)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1628, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "codebook_decode_scalar_raw", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "Codebook *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "Codebook" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "Codebook *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "Codebook" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1656, + "column": 1, + "source_line": "static int codebook_decode_scalar_raw(vorb *f, Codebook *c)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1656, + "column": 1, + "source_line": "static int codebook_decode_scalar_raw(vorb *f, Codebook *c)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1713, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "codebook_decode_scalar", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "Codebook *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "Codebook" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "Codebook *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "Codebook" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1733, + "column": 1, + "source_line": "static int codebook_decode_scalar(vorb *f, Codebook *c)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1733, + "column": 1, + "source_line": "static int codebook_decode_scalar(vorb *f, Codebook *c)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1748, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "codebook_decode_start", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "Codebook *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "Codebook" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "Codebook *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "Codebook" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1775, + "column": 1, + "source_line": "static int codebook_decode_start(vorb *f, Codebook *c)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1775, + "column": 1, + "source_line": "static int codebook_decode_start(vorb *f, Codebook *c)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1793, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "codebook_decode", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "Codebook *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "Codebook" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "Codebook *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "Codebook" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "output", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *output", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *output", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1795, + "column": 1, + "source_line": "static int codebook_decode(vorb *f, Codebook *c, float *output, int len)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1795, + "column": 1, + "source_line": "static int codebook_decode(vorb *f, Codebook *c, float *output, int len)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1832, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "codebook_decode_step", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "Codebook *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "Codebook" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "Codebook *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "Codebook" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "output", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *output", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *output", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "step", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int step" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int step" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1834, + "column": 1, + "source_line": "static int codebook_decode_step(vorb *f, Codebook *c, float *output, int len, int step)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1834, + "column": 1, + "source_line": "static int codebook_decode_step(vorb *f, Codebook *c, float *output, int len, int step)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1863, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "codebook_decode_deinterleave_repeat", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "Codebook *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "Codebook" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "Codebook *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "Codebook" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "outputs", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float **outputs", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float **outputs", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ch", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ch" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ch" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c_inter_p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *c_inter_p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *c_inter_p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p_inter_p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *p_inter_p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *p_inter_p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "total_decode", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int total_decode" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int total_decode" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1865, + "column": 1, + "source_line": "static int codebook_decode_deinterleave_repeat(vorb *f, Codebook *c, float **outputs, int ch, int *c_inter_p, int *p_inter_p, int len, int total_decode)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1865, + "column": 1, + "source_line": "static int codebook_decode_deinterleave_repeat(vorb *f, Codebook *c, float **outputs, int ch, int *c_inter_p, int *p_inter_p, int len, int total_decode)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1933, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "predict_point", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1935, + "column": 1, + "source_line": "static int predict_point(int x, int x0, int x1, int y0, int y1)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1935, + "column": 1, + "source_line": "static int predict_point(int x, int x0, int x1, int y0, int y1)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1943, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "residue_decode", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "book", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "Codebook *book", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "Codebook" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "Codebook *book", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "Codebook" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "target", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *target", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *target", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "offset", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int offset" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int offset" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "rtype", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int rtype" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int rtype" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2083, + "column": 1, + "source_line": "static int residue_decode(vorb *f, Codebook *book, float *target, int offset, int n, int rtype)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 2083, + "column": 1, + "source_line": "static int residue_decode(vorb *f, Codebook *book, float *target, int offset, int n, int rtype)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 2100, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "decode_residue", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "residue_buffers", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *residue_buffers[]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *residue_buffers[]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": null, + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ch", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ch" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ch" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "rn", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int rn" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int rn" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "do_not_decode", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint8 *do_not_decode", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint8" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint8 *do_not_decode", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint8" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2104, + "column": 1, + "source_line": "static void decode_residue(vorb *f, float *residue_buffers[], int ch, int n, int rn, uint8 *do_not_decode)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 2104, + "column": 1, + "source_line": "static void decode_residue(vorb *f, float *residue_buffers[], int ch, int n, int rn, uint8 *do_not_decode)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 2284, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "inverse_mdct_slow", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2289, + "column": 1, + "source_line": "void inverse_mdct_slow(float *buffer, int n)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 2289, + "column": 1, + "source_line": "void inverse_mdct_slow(float *buffer, int n)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 2309, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "dct_iv_slow", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2333, + "column": 1, + "source_line": "void dct_iv_slow(float *buffer, int n)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 2333, + "column": 1, + "source_line": "void dct_iv_slow(float *buffer, int n)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 2348, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "mdct_init", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "lookup", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "mdct_lookup *lookup", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "mdct_lookup", + "name": "mdct_lookup", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2373, + "column": 3, + "source_line": " int n;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "log2n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int log2n" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2374, + "column": 3, + "source_line": " int log2n;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "trig", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *trig", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2376, + "column": 3, + "source_line": " float *trig;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "bitrev", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *bitrev", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2377, + "column": 3, + "source_line": " int *bitrev;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "scale", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float scale" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2379, + "column": 3, + "source_line": " float scale;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_vorbis.c:2371:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2371, + "column": 1, + "source_line": "typedef struct" + } + }, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2371, + "column": 1, + "source_line": "typedef struct" + }, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "mdct_lookup *lookup", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "mdct_lookup" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "extern" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": false, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2382, + "column": 1, + "source_line": "extern void mdct_init(mdct_lookup *lookup, int n);" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 2382, + "column": 1, + "source_line": "extern void mdct_init(mdct_lookup *lookup, int n);" + }, + "end": null, + "declaration_locations": [] + }, + { + "name": "mdct_clear", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "l", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "mdct_lookup *l", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "mdct_lookup" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "mdct_lookup *l", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "mdct_lookup" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "extern" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": false, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2383, + "column": 1, + "source_line": "extern void mdct_clear(mdct_lookup *l);" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 2383, + "column": 1, + "source_line": "extern void mdct_clear(mdct_lookup *l);" + }, + "end": null, + "declaration_locations": [] + }, + { + "name": "mdct_backward", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "init", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "mdct_lookup *init", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "mdct_lookup" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "mdct_lookup *init", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "mdct_lookup" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "in", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *in", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *in", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "out", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *out", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *out", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "extern" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": false, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2384, + "column": 1, + "source_line": "extern void mdct_backward(mdct_lookup *init, float *in, float *out);" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 2384, + "column": 1, + "source_line": "extern void mdct_backward(mdct_lookup *init, float *in, float *out);" + }, + "end": null, + "declaration_locations": [] + }, + { + "name": "inverse_mdct", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "blocktype", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int blocktype" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int blocktype" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2388, + "column": 1, + "source_line": "void inverse_mdct(float *buffer, int n, vorb *f, int blocktype)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 2388, + "column": 1, + "source_line": "void inverse_mdct(float *buffer, int n, vorb *f, int blocktype)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 2401, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "imdct_step3_iter0_loop", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "e", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *e", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *e", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "i_off", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int i_off" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int i_off" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "k_off", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int k_off" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int k_off" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "A", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *A", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *A", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2408, + "column": 1, + "source_line": "static void imdct_step3_iter0_loop(int n, float *e, int i_off, int k_off, float *A)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 2408, + "column": 1, + "source_line": "static void imdct_step3_iter0_loop(int n, float *e, int i_off, int k_off, float *A)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 2451, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "imdct_step3_inner_r_loop", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "lim", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int lim" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int lim" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "e", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *e", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *e", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "d0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int d0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int d0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "k_off", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int k_off" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int k_off" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "A", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *A", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *A", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "k1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int k1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int k1" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2453, + "column": 1, + "source_line": "static void imdct_step3_inner_r_loop(int lim, float *e, int d0, int k_off, float *A, int k1)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 2453, + "column": 1, + "source_line": "static void imdct_step3_inner_r_loop(int lim, float *e, int d0, int k_off, float *A, int k1)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 2501, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "imdct_step3_inner_s_loop", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "e", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *e", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *e", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "i_off", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int i_off" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int i_off" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "k_off", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int k_off" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int k_off" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "A", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *A", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *A", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "a_off", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a_off" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a_off" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "k0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int k0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int k0" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2503, + "column": 1, + "source_line": "static void imdct_step3_inner_s_loop(int n, float *e, int i_off, int k_off, float *A, int a_off, int k0)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 2503, + "column": 1, + "source_line": "static void imdct_step3_inner_s_loop(int n, float *e, int i_off, int k_off, float *A, int a_off, int k0)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 2552, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "imdct_step3_inner_s_loop_ld654", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "e", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *e", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *e", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "i_off", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int i_off" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int i_off" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "A", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *A", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *A", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "base_n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int base_n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int base_n" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2586, + "column": 1, + "source_line": "static void imdct_step3_inner_s_loop_ld654(int n, float *e, int i_off, float *A, int base_n)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 2586, + "column": 1, + "source_line": "static void imdct_step3_inner_s_loop_ld654(int n, float *e, int i_off, float *A, int base_n)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 2627, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "inverse_mdct_naive", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2933, + "column": 1, + "source_line": "void inverse_mdct_naive(float *buffer, int n)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 2933, + "column": 1, + "source_line": "void inverse_mdct_naive(float *buffer, int n)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 3056, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "get_window", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 3059, + "column": 1, + "source_line": "static float *get_window(vorb *f, int len)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 3059, + "column": 1, + "source_line": "static float *get_window(vorb *f, int len)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 3065, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "do_floor", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "map", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "Mapping *map", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "Mapping" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "Mapping *map", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "Mapping" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "i", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int i" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int i" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "target", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *target", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *target", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "finalY", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "YTYPE *finalY", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "YTYPE", + "name": "YTYPE", + "type": { + "reference": "int16" + }, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 3068, + "column": 1, + "source_line": "typedef int16 YTYPE;" + }, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "YTYPE *finalY", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "YTYPE" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "step2_flag", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint8 *step2_flag", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint8" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint8 *step2_flag", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint8" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 3072, + "column": 1, + "source_line": "static int do_floor(vorb *f, Mapping *map, int i, int n, float *target, YTYPE *finalY, uint8 *step2_flag)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 3072, + "column": 1, + "source_line": "static int do_floor(vorb *f, Mapping *map, int i, int n, float *target, YTYPE *finalY, uint8 *step2_flag)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 3108, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "vorbis_decode_initial", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p_left_start", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *p_left_start", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *p_left_start", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p_left_end", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *p_left_end", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *p_left_end", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p_right_start", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *p_right_start", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *p_right_start", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p_right_end", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *p_right_end", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *p_right_end", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mode", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *mode", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *mode", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 3124, + "column": 1, + "source_line": "static int vorbis_decode_initial(vorb *f, int *p_left_start, int *p_left_end, int *p_right_start, int *p_right_end, int *mode)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 3124, + "column": 1, + "source_line": "static int vorbis_decode_initial(vorb *f, int *p_left_start, int *p_left_end, int *p_right_start, int *p_right_end, int *mode)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 3178, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "vorbis_decode_packet_rest", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *len", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *len", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "m", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "Mode *m", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "Mode" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "Mode *m", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "Mode" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "left_start", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int left_start" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int left_start" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "left_end", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int left_end" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int left_end" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "right_start", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int right_start" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int right_start" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "right_end", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int right_end" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int right_end" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p_left", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *p_left", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *p_left", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 3180, + "column": 1, + "source_line": "static int vorbis_decode_packet_rest(vorb *f, int *len, Mode *m, int left_start, int left_end, int right_start, int right_end, int *p_left)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 3180, + "column": 1, + "source_line": "static int vorbis_decode_packet_rest(vorb *f, int *len, Mode *m, int left_start, int left_end, int right_start, int right_end, int *p_left)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 3447, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "vorbis_decode_packet", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *len", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *len", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p_left", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *p_left", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *p_left", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p_right", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *p_right", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *p_right", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 3449, + "column": 1, + "source_line": "static int vorbis_decode_packet(vorb *f, int *len, int *p_left, int *p_right)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 3449, + "column": 1, + "source_line": "static int vorbis_decode_packet(vorb *f, int *len, int *p_left, int *p_right)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 3454, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "vorbis_finish_frame", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stb_vorbis", + "name": "stb_vorbis", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "left", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int left" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int left" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "right", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int right" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int right" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 3456, + "column": 1, + "source_line": "static int vorbis_finish_frame(stb_vorbis *f, int len, int left, int right)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 3456, + "column": 1, + "source_line": "static int vorbis_finish_frame(stb_vorbis *f, int len, int left, int right)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 3507, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "vorbis_pump_first_frame", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stb_vorbis", + "name": "stb_vorbis", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 3509, + "column": 1, + "source_line": "static int vorbis_pump_first_frame(stb_vorbis *f)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 3509, + "column": 1, + "source_line": "static int vorbis_pump_first_frame(stb_vorbis *f)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 3516, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "is_whole_packet_present", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stb_vorbis", + "name": "stb_vorbis", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 3519, + "column": 1, + "source_line": "static int is_whole_packet_present(stb_vorbis *f)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 3519, + "column": 1, + "source_line": "static int is_whole_packet_present(stb_vorbis *f)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 3577, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "start_decoder", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 3580, + "column": 1, + "source_line": "static int start_decoder(vorb *f)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 3580, + "column": 1, + "source_line": "static int start_decoder(vorb *f)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 4206, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "vorbis_deinit", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stb_vorbis", + "name": "stb_vorbis", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 4208, + "column": 1, + "source_line": "static void vorbis_deinit(stb_vorbis *p)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 4208, + "column": 1, + "source_line": "static void vorbis_deinit(stb_vorbis *p)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 4269, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_vorbis_close", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stb_vorbis", + "name": "stb_vorbis", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 4271, + "column": 1, + "source_line": "void stb_vorbis_close(stb_vorbis *p)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 4271, + "column": 1, + "source_line": "void stb_vorbis_close(stb_vorbis *p)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 4276, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "vorbis_init", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stb_vorbis", + "name": "stb_vorbis", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "z", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stb_vorbis_alloc *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [ + "const" + ], + "source_text": "const stb_vorbis_alloc", + "name": "stb_vorbis_alloc", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stb_vorbis_alloc *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis_alloc" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 4278, + "column": 1, + "source_line": "static void vorbis_init(stb_vorbis *p, const stb_vorbis_alloc *z)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 4278, + "column": 1, + "source_line": "static void vorbis_init(stb_vorbis *p, const stb_vorbis_alloc *z)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 4295, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_vorbis_get_sample_offset", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stb_vorbis", + "name": "stb_vorbis", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 4297, + "column": 1, + "source_line": "int stb_vorbis_get_sample_offset(stb_vorbis *f)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 4297, + "column": 1, + "source_line": "int stb_vorbis_get_sample_offset(stb_vorbis *f)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 4303, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_vorbis_get_info", + "result_type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stb_vorbis_info", + "name": "stb_vorbis_info", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stb_vorbis", + "name": "stb_vorbis", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 4305, + "column": 1, + "source_line": "stb_vorbis_info stb_vorbis_get_info(stb_vorbis *f)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 4305, + "column": 1, + "source_line": "stb_vorbis_info stb_vorbis_get_info(stb_vorbis *f)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 4315, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_vorbis_get_comment", + "result_type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stb_vorbis_comment", + "name": "stb_vorbis_comment", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stb_vorbis", + "name": "stb_vorbis", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 4317, + "column": 1, + "source_line": "stb_vorbis_comment stb_vorbis_get_comment(stb_vorbis *f)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 4317, + "column": 1, + "source_line": "stb_vorbis_comment stb_vorbis_get_comment(stb_vorbis *f)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 4324, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_vorbis_get_error", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stb_vorbis", + "name": "stb_vorbis", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 4326, + "column": 1, + "source_line": "int stb_vorbis_get_error(stb_vorbis *f)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 4326, + "column": 1, + "source_line": "int stb_vorbis_get_error(stb_vorbis *f)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 4331, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "vorbis_alloc", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stb_vorbis", + "name": "stb_vorbis", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stb_vorbis", + "name": "stb_vorbis", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 4333, + "column": 1, + "source_line": "static stb_vorbis * vorbis_alloc(stb_vorbis *f)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 4333, + "column": 1, + "source_line": "static stb_vorbis * vorbis_alloc(stb_vorbis *f)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 4337, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_vorbis_flush_pushdata", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stb_vorbis", + "name": "stb_vorbis", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 4341, + "column": 1, + "source_line": "void stb_vorbis_flush_pushdata(stb_vorbis *f)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 4341, + "column": 1, + "source_line": "void stb_vorbis_flush_pushdata(stb_vorbis *f)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 4351, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "vorbis_search_for_page_pushdata", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint8 *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint8" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint8 *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint8" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "data_len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int data_len" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int data_len" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 4353, + "column": 1, + "source_line": "static int vorbis_search_for_page_pushdata(vorb *f, uint8 *data, int data_len)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 4353, + "column": 1, + "source_line": "static int vorbis_search_for_page_pushdata(vorb *f, uint8 *data, int data_len)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 4441, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_vorbis_decode_frame_pushdata", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stb_vorbis", + "name": "stb_vorbis", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const uint8 *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint8" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const uint8 *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint8" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "data_len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int data_len" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int data_len" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "channels", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *channels", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *channels", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "output", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float ***output", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float ***output", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "samples", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *samples", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *samples", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 4444, + "column": 1, + "source_line": "int stb_vorbis_decode_frame_pushdata(" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 4444, + "column": 1, + "source_line": "int stb_vorbis_decode_frame_pushdata(" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 4512, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_vorbis_open_pushdata", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stb_vorbis", + "name": "stb_vorbis", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "parameters": [ + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const unsigned char *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [ + "const" + ], + "source_text": "const unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const unsigned char *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [ + "const" + ], + "source_text": "const unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "data_len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int data_len" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int data_len" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "data_used", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *data_used", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *data_used", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "error", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *error", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *error", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "alloc", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stb_vorbis_alloc *alloc", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [ + "const" + ], + "source_text": "const stb_vorbis_alloc", + "name": "stb_vorbis_alloc", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stb_vorbis_alloc *alloc", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis_alloc" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 4514, + "column": 1, + "source_line": "stb_vorbis *stb_vorbis_open_pushdata(" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 4514, + "column": 1, + "source_line": "stb_vorbis *stb_vorbis_open_pushdata(" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 4542, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_vorbis_get_file_offset", + "result_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stb_vorbis", + "name": "stb_vorbis", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 4545, + "column": 1, + "source_line": "unsigned int stb_vorbis_get_file_offset(stb_vorbis *f)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 4545, + "column": 1, + "source_line": "unsigned int stb_vorbis_get_file_offset(stb_vorbis *f)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 4554, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "vorbis_find_page", + "result_type": { + "reference": "uint32" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stb_vorbis", + "name": "stb_vorbis", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "end", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint32 *end", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint32" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint32 *end", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint32" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "last", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint32 *last", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint32" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint32 *last", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint32" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 4561, + "column": 1, + "source_line": "static uint32 vorbis_find_page(stb_vorbis *f, uint32 *end, uint32 *last)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 4561, + "column": 1, + "source_line": "static uint32 vorbis_find_page(stb_vorbis *f, uint32 *end, uint32 *last)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 4629, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "get_seek_page_info", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stb_vorbis", + "name": "stb_vorbis", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "z", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "ProbedPage *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "ProbedPage" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "ProbedPage *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "ProbedPage" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 4643, + "column": 1, + "source_line": "static int get_seek_page_info(stb_vorbis *f, ProbedPage *z)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 4643, + "column": 1, + "source_line": "static int get_seek_page_info(stb_vorbis *f, ProbedPage *z)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 4671, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "go_to_page_before", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stb_vorbis", + "name": "stb_vorbis", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "limit_offset", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int limit_offset" + }, + "declared_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int limit_offset" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 4675, + "column": 1, + "source_line": "static int go_to_page_before(stb_vorbis *f, unsigned int limit_offset)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 4675, + "column": 1, + "source_line": "static int go_to_page_before(stb_vorbis *f, unsigned int limit_offset)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 4694, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "seek_to_sample_coarse", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stb_vorbis", + "name": "stb_vorbis", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "sample_number", + "type": { + "reference": "uint32" + }, + "declared_type": { + "reference": "uint32" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 4700, + "column": 1, + "source_line": "static int seek_to_sample_coarse(stb_vorbis *f, uint32 sample_number)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 4700, + "column": 1, + "source_line": "static int seek_to_sample_coarse(stb_vorbis *f, uint32 sample_number)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 4852, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "peek_decode_initial", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p_left_start", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *p_left_start", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *p_left_start", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p_left_end", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *p_left_end", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *p_left_end", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p_right_start", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *p_right_start", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *p_right_start", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p_right_end", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *p_right_end", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *p_right_end", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mode", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *mode", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *mode", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 4855, + "column": 1, + "source_line": "static int peek_decode_initial(vorb *f, int *p_left_start, int *p_left_end, int *p_right_start, int *p_right_end, int *mode)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 4855, + "column": 1, + "source_line": "static int peek_decode_initial(vorb *f, int *p_left_start, int *p_left_end, int *p_right_start, int *p_right_end, int *mode)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 4878, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_vorbis_seek_frame", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stb_vorbis", + "name": "stb_vorbis", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "sample_number", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int sample_number" + }, + "declared_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int sample_number" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 4880, + "column": 1, + "source_line": "int stb_vorbis_seek_frame(stb_vorbis *f, unsigned int sample_number)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 4880, + "column": 1, + "source_line": "int stb_vorbis_seek_frame(stb_vorbis *f, unsigned int sample_number)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 4917, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_vorbis_seek", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stb_vorbis", + "name": "stb_vorbis", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "sample_number", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int sample_number" + }, + "declared_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int sample_number" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 4919, + "column": 1, + "source_line": "int stb_vorbis_seek(stb_vorbis *f, unsigned int sample_number)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 4919, + "column": 1, + "source_line": "int stb_vorbis_seek(stb_vorbis *f, unsigned int sample_number)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 4934, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_vorbis_seek_start", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stb_vorbis", + "name": "stb_vorbis", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 4936, + "column": 1, + "source_line": "int stb_vorbis_seek_start(stb_vorbis *f)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 4936, + "column": 1, + "source_line": "int stb_vorbis_seek_start(stb_vorbis *f)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 4944, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_vorbis_stream_length_in_samples", + "result_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stb_vorbis", + "name": "stb_vorbis", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 4946, + "column": 1, + "source_line": "unsigned int stb_vorbis_stream_length_in_samples(stb_vorbis *f)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 4946, + "column": 1, + "source_line": "unsigned int stb_vorbis_stream_length_in_samples(stb_vorbis *f)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 5019, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_vorbis_stream_length_in_seconds", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stb_vorbis", + "name": "stb_vorbis", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5021, + "column": 1, + "source_line": "float stb_vorbis_stream_length_in_seconds(stb_vorbis *f)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 5021, + "column": 1, + "source_line": "float stb_vorbis_stream_length_in_seconds(stb_vorbis *f)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 5024, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_vorbis_get_frame_float", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stb_vorbis", + "name": "stb_vorbis", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "channels", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *channels", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *channels", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "output", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float ***output", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float ***output", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5028, + "column": 1, + "source_line": "int stb_vorbis_get_frame_float(stb_vorbis *f, int *channels, float ***output)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 5028, + "column": 1, + "source_line": "int stb_vorbis_get_frame_float(stb_vorbis *f, int *channels, float ***output)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 5048, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_vorbis_open_file_section", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stb_vorbis", + "name": "stb_vorbis", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "parameters": [ + { + "name": "file", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "FILE *file", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "FILE", + "name": "FILE", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "FILE *file", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "FILE" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "close_on_free", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int close_on_free" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int close_on_free" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "error", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *error", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *error", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "alloc", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stb_vorbis_alloc *alloc", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [ + "const" + ], + "source_text": "const stb_vorbis_alloc", + "name": "stb_vorbis_alloc", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stb_vorbis_alloc *alloc", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis_alloc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "length", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int length" + }, + "declared_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int length" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5052, + "column": 1, + "source_line": "stb_vorbis * stb_vorbis_open_file_section(FILE *file, int close_on_free, int *error, const stb_vorbis_alloc *alloc, unsigned int length)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 5052, + "column": 1, + "source_line": "stb_vorbis * stb_vorbis_open_file_section(FILE *file, int close_on_free, int *error, const stb_vorbis_alloc *alloc, unsigned int length)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 5071, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_vorbis_open_file", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stb_vorbis", + "name": "stb_vorbis", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "parameters": [ + { + "name": "file", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "FILE *file", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "FILE", + "name": "FILE", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "FILE *file", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "FILE" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "close_on_free", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int close_on_free" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int close_on_free" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "error", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *error", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *error", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "alloc", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stb_vorbis_alloc *alloc", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [ + "const" + ], + "source_text": "const stb_vorbis_alloc", + "name": "stb_vorbis_alloc", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stb_vorbis_alloc *alloc", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis_alloc" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5073, + "column": 1, + "source_line": "stb_vorbis * stb_vorbis_open_file(FILE *file, int close_on_free, int *error, const stb_vorbis_alloc *alloc)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 5073, + "column": 1, + "source_line": "stb_vorbis * stb_vorbis_open_file(FILE *file, int close_on_free, int *error, const stb_vorbis_alloc *alloc)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 5081, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_vorbis_open_filename", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stb_vorbis", + "name": "stb_vorbis", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "parameters": [ + { + "name": "filename", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *filename", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *filename", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "error", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *error", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *error", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "alloc", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stb_vorbis_alloc *alloc", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [ + "const" + ], + "source_text": "const stb_vorbis_alloc", + "name": "stb_vorbis_alloc", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stb_vorbis_alloc *alloc", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis_alloc" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5083, + "column": 1, + "source_line": "stb_vorbis * stb_vorbis_open_filename(const char *filename, int *error, const stb_vorbis_alloc *alloc)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 5083, + "column": 1, + "source_line": "stb_vorbis * stb_vorbis_open_filename(const char *filename, int *error, const stb_vorbis_alloc *alloc)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 5096, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_vorbis_open_memory", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stb_vorbis", + "name": "stb_vorbis", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "parameters": [ + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const unsigned char *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [ + "const" + ], + "source_text": "const unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const unsigned char *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [ + "const" + ], + "source_text": "const unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "error", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *error", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *error", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "alloc", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stb_vorbis_alloc *alloc", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [ + "const" + ], + "source_text": "const stb_vorbis_alloc", + "name": "stb_vorbis_alloc", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stb_vorbis_alloc *alloc", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis_alloc" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5099, + "column": 1, + "source_line": "stb_vorbis * stb_vorbis_open_memory(const unsigned char *data, int len, int *error, const stb_vorbis_alloc *alloc)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 5099, + "column": 1, + "source_line": "stb_vorbis * stb_vorbis_open_memory(const unsigned char *data, int len, int *error, const stb_vorbis_alloc *alloc)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 5124, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "copy_samples", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "dest", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short *dest", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short *dest", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "src", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *src", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *src", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5165, + "column": 1, + "source_line": "static void copy_samples(short *dest, float *src, int len)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 5165, + "column": 1, + "source_line": "static void copy_samples(short *dest, float *src, int len)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 5176, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "compute_samples", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "mask", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mask" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mask" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "output", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short *output", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short *output", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "num_c", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_c" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_c" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float **data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float **data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "d_offset", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int d_offset" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int d_offset" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5178, + "column": 1, + "source_line": "static void compute_samples(int mask, short *output, int num_c, float **data, int d_offset, int len)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 5178, + "column": 1, + "source_line": "static void compute_samples(int mask, short *output, int num_c, float **data, int d_offset, int len)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 5202, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "compute_stereo_samples", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "output", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short *output", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short *output", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "num_c", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_c" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_c" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float **data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float **data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "d_offset", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int d_offset" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int d_offset" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5204, + "column": 1, + "source_line": "static void compute_stereo_samples(short *output, int num_c, float **data, int d_offset, int len)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 5204, + "column": 1, + "source_line": "static void compute_stereo_samples(short *output, int num_c, float **data, int d_offset, int len)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 5242, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "convert_samples_short", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "buf_c", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int buf_c" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int buf_c" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short **buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short **buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b_offset", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b_offset" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b_offset" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "data_c", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int data_c" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int data_c" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float **data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float **data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "d_offset", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int d_offset" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int d_offset" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "samples", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int samples" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int samples" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5244, + "column": 1, + "source_line": "static void convert_samples_short(int buf_c, short **buffer, int b_offset, int data_c, float **data, int d_offset, int samples)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 5244, + "column": 1, + "source_line": "static void convert_samples_short(int buf_c, short **buffer, int b_offset, int data_c, float **data, int d_offset, int samples)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 5258, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_vorbis_get_frame_short", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stb_vorbis", + "name": "stb_vorbis", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "num_c", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_c" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_c" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short **buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short **buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "num_samples", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_samples" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_samples" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5260, + "column": 1, + "source_line": "int stb_vorbis_get_frame_short(stb_vorbis *f, int num_c, short **buffer, int num_samples)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 5260, + "column": 1, + "source_line": "int stb_vorbis_get_frame_short(stb_vorbis *f, int num_c, short **buffer, int num_samples)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 5268, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "convert_channels_short_interleaved", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "buf_c", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int buf_c" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int buf_c" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short *buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short *buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "data_c", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int data_c" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int data_c" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float **data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float **data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "d_offset", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int d_offset" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int d_offset" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5270, + "column": 1, + "source_line": "static void convert_channels_short_interleaved(int buf_c, short *buffer, int data_c, float **data, int d_offset, int len)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 5270, + "column": 1, + "source_line": "static void convert_channels_short_interleaved(int buf_c, short *buffer, int data_c, float **data, int d_offset, int len)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 5294, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_vorbis_get_frame_short_interleaved", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stb_vorbis", + "name": "stb_vorbis", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "num_c", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_c" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_c" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short *buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short *buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "num_shorts", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_shorts" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_shorts" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5296, + "column": 1, + "source_line": "int stb_vorbis_get_frame_short_interleaved(stb_vorbis *f, int num_c, short *buffer, int num_shorts)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 5296, + "column": 1, + "source_line": "int stb_vorbis_get_frame_short_interleaved(stb_vorbis *f, int num_c, short *buffer, int num_shorts)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 5307, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_vorbis_get_samples_short_interleaved", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stb_vorbis", + "name": "stb_vorbis", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "channels", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int channels" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int channels" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short *buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short *buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "num_shorts", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_shorts" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_shorts" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5309, + "column": 1, + "source_line": "int stb_vorbis_get_samples_short_interleaved(stb_vorbis *f, int channels, short *buffer, int num_shorts)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 5309, + "column": 1, + "source_line": "int stb_vorbis_get_samples_short_interleaved(stb_vorbis *f, int channels, short *buffer, int num_shorts)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 5326, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_vorbis_get_samples_short", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stb_vorbis", + "name": "stb_vorbis", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "channels", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int channels" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int channels" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short **buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short **buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5328, + "column": 1, + "source_line": "int stb_vorbis_get_samples_short(stb_vorbis *f, int channels, short **buffer, int len)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 5328, + "column": 1, + "source_line": "int stb_vorbis_get_samples_short(stb_vorbis *f, int channels, short **buffer, int len)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 5343, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_vorbis_decode_filename", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "filename", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *filename", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *filename", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "channels", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *channels", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *channels", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "sample_rate", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *sample_rate", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *sample_rate", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "output", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short **output", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short **output", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5346, + "column": 1, + "source_line": "int stb_vorbis_decode_filename(const char *filename, int *channels, int *sample_rate, short **output)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 5346, + "column": 1, + "source_line": "int stb_vorbis_decode_filename(const char *filename, int *channels, int *sample_rate, short **output)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 5383, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_vorbis_decode_memory", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "mem", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const uint8 *mem", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint8" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const uint8 *mem", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint8" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "channels", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *channels", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *channels", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "sample_rate", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *sample_rate", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *sample_rate", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "output", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short **output", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short **output", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5386, + "column": 1, + "source_line": "int stb_vorbis_decode_memory(const uint8 *mem, int len, int *channels, int *sample_rate, short **output)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 5386, + "column": 1, + "source_line": "int stb_vorbis_decode_memory(const uint8 *mem, int len, int *channels, int *sample_rate, short **output)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 5423, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_vorbis_get_samples_float_interleaved", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stb_vorbis", + "name": "stb_vorbis", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "channels", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int channels" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int channels" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "num_floats", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_floats" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_floats" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5426, + "column": 1, + "source_line": "int stb_vorbis_get_samples_float_interleaved(stb_vorbis *f, int channels, float *buffer, int num_floats)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 5426, + "column": 1, + "source_line": "int stb_vorbis_get_samples_float_interleaved(stb_vorbis *f, int channels, float *buffer, int num_floats)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 5451, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stb_vorbis_get_samples_float", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stb_vorbis", + "name": "stb_vorbis", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "channels", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int channels" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int channels" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float **buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float **buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "num_samples", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_samples" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_samples" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5453, + "column": 1, + "source_line": "int stb_vorbis_get_samples_float(stb_vorbis *f, int channels, float **buffer, int num_samples)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 5453, + "column": 1, + "source_line": "int stb_vorbis_get_samples_float(stb_vorbis *f, int channels, float **buffer, int num_samples)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 5477, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + } + ], + "structs": [ + { + "reference": "struct@stb/stb_vorbis.c:680:1" + }, + { + "reference": "struct@stb/stb_vorbis.c:703:1" + }, + { + "reference": "struct@stb/stb_vorbis.c:714:1" + }, + { + "reference": "struct@stb/stb_vorbis.c:736:1" + }, + { + "reference": "struct@stb/stb_vorbis.c:746:1" + }, + { + "reference": "struct@stb/stb_vorbis.c:753:1" + }, + { + "reference": "struct@stb/stb_vorbis.c:762:1" + }, + { + "reference": "struct@stb/stb_vorbis.c:770:1" + }, + { + "reference": "struct@stb/stb_vorbis.c:779:1" + }, + { + "reference": "struct stb_vorbis" + }, + { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "x", + "type": { + "reference": "uint16" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1317, + "column": 4, + "source_line": " uint16 x,id;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "id", + "type": { + "reference": "uint16" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1317, + "column": 4, + "source_line": " uint16 x,id;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_vorbis.c:1315:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1315, + "column": 1, + "source_line": "typedef struct" + } + }, + { + "reference": "struct@stb/stb_vorbis.c:2371:1" + } + ], + "unions": [ + { + "reference": "union@stb/stb_vorbis.c:730:1" + }, + { + "model": "CUnion", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "f", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float f" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5149, + "column": 7, + "source_line": " float f;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "i", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int i" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5150, + "column": 7, + "source_line": " int i;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "union@stb/stb_vorbis.c:5148:4", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5148, + "column": 4, + "source_line": " typedef union {" + } + } + ], + "enums": [ + { + "model": "CEnum", + "qualifiers": [], + "source_text": "", + "name": null, + "constants": [ + { + "name": "VORBIS_packet_id", + "value": "1", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1649, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "VORBIS_packet_comment", + "value": "3", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1649, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "VORBIS_packet_setup", + "value": "5", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1649, + "column": 1, + "source_line": "enum" + } + } + ], + "anonymous_id": "enum@stb/stb_vorbis.c:1649:1", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1649, + "column": 1, + "source_line": "enum" + } + } + ], + "typedefs": [ + { + "reference": "uint8" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "int8", + "name": "int8", + "type": { + "model": "CSignedChar", + "qualifiers": [], + "source_text": "typedef signed char int8" + }, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 645, + "column": 1, + "source_line": "typedef signed char int8;" + }, + "declaration_locations": [] + }, + { + "reference": "uint16" + }, + { + "reference": "int16" + }, + { + "reference": "uint32" + }, + { + "reference": "int32" + }, + { + "reference": "codetype" + }, + { + "reference": "Codebook" + }, + { + "reference": "Floor0" + }, + { + "reference": "Floor1" + }, + { + "reference": "Floor" + }, + { + "reference": "Residue" + }, + { + "reference": "MappingChannel" + }, + { + "reference": "Mapping" + }, + { + "reference": "Mode" + }, + { + "reference": "CRCscan" + }, + { + "reference": "ProbedPage" + }, + { + "reference": "vorb" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbv__floor_ordering", + "name": "stbv__floor_ordering", + "type": { + "reference": "struct@stb/stb_vorbis.c:1315:1" + }, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1315, + "column": 1, + "source_line": "typedef struct" + }, + "declaration_locations": [] + }, + { + "reference": "mdct_lookup" + }, + { + "reference": "YTYPE" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "float_conv", + "name": "float_conv", + "type": { + "reference": "union@stb/stb_vorbis.c:5148:4" + }, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5148, + "column": 4, + "source_line": " typedef union {" + }, + "declaration_locations": [] + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stb_vorbis_float_size_test", + "name": "stb_vorbis_float_size_test", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "typedef char stb_vorbis_float_size_test[sizeof(float)==4 && sizeof(int) == 4]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "sizeof(float)==4 && sizeof(int) == 4", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5152, + "column": 4, + "source_line": " typedef char stb_vorbis_float_size_test[sizeof(float)==4 && sizeof(int) == 4];" + }, + "declaration_locations": [] + } + ], + "variables": [ + { + "name": "crc_table", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "static uint32 crc_table[256]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "256", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "reference": "uint32" + } + ] + }, + "storage": [ + "static" + ], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 991, + "column": 1, + "source_line": "static uint32 crc_table[256];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "integer_divide_table", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int8 integer_divide_table[DIVTAB_NUMER][DIVTAB_DENOM]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "DIVTAB_NUMER", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "DIVTAB_DENOM", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "reference": "int8" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2031, + "column": 1, + "source_line": "int8 integer_divide_table[DIVTAB_NUMER][DIVTAB_DENOM]; // 2KB" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "M1", + "type": { + "reference": "mdct_lookup" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2386, + "column": 1, + "source_line": "mdct_lookup M1,M2;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "M2", + "type": { + "reference": "mdct_lookup" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2386, + "column": 1, + "source_line": "mdct_lookup M1,M2;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "macros": [ + { + "name": "STB_VORBIS_INCLUDE_STB_VORBIS_H", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 75, + "column": 1, + "source_line": "#define STB_VORBIS_INCLUDE_STB_VORBIS_H" + } + }, + { + "name": "STB_VORBIS_NO_STDIO", + "value": "1", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 78, + "column": 1, + "source_line": "#define STB_VORBIS_NO_STDIO 1" + } + }, + { + "name": "STB_VORBIS_MAX_CHANNELS", + "value": "16", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 461, + "column": 1, + "source_line": "#define STB_VORBIS_MAX_CHANNELS 16 // enough for anyone?" + } + }, + { + "name": "STB_VORBIS_PUSHDATA_CRC_COUNT", + "value": "4", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 477, + "column": 1, + "source_line": "#define STB_VORBIS_PUSHDATA_CRC_COUNT 4" + } + }, + { + "name": "STB_VORBIS_FAST_HUFFMAN_LENGTH", + "value": "10", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 486, + "column": 1, + "source_line": "#define STB_VORBIS_FAST_HUFFMAN_LENGTH 10" + } + }, + { + "name": "STB_VORBIS_FAST_HUFFMAN_SHORT", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 500, + "column": 1, + "source_line": "#define STB_VORBIS_FAST_HUFFMAN_SHORT" + } + }, + { + "name": "STB_VORBIS_NO_INTEGER_CONVERSION", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 553, + "column": 4, + "source_line": " #define STB_VORBIS_NO_INTEGER_CONVERSION" + } + }, + { + "name": "STB_VORBIS_NO_STDIO", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 554, + "column": 4, + "source_line": " #define STB_VORBIS_NO_STDIO" + } + }, + { + "name": "STB_VORBIS_NO_STDIO", + "value": "1", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 558, + "column": 4, + "source_line": " #define STB_VORBIS_NO_STDIO 1" + } + }, + { + "name": "STB_VORBIS_ENDIAN", + "value": "0", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 568, + "column": 6, + "source_line": " #define STB_VORBIS_ENDIAN 0" + } + }, + { + "name": "STB_VORBIS_ENDIAN", + "value": "1", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 570, + "column": 6, + "source_line": " #define STB_VORBIS_ENDIAN 1" + } + }, + { + "name": "NULL", + "value": "0", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 595, + "column": 4, + "source_line": " #define NULL 0" + } + }, + { + "name": "malloc", + "value": "0", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 596, + "column": 4, + "source_line": " #define malloc(s) 0" + } + }, + { + "name": "free", + "value": "((void) 0)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 597, + "column": 4, + "source_line": " #define free(s) ((void) 0)" + } + }, + { + "name": "realloc", + "value": "0", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 598, + "column": 4, + "source_line": " #define realloc(s) 0" + } + }, + { + "name": "__forceinline", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 610, + "column": 4, + "source_line": " #undef __forceinline" + } + }, + { + "name": "__forceinline", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 612, + "column": 4, + "source_line": " #define __forceinline" + } + }, + { + "name": "alloca", + "value": "__builtin_alloca", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 614, + "column": 4, + "source_line": " #define alloca __builtin_alloca" + } + }, + { + "name": "__forceinline", + "value": "inline", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 618, + "column": 7, + "source_line": " #define __forceinline inline" + } + }, + { + "name": "__forceinline", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 620, + "column": 7, + "source_line": " #define __forceinline" + } + }, + { + "name": "CHECK", + "value": "_CrtIsValidHeapPointer(f->channel_buffers[1])", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 635, + "column": 1, + "source_line": "#define CHECK(f) _CrtIsValidHeapPointer(f->channel_buffers[1])" + } + }, + { + "name": "CHECK", + "value": "((void) 0)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 637, + "column": 1, + "source_line": "#define CHECK(f) ((void) 0)" + } + }, + { + "name": "MAX_BLOCKSIZE_LOG", + "value": "13", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 640, + "column": 1, + "source_line": "#define MAX_BLOCKSIZE_LOG 13 // from specification" + } + }, + { + "name": "MAX_BLOCKSIZE", + "value": "(1 << MAX_BLOCKSIZE_LOG)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 641, + "column": 1, + "source_line": "#define MAX_BLOCKSIZE (1 << MAX_BLOCKSIZE_LOG)" + } + }, + { + "name": "TRUE", + "value": "1", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 652, + "column": 1, + "source_line": "#define TRUE 1" + } + }, + { + "name": "FALSE", + "value": "0", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 653, + "column": 1, + "source_line": "#define FALSE 0" + } + }, + { + "name": "STBV_NOTUSED", + "value": "(void)(v)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 659, + "column": 1, + "source_line": "#define STBV_NOTUSED(v) (void)(v)" + } + }, + { + "name": "STBV_NOTUSED", + "value": "(void)sizeof(v)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 661, + "column": 1, + "source_line": "#define STBV_NOTUSED(v) (void)sizeof(v)" + } + }, + { + "name": "FAST_HUFFMAN_TABLE_SIZE", + "value": "(1 << STB_VORBIS_FAST_HUFFMAN_LENGTH)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 677, + "column": 1, + "source_line": "#define FAST_HUFFMAN_TABLE_SIZE (1 << STB_VORBIS_FAST_HUFFMAN_LENGTH)" + } + }, + { + "name": "FAST_HUFFMAN_TABLE_MASK", + "value": "(FAST_HUFFMAN_TABLE_SIZE - 1)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 678, + "column": 1, + "source_line": "#define FAST_HUFFMAN_TABLE_MASK (FAST_HUFFMAN_TABLE_SIZE - 1)" + } + }, + { + "name": "IS_PUSH_MODE", + "value": "FALSE", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 904, + "column": 4, + "source_line": " #define IS_PUSH_MODE(f) FALSE" + } + }, + { + "name": "IS_PUSH_MODE", + "value": "TRUE", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 906, + "column": 4, + "source_line": " #define IS_PUSH_MODE(f) TRUE" + } + }, + { + "name": "IS_PUSH_MODE", + "value": "((f)->push_mode)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 908, + "column": 4, + "source_line": " #define IS_PUSH_MODE(f) ((f)->push_mode)" + } + }, + { + "name": "array_size_required", + "value": "(count*(sizeof(void *)+(size)))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 928, + "column": 1, + "source_line": "#define array_size_required(count,size) (count*(sizeof(void *)+(size)))" + } + }, + { + "name": "temp_alloc", + "value": "(f->alloc.alloc_buffer ? setup_temp_malloc(f,size) : alloca(size))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 930, + "column": 1, + "source_line": "#define temp_alloc(f,size) (f->alloc.alloc_buffer ? setup_temp_malloc(f,size) : alloca(size))" + } + }, + { + "name": "temp_free", + "value": "(void)0", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 931, + "column": 1, + "source_line": "#define temp_free(f,p) (void)0" + } + }, + { + "name": "temp_alloc_save", + "value": "((f)->temp_offset)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 932, + "column": 1, + "source_line": "#define temp_alloc_save(f) ((f)->temp_offset)" + } + }, + { + "name": "temp_alloc_restore", + "value": "((f)->temp_offset = (p))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 933, + "column": 1, + "source_line": "#define temp_alloc_restore(f,p) ((f)->temp_offset = (p))" + } + }, + { + "name": "temp_block_array", + "value": "make_block_array(temp_alloc(f,array_size_required(count,size)), count, size)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 935, + "column": 1, + "source_line": "#define temp_block_array(f,count,size) make_block_array(temp_alloc(f,array_size_required(count,size)), count, size)" + } + }, + { + "name": "CRC32_POLY", + "value": "0x04c11db7", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 989, + "column": 1, + "source_line": "#define CRC32_POLY 0x04c11db7 // from spec" + } + }, + { + "name": "M_PI", + "value": "3.14159265358979323846264f", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1046, + "column": 3, + "source_line": " #define M_PI 3.14159265358979323846264f // from CRC" + } + }, + { + "name": "NO_CODE", + "value": "255", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1050, + "column": 1, + "source_line": "#define NO_CODE 255" + } + }, + { + "name": "STBV_CDECL", + "value": "__cdecl", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1157, + "column": 1, + "source_line": "#define STBV_CDECL __cdecl" + } + }, + { + "name": "STBV_CDECL", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1159, + "column": 1, + "source_line": "#define STBV_CDECL" + } + }, + { + "name": "USE_MEMORY", + "value": "TRUE", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1332, + "column": 4, + "source_line": " #define USE_MEMORY(z) TRUE" + } + }, + { + "name": "USE_MEMORY", + "value": "((z)->stream)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1334, + "column": 4, + "source_line": " #define USE_MEMORY(z) ((z)->stream)" + } + }, + { + "name": "PAGEFLAG_continued_packet", + "value": "1", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1440, + "column": 1, + "source_line": "#define PAGEFLAG_continued_packet 1" + } + }, + { + "name": "PAGEFLAG_first_page", + "value": "2", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1441, + "column": 1, + "source_line": "#define PAGEFLAG_first_page 2" + } + }, + { + "name": "PAGEFLAG_last_page", + "value": "4", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1442, + "column": 1, + "source_line": "#define PAGEFLAG_last_page 4" + } + }, + { + "name": "EOP", + "value": "(-1)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1560, + "column": 1, + "source_line": "#define EOP (-1)" + } + }, + { + "name": "INVALID_BITS", + "value": "(-1)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1561, + "column": 1, + "source_line": "#define INVALID_BITS (-1)" + } + }, + { + "name": "DECODE_RAW", + "value": "if (f->valid_bits < STB_VORBIS_FAST_HUFFMAN_LENGTH) prep_huffman(f); var = f->acc & FAST_HUFFMAN_TABLE_MASK; var = c->fast_huffman[var]; if (var >= 0) { int n = c->codeword_lengths[var]; f->acc >>= n; f->valid_bits -= n; if (f->valid_bits < 0) { f->valid_bits = 0; var = -1; } } else { var = codebook_decode_scalar_raw(f,c); }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1717, + "column": 1, + "source_line": "#define DECODE_RAW(var, f,c) \\" + } + }, + { + "name": "DECODE_RAW", + "value": "var = codebook_decode_scalar(f,c);", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1750, + "column": 1, + "source_line": "#define DECODE_RAW(var,f,c) var = codebook_decode_scalar(f,c);" + } + }, + { + "name": "DECODE", + "value": "DECODE_RAW(var,f,c) if (c->sparse) var = c->sorted_values[var];", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1754, + "column": 1, + "source_line": "#define DECODE(var,f,c) \\" + } + }, + { + "name": "DECODE_VQ", + "value": "DECODE_RAW(var,f,c)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1759, + "column": 3, + "source_line": " #define DECODE_VQ(var,f,c) DECODE_RAW(var,f,c)" + } + }, + { + "name": "DECODE_VQ", + "value": "DECODE(var,f,c)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1761, + "column": 3, + "source_line": " #define DECODE_VQ(var,f,c) DECODE(var,f,c)" + } + }, + { + "name": "CODEBOOK_ELEMENT", + "value": "(c->multiplicands[off])", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1771, + "column": 1, + "source_line": "#define CODEBOOK_ELEMENT(c,off) (c->multiplicands[off])" + } + }, + { + "name": "CODEBOOK_ELEMENT_FAST", + "value": "(c->multiplicands[off])", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1772, + "column": 1, + "source_line": "#define CODEBOOK_ELEMENT_FAST(c,off) (c->multiplicands[off])" + } + }, + { + "name": "CODEBOOK_ELEMENT_BASE", + "value": "(0)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1773, + "column": 1, + "source_line": "#define CODEBOOK_ELEMENT_BASE(c) (0)" + } + }, + { + "name": "LINE_OP", + "value": "a *= b", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2023, + "column": 1, + "source_line": "#define LINE_OP(a,b) a *= b" + } + }, + { + "name": "LINE_OP", + "value": "a = b", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2025, + "column": 1, + "source_line": "#define LINE_OP(a,b) a = b" + } + }, + { + "name": "DIVTAB_NUMER", + "value": "32", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2029, + "column": 1, + "source_line": "#define DIVTAB_NUMER 32" + } + }, + { + "name": "DIVTAB_DENOM", + "value": "64", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2030, + "column": 1, + "source_line": "#define DIVTAB_DENOM 64" + } + }, + { + "name": "LIBVORBIS_MDCT", + "value": "0", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2365, + "column": 1, + "source_line": "#define LIBVORBIS_MDCT 0" + } + }, + { + "name": "SAMPLE_unknown", + "value": "0xffffffff", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 4632, + "column": 1, + "source_line": "#define SAMPLE_unknown 0xffffffff" + } + }, + { + "name": "PLAYBACK_MONO", + "value": "1", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5127, + "column": 1, + "source_line": "#define PLAYBACK_MONO 1" + } + }, + { + "name": "PLAYBACK_LEFT", + "value": "2", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5128, + "column": 1, + "source_line": "#define PLAYBACK_LEFT 2" + } + }, + { + "name": "PLAYBACK_RIGHT", + "value": "4", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5129, + "column": 1, + "source_line": "#define PLAYBACK_RIGHT 4" + } + }, + { + "name": "L", + "value": "(PLAYBACK_LEFT | PLAYBACK_MONO)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5131, + "column": 1, + "source_line": "#define L (PLAYBACK_LEFT | PLAYBACK_MONO)" + } + }, + { + "name": "C", + "value": "(PLAYBACK_LEFT | PLAYBACK_RIGHT | PLAYBACK_MONO)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5132, + "column": 1, + "source_line": "#define C (PLAYBACK_LEFT | PLAYBACK_RIGHT | PLAYBACK_MONO)" + } + }, + { + "name": "R", + "value": "(PLAYBACK_RIGHT | PLAYBACK_MONO)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5133, + "column": 1, + "source_line": "#define R (PLAYBACK_RIGHT | PLAYBACK_MONO)" + } + }, + { + "name": "FASTDEF", + "value": "float_conv x", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5153, + "column": 4, + "source_line": " #define FASTDEF(x) float_conv x" + } + }, + { + "name": "MAGIC", + "value": "(1.5f * (1 << (23-SHIFT)) + 0.5f/(1 << SHIFT))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5155, + "column": 4, + "source_line": " #define MAGIC(SHIFT) (1.5f * (1 << (23-SHIFT)) + 0.5f/(1 << SHIFT))" + } + }, + { + "name": "ADDEND", + "value": "(((150-SHIFT) << 23) + (1 << 22))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5156, + "column": 4, + "source_line": " #define ADDEND(SHIFT) (((150-SHIFT) << 23) + (1 << 22))" + } + }, + { + "name": "FAST_SCALED_FLOAT_TO_INT", + "value": "(temp.f = (x) + MAGIC(s), temp.i - ADDEND(s))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5157, + "column": 4, + "source_line": " #define FAST_SCALED_FLOAT_TO_INT(temp,x,s) (temp.f = (x) + MAGIC(s), temp.i - ADDEND(s))" + } + }, + { + "name": "check_endianness", + "value": null, + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5158, + "column": 4, + "source_line": " #define check_endianness()" + } + }, + { + "name": "FAST_SCALED_FLOAT_TO_INT", + "value": "((int) ((x) * (1 << (s))))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5160, + "column": 4, + "source_line": " #define FAST_SCALED_FLOAT_TO_INT(temp,x,s) ((int) ((x) * (1 << (s))))" + } + }, + { + "name": "check_endianness", + "value": null, + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5161, + "column": 4, + "source_line": " #define check_endianness()" + } + }, + { + "name": "FASTDEF", + "value": null, + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5162, + "column": 4, + "source_line": " #define FASTDEF(x)" + } + }, + { + "name": "STB_BUFFER_SIZE", + "value": "32", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5180, + "column": 4, + "source_line": " #define STB_BUFFER_SIZE 32" + } + }, + { + "name": "STB_BUFFER_SIZE", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5201, + "column": 4, + "source_line": " #undef STB_BUFFER_SIZE" + } + }, + { + "name": "STB_BUFFER_SIZE", + "value": "32", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5206, + "column": 4, + "source_line": " #define STB_BUFFER_SIZE 32" + } + }, + { + "name": "STB_BUFFER_SIZE", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5241, + "column": 4, + "source_line": " #undef STB_BUFFER_SIZE" + } + } + ], + "includes": [ + { + "target": "stdio.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 82, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "stdio.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 578, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "stdlib.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 582, + "column": 4, + "source_line": " #include " + } + }, + { + "target": "string.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 583, + "column": 4, + "source_line": " #include " + } + }, + { + "target": "assert.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 584, + "column": 4, + "source_line": " #include " + } + }, + { + "target": "math.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 585, + "column": 4, + "source_line": " #include " + } + }, + { + "target": "malloc.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 589, + "column": 7, + "source_line": " #include " + } + }, + { + "target": "alloca.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 592, + "column": 7, + "source_line": " #include " + } + }, + { + "target": "limits.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 601, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "crtdbg.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 634, + "column": 1, + "source_line": "#include " + } + } + ], + "raw_directives": [ + { + "directive": "ifndef", + "argument": "STB_VORBIS_INCLUDE_STB_VORBIS_H", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 74, + "column": 1, + "source_line": "#ifndef STB_VORBIS_INCLUDE_STB_VORBIS_H" + } + }, + { + "directive": "if", + "argument": "defined(STB_VORBIS_NO_CRT) && !defined(STB_VORBIS_NO_STDIO)", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 77, + "column": 1, + "source_line": "#if defined(STB_VORBIS_NO_CRT) && !defined(STB_VORBIS_NO_STDIO)" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 79, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_VORBIS_NO_STDIO", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 81, + "column": 1, + "source_line": "#ifndef STB_VORBIS_NO_STDIO" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 83, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "__cplusplus", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 85, + "column": 1, + "source_line": "#ifdef __cplusplus" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 87, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_VORBIS_NO_PUSHDATA_API", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 174, + "column": 1, + "source_line": "#ifndef STB_VORBIS_NO_PUSHDATA_API" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 244, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_VORBIS_NO_PULLDATA_API", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 249, + "column": 1, + "source_line": "#ifndef STB_VORBIS_NO_PULLDATA_API" + } + }, + { + "directive": "if", + "argument": "!defined(STB_VORBIS_NO_STDIO) && !defined(STB_VORBIS_NO_INTEGER_CONVERSION)", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 257, + "column": 1, + "source_line": "#if !defined(STB_VORBIS_NO_STDIO) && !defined(STB_VORBIS_NO_INTEGER_CONVERSION)" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 259, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "!defined(STB_VORBIS_NO_INTEGER_CONVERSION)", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 260, + "column": 1, + "source_line": "#if !defined(STB_VORBIS_NO_INTEGER_CONVERSION)" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 262, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_VORBIS_NO_STDIO", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 273, + "column": 1, + "source_line": "#ifndef STB_VORBIS_NO_STDIO" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 296, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_VORBIS_NO_INTEGER_CONVERSION", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 324, + "column": 1, + "source_line": "#ifndef STB_VORBIS_NO_INTEGER_CONVERSION" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 327, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_VORBIS_NO_INTEGER_CONVERSION", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 360, + "column": 1, + "source_line": "#ifndef STB_VORBIS_NO_INTEGER_CONVERSION" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 363, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 370, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "__cplusplus", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 410, + "column": 1, + "source_line": "#ifdef __cplusplus" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 412, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 414, + "column": 1, + "source_line": "#endif // STB_VORBIS_INCLUDE_STB_VORBIS_H" + } + }, + { + "directive": "ifndef", + "argument": "STB_VORBIS_HEADER_ONLY", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 420, + "column": 1, + "source_line": "#ifndef STB_VORBIS_HEADER_ONLY" + } + }, + { + "directive": "ifndef", + "argument": "STB_VORBIS_MAX_CHANNELS", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 460, + "column": 1, + "source_line": "#ifndef STB_VORBIS_MAX_CHANNELS" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 462, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_VORBIS_PUSHDATA_CRC_COUNT", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 476, + "column": 1, + "source_line": "#ifndef STB_VORBIS_PUSHDATA_CRC_COUNT" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 478, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_VORBIS_FAST_HUFFMAN_LENGTH", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 485, + "column": 1, + "source_line": "#ifndef STB_VORBIS_FAST_HUFFMAN_LENGTH" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 487, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_VORBIS_FAST_HUFFMAN_INT", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 499, + "column": 1, + "source_line": "#ifndef STB_VORBIS_FAST_HUFFMAN_INT" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 501, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STB_VORBIS_CODEBOOK_SHORTS", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 527, + "column": 1, + "source_line": "#ifdef STB_VORBIS_CODEBOOK_SHORTS" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 529, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STB_VORBIS_NO_PULLDATA_API", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 552, + "column": 1, + "source_line": "#ifdef STB_VORBIS_NO_PULLDATA_API" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 555, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "defined(STB_VORBIS_NO_CRT) && !defined(STB_VORBIS_NO_STDIO)", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 557, + "column": 1, + "source_line": "#if defined(STB_VORBIS_NO_CRT) && !defined(STB_VORBIS_NO_STDIO)" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 559, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_VORBIS_NO_INTEGER_CONVERSION", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 561, + "column": 1, + "source_line": "#ifndef STB_VORBIS_NO_INTEGER_CONVERSION" + } + }, + { + "directive": "ifndef", + "argument": "STB_VORBIS_NO_FAST_SCALED_FLOAT", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 562, + "column": 1, + "source_line": "#ifndef STB_VORBIS_NO_FAST_SCALED_FLOAT" + } + }, + { + "directive": "ifndef", + "argument": "STB_VORBIS_BIG_ENDIAN", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 567, + "column": 4, + "source_line": " #ifndef STB_VORBIS_BIG_ENDIAN" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 569, + "column": 4, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 571, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 573, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 574, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_VORBIS_NO_STDIO", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 577, + "column": 1, + "source_line": "#ifndef STB_VORBIS_NO_STDIO" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 579, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_VORBIS_NO_CRT", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 581, + "column": 1, + "source_line": "#ifndef STB_VORBIS_NO_CRT" + } + }, + { + "directive": "if", + "argument": "defined(_MSC_VER) || defined(__MINGW32__)", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 588, + "column": 4, + "source_line": " #if defined(_MSC_VER) || defined(__MINGW32__)" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 590, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "defined(__linux__) || defined(__linux) || defined(__sun__) || defined(__EMSCRIPTEN__) || defined(__NEWLIB__)", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 591, + "column": 4, + "source_line": " #if defined(__linux__) || defined(__linux) || defined(__sun__) || defined(__EMSCRIPTEN__) || defined(__NEWLIB__)" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 593, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 594, + "column": 1, + "source_line": "#else // STB_VORBIS_NO_CRT" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 599, + "column": 1, + "source_line": "#endif // STB_VORBIS_NO_CRT" + } + }, + { + "directive": "ifdef", + "argument": "__MINGW32__", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 603, + "column": 1, + "source_line": "#ifdef __MINGW32__" + } + }, + { + "directive": "ifdef", + "argument": "__forceinline", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 609, + "column": 4, + "source_line": " #ifdef __forceinline" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 611, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "alloca", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 613, + "column": 4, + "source_line": " #ifndef alloca" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 615, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "elif", + "argument": "!defined(_MSC_VER)", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 616, + "column": 1, + "source_line": "#elif !defined(_MSC_VER)" + } + }, + { + "directive": "if", + "argument": "__GNUC__", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 617, + "column": 4, + "source_line": " #if __GNUC__" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 619, + "column": 4, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 621, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 622, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "STB_VORBIS_MAX_CHANNELS > 256", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 624, + "column": 1, + "source_line": "#if STB_VORBIS_MAX_CHANNELS > 256" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 626, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "STB_VORBIS_FAST_HUFFMAN_LENGTH > 24", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 628, + "column": 1, + "source_line": "#if STB_VORBIS_FAST_HUFFMAN_LENGTH > 24" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 630, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "0", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 633, + "column": 1, + "source_line": "#if 0" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 636, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 638, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "TRUE", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 651, + "column": 1, + "source_line": "#ifndef TRUE" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 654, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "_MSC_VER", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 658, + "column": 1, + "source_line": "#ifdef _MSC_VER" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 660, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 662, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STB_VORBIS_FAST_HUFFMAN_SHORT", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 693, + "column": 4, + "source_line": " #ifdef STB_VORBIS_FAST_HUFFMAN_SHORT" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 695, + "column": 4, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 697, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_VORBIS_NO_STDIO", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 800, + "column": 1, + "source_line": "#ifndef STB_VORBIS_NO_STDIO" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 804, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_VORBIS_NO_DEFER_FLOOR", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 857, + "column": 4, + "source_line": " #ifndef STB_VORBIS_NO_DEFER_FLOOR" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 859, + "column": 4, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 861, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_VORBIS_NO_PUSHDATA_API", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 894, + "column": 1, + "source_line": "#ifndef STB_VORBIS_NO_PUSHDATA_API" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 896, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "defined(STB_VORBIS_NO_PUSHDATA_API)", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 903, + "column": 1, + "source_line": "#if defined(STB_VORBIS_NO_PUSHDATA_API)" + } + }, + { + "directive": "elif", + "argument": "defined(STB_VORBIS_NO_PULLDATA_API)", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 905, + "column": 1, + "source_line": "#elif defined(STB_VORBIS_NO_PULLDATA_API)" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 907, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 909, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "M_PI", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1045, + "column": 1, + "source_line": "#ifndef M_PI" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1047, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STB_VORBIS_FAST_HUFFMAN_SHORT", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1141, + "column": 4, + "source_line": " #ifdef STB_VORBIS_FAST_HUFFMAN_SHORT" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1143, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "_MSC_VER", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1156, + "column": 1, + "source_line": "#ifdef _MSC_VER" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1158, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1160, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "defined(STB_VORBIS_NO_STDIO)", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1331, + "column": 1, + "source_line": "#if defined(STB_VORBIS_NO_STDIO)" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1333, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1335, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_VORBIS_NO_STDIO", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1344, + "column": 4, + "source_line": " #ifndef STB_VORBIS_NO_STDIO" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1350, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_VORBIS_NO_STDIO", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1372, + "column": 4, + "source_line": " #ifndef STB_VORBIS_NO_STDIO" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1379, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_VORBIS_NO_STDIO", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1389, + "column": 4, + "source_line": " #ifndef STB_VORBIS_NO_STDIO" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1394, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_VORBIS_NO_PUSHDATA_API", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1399, + "column": 4, + "source_line": " #ifndef STB_VORBIS_NO_PUSHDATA_API" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1401, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_VORBIS_NO_STDIO", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1413, + "column": 4, + "source_line": " #ifndef STB_VORBIS_NO_STDIO" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1425, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_VORBIS_NO_INLINE_DECODE", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1715, + "column": 1, + "source_line": "#ifndef STB_VORBIS_NO_INLINE_DECODE" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1731, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1752, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_VORBIS_DIVIDES_IN_CODEBOOK", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1758, + "column": 1, + "source_line": "#ifndef STB_VORBIS_DIVIDES_IN_CODEBOOK" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1760, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1762, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STB_VORBIS_DIVIDES_IN_CODEBOOK", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1801, + "column": 1, + "source_line": "#ifdef STB_VORBIS_DIVIDES_IN_CODEBOOK" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1814, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STB_VORBIS_DIVIDES_IN_CODEBOOK", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1841, + "column": 1, + "source_line": "#ifdef STB_VORBIS_DIVIDES_IN_CODEBOOK" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1853, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_VORBIS_DIVIDES_IN_CODEBOOK", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1877, + "column": 7, + "source_line": " #ifndef STB_VORBIS_DIVIDES_IN_CODEBOOK" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1879, + "column": 7, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "STB_VORBIS_DIVIDES_IN_CODEBOOK", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1894, + "column": 4, + "source_line": " #ifdef STB_VORBIS_DIVIDES_IN_CODEBOOK" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1907, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_VORBIS_NO_DEFER_FLOOR", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2022, + "column": 1, + "source_line": "#ifndef STB_VORBIS_NO_DEFER_FLOOR" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2024, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2026, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STB_VORBIS_DIVIDE_TABLE", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2028, + "column": 1, + "source_line": "#ifdef STB_VORBIS_DIVIDE_TABLE" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2032, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STB_VORBIS_DIVIDE_TABLE", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2044, + "column": 1, + "source_line": "#ifdef STB_VORBIS_DIVIDE_TABLE" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2060, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2066, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_VORBIS_DIVIDES_IN_RESIDUE", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2117, + "column": 4, + "source_line": " #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2119, + "column": 4, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2121, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_VORBIS_DIVIDES_IN_RESIDUE", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2147, + "column": 19, + "source_line": " #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2149, + "column": 19, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2154, + "column": 19, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_VORBIS_DIVIDES_IN_RESIDUE", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2158, + "column": 19, + "source_line": " #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2160, + "column": 19, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2162, + "column": 19, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "STB_VORBIS_DIVIDES_IN_CODEBOOK", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2166, + "column": 22, + "source_line": " #ifdef STB_VORBIS_DIVIDES_IN_CODEBOOK" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2169, + "column": 22, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2173, + "column": 22, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_VORBIS_DIVIDES_IN_RESIDUE", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2180, + "column": 16, + "source_line": " #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2182, + "column": 16, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_VORBIS_DIVIDES_IN_RESIDUE", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2193, + "column": 19, + "source_line": " #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2195, + "column": 19, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2200, + "column": 19, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_VORBIS_DIVIDES_IN_RESIDUE", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2204, + "column": 19, + "source_line": " #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2206, + "column": 19, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2208, + "column": 19, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_VORBIS_DIVIDES_IN_RESIDUE", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2220, + "column": 16, + "source_line": " #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2222, + "column": 16, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_VORBIS_DIVIDES_IN_RESIDUE", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2240, + "column": 19, + "source_line": " #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2242, + "column": 19, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2247, + "column": 19, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_VORBIS_DIVIDES_IN_RESIDUE", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2254, + "column": 19, + "source_line": " #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2256, + "column": 19, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2258, + "column": 19, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_VORBIS_DIVIDES_IN_RESIDUE", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2271, + "column": 10, + "source_line": " #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2273, + "column": 10, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_VORBIS_DIVIDES_IN_RESIDUE", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2278, + "column": 4, + "source_line": " #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2280, + "column": 4, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2282, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "0", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2287, + "column": 1, + "source_line": "#if 0" + } + }, + { + "directive": "elif", + "argument": "0", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2310, + "column": 1, + "source_line": "#elif 0" + } + }, + { + "directive": "elif", + "argument": "0", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2330, + "column": 1, + "source_line": "#elif 0" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2362, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "LIBVORBIS_MDCT", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2364, + "column": 1, + "source_line": "#ifndef LIBVORBIS_MDCT" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2366, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "LIBVORBIS_MDCT", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2368, + "column": 1, + "source_line": "#if LIBVORBIS_MDCT" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2402, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "0", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2931, + "column": 1, + "source_line": "#if 0" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 3057, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_VORBIS_NO_DEFER_FLOOR", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 3067, + "column": 1, + "source_line": "#ifndef STB_VORBIS_NO_DEFER_FLOOR" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 3069, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 3071, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_VORBIS_NO_DEFER_FLOOR", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 3085, + "column": 10, + "source_line": " #ifndef STB_VORBIS_NO_DEFER_FLOOR" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 3088, + "column": 10, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 3090, + "column": 10, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "STB_VORBIS_NO_DEFER_FLOOR", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 3271, + "column": 1, + "source_line": "#ifdef STB_VORBIS_NO_DEFER_FLOOR" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 3273, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 3279, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_VORBIS_NO_DEFER_FLOOR", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 3353, + "column": 1, + "source_line": "#ifndef STB_VORBIS_NO_DEFER_FLOOR" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 3361, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 3370, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_VORBIS_NO_PUSHDATA_API", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 3518, + "column": 1, + "source_line": "#ifndef STB_VORBIS_NO_PUSHDATA_API" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 3578, + "column": 1, + "source_line": "#endif // !STB_VORBIS_NO_PUSHDATA_API" + } + }, + { + "directive": "ifndef", + "argument": "STB_VORBIS_NO_PUSHDATA_API", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 3696, + "column": 4, + "source_line": " #ifndef STB_VORBIS_NO_PUSHDATA_API" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 3705, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_VORBIS_NO_HUFFMAN_BINARY_SEARCH", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 3790, + "column": 10, + "source_line": " #ifndef STB_VORBIS_NO_HUFFMAN_BINARY_SEARCH" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 3794, + "column": 10, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_VORBIS_DIVIDES_IN_CODEBOOK", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 3871, + "column": 1, + "source_line": "#ifndef STB_VORBIS_DIVIDES_IN_CODEBOOK" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 3904, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_VORBIS_DIVIDES_IN_CODEBOOK", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 3917, + "column": 1, + "source_line": "#ifndef STB_VORBIS_DIVIDES_IN_CODEBOOK" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 3919, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STB_VORBIS_NO_DEFER_FLOOR", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 4137, + "column": 7, + "source_line": " #ifdef STB_VORBIS_NO_DEFER_FLOOR" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 4140, + "column": 7, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "STB_VORBIS_DIVIDE_TABLE", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 4148, + "column": 1, + "source_line": "#ifdef STB_VORBIS_DIVIDE_TABLE" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 4153, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_VORBIS_DIVIDES_IN_RESIDUE", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 4172, + "column": 7, + "source_line": " #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 4174, + "column": 7, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 4176, + "column": 7, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "STB_VORBIS_NO_DEFER_FLOOR", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 4254, + "column": 7, + "source_line": " #ifdef STB_VORBIS_NO_DEFER_FLOOR" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 4256, + "column": 7, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_VORBIS_NO_STDIO", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 4266, + "column": 4, + "source_line": " #ifndef STB_VORBIS_NO_STDIO" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 4268, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_VORBIS_NO_STDIO", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 4291, + "column": 4, + "source_line": " #ifndef STB_VORBIS_NO_STDIO" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 4294, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_VORBIS_NO_PUSHDATA_API", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 4339, + "column": 1, + "source_line": "#ifndef STB_VORBIS_NO_PUSHDATA_API" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 4543, + "column": 1, + "source_line": "#endif // STB_VORBIS_NO_PUSHDATA_API" + } + }, + { + "directive": "ifndef", + "argument": "STB_VORBIS_NO_PUSHDATA_API", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 4547, + "column": 4, + "source_line": " #ifndef STB_VORBIS_NO_PUSHDATA_API" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 4549, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_VORBIS_NO_STDIO", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 4551, + "column": 4, + "source_line": " #ifndef STB_VORBIS_NO_STDIO" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 4553, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_VORBIS_NO_PULLDATA_API", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 4556, + "column": 1, + "source_line": "#ifndef STB_VORBIS_NO_PULLDATA_API" + } + }, + { + "directive": "ifndef", + "argument": "STB_VORBIS_NO_STDIO", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5050, + "column": 1, + "source_line": "#ifndef STB_VORBIS_NO_STDIO" + } + }, + { + "directive": "if", + "argument": "defined(_WIN32) && defined(__STDC_WANT_SECURE_LIB__)", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5086, + "column": 1, + "source_line": "#if defined(_WIN32) && defined(__STDC_WANT_SECURE_LIB__)" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5089, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5091, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5097, + "column": 1, + "source_line": "#endif // STB_VORBIS_NO_STDIO" + } + }, + { + "directive": "ifndef", + "argument": "STB_VORBIS_NO_INTEGER_CONVERSION", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5126, + "column": 1, + "source_line": "#ifndef STB_VORBIS_NO_INTEGER_CONVERSION" + } + }, + { + "directive": "ifndef", + "argument": "STB_VORBIS_NO_FAST_SCALED_FLOAT", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5147, + "column": 1, + "source_line": "#ifndef STB_VORBIS_NO_FAST_SCALED_FLOAT" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5159, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5163, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STB_VORBIS_NO_STDIO", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5345, + "column": 1, + "source_line": "#ifndef STB_VORBIS_NO_STDIO" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5384, + "column": 1, + "source_line": "#endif // NO_STDIO" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5424, + "column": 1, + "source_line": "#endif // STB_VORBIS_NO_INTEGER_CONVERSION" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5478, + "column": 1, + "source_line": "#endif // STB_VORBIS_NO_PULLDATA_API" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5541, + "column": 1, + "source_line": "#endif // STB_VORBIS_HEADER_ONLY" + } + } + ], + "macro_dependencies": [ + { + "name": "__forceinline", + "context": "declaration", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1003, + "column": 1, + "source_line": "static __forceinline uint32 crc32_update(uint32 crc, uint8 byte)" + }, + "source_text": "static __forceinline uint32 crc32_update(uint32 crc, uint8 byte)" + }, + { + "name": "__forceinline", + "context": "declaration", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1634, + "column": 1, + "source_line": "static __forceinline void prep_huffman(vorb *f)" + }, + "source_text": "static __forceinline void prep_huffman(vorb *f)" + }, + { + "name": "__forceinline", + "context": "declaration", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2034, + "column": 1, + "source_line": "static __forceinline void draw_line(float *output, int x0, int y0, int x1, int y1, int n)" + }, + "source_text": "static __forceinline void draw_line(float *output, int x0, int y0, int x1, int y1, int n)" + }, + { + "name": "__forceinline", + "context": "declaration", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2554, + "column": 1, + "source_line": "static __forceinline void iter_54(float *z)" + }, + "source_text": "static __forceinline void iter_54(float *z)" + } + ], + "diagnostics": [ + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'malloc' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 596, + "column": 4, + "source_line": " #define malloc(s) 0" + }, + "unit_kind": "macro", + "unit_name": "malloc" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'free' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 597, + "column": 4, + "source_line": " #define free(s) ((void) 0)" + }, + "unit_kind": "macro", + "unit_name": "free" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'realloc' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 598, + "column": 4, + "source_line": " #define realloc(s) 0" + }, + "unit_kind": "macro", + "unit_name": "realloc" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'CHECK' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 635, + "column": 1, + "source_line": "#define CHECK(f) _CrtIsValidHeapPointer(f->channel_buffers[1])" + }, + "unit_kind": "macro", + "unit_name": "CHECK" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'CHECK' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 637, + "column": 1, + "source_line": "#define CHECK(f) ((void) 0)" + }, + "unit_kind": "macro", + "unit_name": "CHECK" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBV_NOTUSED' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 659, + "column": 1, + "source_line": "#define STBV_NOTUSED(v) (void)(v)" + }, + "unit_kind": "macro", + "unit_name": "STBV_NOTUSED" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBV_NOTUSED' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 661, + "column": 1, + "source_line": "#define STBV_NOTUSED(v) (void)sizeof(v)" + }, + "unit_kind": "macro", + "unit_name": "STBV_NOTUSED" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'IS_PUSH_MODE' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 904, + "column": 4, + "source_line": " #define IS_PUSH_MODE(f) FALSE" + }, + "unit_kind": "macro", + "unit_name": "IS_PUSH_MODE" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'IS_PUSH_MODE' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 906, + "column": 4, + "source_line": " #define IS_PUSH_MODE(f) TRUE" + }, + "unit_kind": "macro", + "unit_name": "IS_PUSH_MODE" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'IS_PUSH_MODE' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 908, + "column": 4, + "source_line": " #define IS_PUSH_MODE(f) ((f)->push_mode)" + }, + "unit_kind": "macro", + "unit_name": "IS_PUSH_MODE" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'array_size_required' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 928, + "column": 1, + "source_line": "#define array_size_required(count,size) (count*(sizeof(void *)+(size)))" + }, + "unit_kind": "macro", + "unit_name": "array_size_required" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'temp_alloc' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 930, + "column": 1, + "source_line": "#define temp_alloc(f,size) (f->alloc.alloc_buffer ? setup_temp_malloc(f,size) : alloca(size))" + }, + "unit_kind": "macro", + "unit_name": "temp_alloc" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'temp_free' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 931, + "column": 1, + "source_line": "#define temp_free(f,p) (void)0" + }, + "unit_kind": "macro", + "unit_name": "temp_free" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'temp_alloc_save' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 932, + "column": 1, + "source_line": "#define temp_alloc_save(f) ((f)->temp_offset)" + }, + "unit_kind": "macro", + "unit_name": "temp_alloc_save" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'temp_alloc_restore' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 933, + "column": 1, + "source_line": "#define temp_alloc_restore(f,p) ((f)->temp_offset = (p))" + }, + "unit_kind": "macro", + "unit_name": "temp_alloc_restore" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'temp_block_array' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 935, + "column": 1, + "source_line": "#define temp_block_array(f,count,size) make_block_array(temp_alloc(f,array_size_required(count,size)), count, size)" + }, + "unit_kind": "macro", + "unit_name": "temp_block_array" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'USE_MEMORY' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 1332, + "column": 4, + "source_line": " #define USE_MEMORY(z) TRUE" + }, + "unit_kind": "macro", + "unit_name": "USE_MEMORY" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'USE_MEMORY' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 1334, + "column": 4, + "source_line": " #define USE_MEMORY(z) ((z)->stream)" + }, + "unit_kind": "macro", + "unit_name": "USE_MEMORY" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'DECODE_RAW' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 1717, + "column": 1, + "source_line": "#define DECODE_RAW(var, f,c) \\" + }, + "unit_kind": "macro", + "unit_name": "DECODE_RAW" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'DECODE_RAW' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 1750, + "column": 1, + "source_line": "#define DECODE_RAW(var,f,c) var = codebook_decode_scalar(f,c);" + }, + "unit_kind": "macro", + "unit_name": "DECODE_RAW" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'DECODE' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 1754, + "column": 1, + "source_line": "#define DECODE(var,f,c) \\" + }, + "unit_kind": "macro", + "unit_name": "DECODE" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'DECODE_VQ' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 1759, + "column": 3, + "source_line": " #define DECODE_VQ(var,f,c) DECODE_RAW(var,f,c)" + }, + "unit_kind": "macro", + "unit_name": "DECODE_VQ" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'DECODE_VQ' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 1761, + "column": 3, + "source_line": " #define DECODE_VQ(var,f,c) DECODE(var,f,c)" + }, + "unit_kind": "macro", + "unit_name": "DECODE_VQ" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'CODEBOOK_ELEMENT' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 1771, + "column": 1, + "source_line": "#define CODEBOOK_ELEMENT(c,off) (c->multiplicands[off])" + }, + "unit_kind": "macro", + "unit_name": "CODEBOOK_ELEMENT" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'CODEBOOK_ELEMENT_FAST' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 1772, + "column": 1, + "source_line": "#define CODEBOOK_ELEMENT_FAST(c,off) (c->multiplicands[off])" + }, + "unit_kind": "macro", + "unit_name": "CODEBOOK_ELEMENT_FAST" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'CODEBOOK_ELEMENT_BASE' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 1773, + "column": 1, + "source_line": "#define CODEBOOK_ELEMENT_BASE(c) (0)" + }, + "unit_kind": "macro", + "unit_name": "CODEBOOK_ELEMENT_BASE" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'LINE_OP' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 2023, + "column": 1, + "source_line": "#define LINE_OP(a,b) a *= b" + }, + "unit_kind": "macro", + "unit_name": "LINE_OP" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'LINE_OP' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 2025, + "column": 1, + "source_line": "#define LINE_OP(a,b) a = b" + }, + "unit_kind": "macro", + "unit_name": "LINE_OP" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'FASTDEF' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 5153, + "column": 4, + "source_line": " #define FASTDEF(x) float_conv x" + }, + "unit_kind": "macro", + "unit_name": "FASTDEF" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'MAGIC' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 5155, + "column": 4, + "source_line": " #define MAGIC(SHIFT) (1.5f * (1 << (23-SHIFT)) + 0.5f/(1 << SHIFT))" + }, + "unit_kind": "macro", + "unit_name": "MAGIC" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'ADDEND' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 5156, + "column": 4, + "source_line": " #define ADDEND(SHIFT) (((150-SHIFT) << 23) + (1 << 22))" + }, + "unit_kind": "macro", + "unit_name": "ADDEND" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'FAST_SCALED_FLOAT_TO_INT' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 5157, + "column": 4, + "source_line": " #define FAST_SCALED_FLOAT_TO_INT(temp,x,s) (temp.f = (x) + MAGIC(s), temp.i - ADDEND(s))" + }, + "unit_kind": "macro", + "unit_name": "FAST_SCALED_FLOAT_TO_INT" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'check_endianness' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 5158, + "column": 4, + "source_line": " #define check_endianness()" + }, + "unit_kind": "macro", + "unit_name": "check_endianness" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'FAST_SCALED_FLOAT_TO_INT' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 5160, + "column": 4, + "source_line": " #define FAST_SCALED_FLOAT_TO_INT(temp,x,s) ((int) ((x) * (1 << (s))))" + }, + "unit_kind": "macro", + "unit_name": "FAST_SCALED_FLOAT_TO_INT" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'check_endianness' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 5161, + "column": 4, + "source_line": " #define check_endianness()" + }, + "unit_kind": "macro", + "unit_name": "check_endianness" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'FASTDEF' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 5162, + "column": 4, + "source_line": " #define FASTDEF(x)" + }, + "unit_kind": "macro", + "unit_name": "FASTDEF" + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '\"C\"'.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 86, + "column": 1, + "source_line": "extern \"C\" {" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro '__forceinline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 1003, + "column": 1, + "source_line": "static __forceinline uint32 crc32_update(uint32 crc, uint8 byte)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "__forceinline" + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'uint32_compare(const void *p, const void *q)'.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 1162, + "column": 1, + "source_line": "static int STBV_CDECL uint32_compare(const void *p, const void *q)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'point_compare(const void *p, const void *q)'.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 1320, + "column": 1, + "source_line": "static int STBV_CDECL point_compare(const void *p, const void *q)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 1429, + "column": 1, + "source_line": "static uint8 ogg_page_header[4] = { 0x4f, 0x67, 0x67, 0x53 };" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro '__forceinline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 1634, + "column": 1, + "source_line": "static __forceinline void prep_huffman(vorb *f)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "__forceinline" + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 1946, + "column": 1, + "source_line": "static float inverse_db_table[256] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro '__forceinline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 2034, + "column": 1, + "source_line": "static __forceinline void draw_line(float *output, int x0, int y0, int x1, int y1, int n)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "__forceinline" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro '__forceinline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 2554, + "column": 1, + "source_line": "static __forceinline void iter_54(float *z)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "__forceinline" + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 5135, + "column": 1, + "source_line": "static int8 channel_position[7][6] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_CONFLICTING_TYPEDEF", + "message": "Conflicting typedef declarations for 'YTYPE'.", + "severity": "error", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 3070, + "column": 1, + "source_line": "typedef int YTYPE;" + }, + "unit_kind": "typedef", + "unit_name": "YTYPE" + }, + { + "code": "C_CONFLICTING_FUNCTION_DECLARATION", + "message": "Conflicting declarations for function 'inverse_mdct_slow'.", + "severity": "error", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 2312, + "column": 1, + "source_line": "void inverse_mdct_slow(float *buffer, int n, vorb *f, int blocktype)" + }, + "unit_kind": "function", + "unit_name": "inverse_mdct_slow" + }, + { + "code": "C_CONFLICTING_FUNCTION_DECLARATION", + "message": "Conflicting declarations for function 'inverse_mdct_slow'.", + "severity": "error", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 2350, + "column": 1, + "source_line": "void inverse_mdct_slow(float *buffer, int n, vorb *f, int blocktype)" + }, + "unit_kind": "function", + "unit_name": "inverse_mdct_slow" + }, + { + "code": "C_DUPLICATE_FUNCTION_DEFINITION", + "message": "Duplicate definition for function 'inverse_mdct'.", + "severity": "error", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 2629, + "column": 1, + "source_line": "static void inverse_mdct(float *buffer, int n, vorb *f, int blocktype)" + }, + "unit_kind": "function", + "unit_name": "inverse_mdct" + } + ] + } + }, + "functions": { + "error": { + "name": "error", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "e", + "type": { + "reference": "enum STBVorbisError" + }, + "declared_type": { + "reference": "enum STBVorbisError" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 913, + "column": 1, + "source_line": "static int error(vorb *f, enum STBVorbisError e)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 913, + "column": 1, + "source_line": "static int error(vorb *f, enum STBVorbisError e)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 920, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "make_block_array": { + "name": "make_block_array", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "parameters": [ + { + "name": "mem", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *mem", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *mem", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "count", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int count" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int count" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "size", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int size" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int size" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 938, + "column": 1, + "source_line": "static void *make_block_array(void *mem, int count, int size)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 938, + "column": 1, + "source_line": "static void *make_block_array(void *mem, int count, int size)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 948, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "setup_malloc": { + "name": "setup_malloc", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "sz", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int sz" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int sz" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 950, + "column": 1, + "source_line": "static void *setup_malloc(vorb *f, int sz)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 950, + "column": 1, + "source_line": "static void *setup_malloc(vorb *f, int sz)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 961, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "setup_free": { + "name": "setup_free", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 963, + "column": 1, + "source_line": "static void setup_free(vorb *f, void *p)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 963, + "column": 1, + "source_line": "static void setup_free(vorb *f, void *p)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 967, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "setup_temp_malloc": { + "name": "setup_temp_malloc", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "sz", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int sz" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int sz" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 969, + "column": 1, + "source_line": "static void *setup_temp_malloc(vorb *f, int sz)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 969, + "column": 1, + "source_line": "static void *setup_temp_malloc(vorb *f, int sz)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 978, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "setup_temp_free": { + "name": "setup_temp_free", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "sz", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int sz" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int sz" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 980, + "column": 1, + "source_line": "static void setup_temp_free(vorb *f, void *p, int sz)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 980, + "column": 1, + "source_line": "static void setup_temp_free(vorb *f, void *p, int sz)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 987, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "crc32_init": { + "name": "crc32_init", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 992, + "column": 1, + "source_line": "static void crc32_init(void)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 992, + "column": 1, + "source_line": "static void crc32_init(void)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1001, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "bit_reverse": { + "name": "bit_reverse", + "result_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int" + }, + "parameters": [ + { + "name": "n", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int n" + }, + "declared_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int n" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1010, + "column": 1, + "source_line": "static unsigned int bit_reverse(unsigned int n)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1010, + "column": 1, + "source_line": "static unsigned int bit_reverse(unsigned int n)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1017, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "square": { + "name": "square", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1019, + "column": 1, + "source_line": "static float square(float x)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1019, + "column": 1, + "source_line": "static float square(float x)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1022, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "ilog": { + "name": "ilog", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "n", + "type": { + "reference": "int32" + }, + "declared_type": { + "reference": "int32" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1027, + "column": 1, + "source_line": "static int ilog(int32 n)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1027, + "column": 1, + "source_line": "static int ilog(int32 n)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1043, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "float32_unpack": { + "name": "float32_unpack", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "x", + "type": { + "reference": "uint32" + }, + "declared_type": { + "reference": "uint32" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1057, + "column": 1, + "source_line": "static float float32_unpack(uint32 x)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1057, + "column": 1, + "source_line": "static float float32_unpack(uint32 x)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1065, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "add_entry": { + "name": "add_entry", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "c", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "Codebook *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "Codebook" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "Codebook *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "Codebook" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "huff_code", + "type": { + "reference": "uint32" + }, + "declared_type": { + "reference": "uint32" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "symbol", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int symbol" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int symbol" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "count", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int count" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int count" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "values", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint32 *values", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint32" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint32 *values", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint32" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1075, + "column": 1, + "source_line": "static void add_entry(Codebook *c, uint32 huff_code, int symbol, int count, int len, uint32 *values)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1075, + "column": 1, + "source_line": "static void add_entry(Codebook *c, uint32 huff_code, int symbol, int count, int len, uint32 *values)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1084, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "compute_codewords": { + "name": "compute_codewords", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "c", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "Codebook *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "Codebook" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "Codebook *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "Codebook" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint8 *len", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint8" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint8 *len", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint8" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "values", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint32 *values", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint32" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint32 *values", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint32" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1086, + "column": 1, + "source_line": "static int compute_codewords(Codebook *c, uint8 *len, int n, uint32 *values)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1086, + "column": 1, + "source_line": "static int compute_codewords(Codebook *c, uint8 *len, int n, uint32 *values)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1130, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "compute_accelerated_huffman": { + "name": "compute_accelerated_huffman", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "c", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "Codebook *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "Codebook" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "Codebook *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "Codebook" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1134, + "column": 1, + "source_line": "static void compute_accelerated_huffman(Codebook *c)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1134, + "column": 1, + "source_line": "static void compute_accelerated_huffman(Codebook *c)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1154, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "include_in_sort": { + "name": "include_in_sort", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "c", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "Codebook *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "Codebook" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "Codebook *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "Codebook" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "reference": "uint8" + }, + "declared_type": { + "reference": "uint8" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1169, + "column": 1, + "source_line": "static int include_in_sort(Codebook *c, uint8 len)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1169, + "column": 1, + "source_line": "static int include_in_sort(Codebook *c, uint8 len)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1175, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "compute_sorted_huffman": { + "name": "compute_sorted_huffman", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "c", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "Codebook *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "Codebook" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "Codebook *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "Codebook" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "lengths", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint8 *lengths", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint8" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint8 *lengths", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint8" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "values", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint32 *values", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint32" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint32 *values", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint32" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1179, + "column": 1, + "source_line": "static void compute_sorted_huffman(Codebook *c, uint8 *lengths, uint32 *values)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1179, + "column": 1, + "source_line": "static void compute_sorted_huffman(Codebook *c, uint8 *lengths, uint32 *values)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1230, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "vorbis_validate": { + "name": "vorbis_validate", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint8 *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint8" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint8 *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint8" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1233, + "column": 1, + "source_line": "static int vorbis_validate(uint8 *data)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1233, + "column": 1, + "source_line": "static int vorbis_validate(uint8 *data)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1237, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "lookup1_values": { + "name": "lookup1_values", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "entries", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int entries" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int entries" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "dim", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int dim" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int dim" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1241, + "column": 1, + "source_line": "static int lookup1_values(int entries, int dim)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1241, + "column": 1, + "source_line": "static int lookup1_values(int entries, int dim)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1251, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "compute_twiddle_factors": { + "name": "compute_twiddle_factors", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "A", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *A", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *A", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "B", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *B", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *B", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "C", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *C", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *C", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1254, + "column": 1, + "source_line": "static void compute_twiddle_factors(int n, float *A, float *B, float *C)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1254, + "column": 1, + "source_line": "static void compute_twiddle_factors(int n, float *A, float *B, float *C)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1269, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "compute_window": { + "name": "compute_window", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "window", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *window", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *window", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1271, + "column": 1, + "source_line": "static void compute_window(int n, float *window)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1271, + "column": 1, + "source_line": "static void compute_window(int n, float *window)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1276, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "compute_bitreverse": { + "name": "compute_bitreverse", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "rev", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint16 *rev", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint16" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint16 *rev", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint16" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1278, + "column": 1, + "source_line": "static void compute_bitreverse(int n, uint16 *rev)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1278, + "column": 1, + "source_line": "static void compute_bitreverse(int n, uint16 *rev)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1284, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "init_blocksize": { + "name": "init_blocksize", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1286, + "column": 1, + "source_line": "static int init_blocksize(vorb *f, int b, int n)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1286, + "column": 1, + "source_line": "static int init_blocksize(vorb *f, int b, int n)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1301, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "neighbors": { + "name": "neighbors", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint16 *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint16" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint16 *x", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint16" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "plow", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *plow", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *plow", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "phigh", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *phigh", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *phigh", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1303, + "column": 1, + "source_line": "static void neighbors(uint16 *x, int n, int *plow, int *phigh)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1303, + "column": 1, + "source_line": "static void neighbors(uint16 *x, int n, int *plow, int *phigh)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1312, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "get8": { + "name": "get8", + "result_type": { + "reference": "uint8" + }, + "parameters": [ + { + "name": "z", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1337, + "column": 1, + "source_line": "static uint8 get8(vorb *z)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1337, + "column": 1, + "source_line": "static uint8 get8(vorb *z)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1351, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "get32": { + "name": "get32", + "result_type": { + "reference": "uint32" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1353, + "column": 1, + "source_line": "static uint32 get32(vorb *f)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1353, + "column": 1, + "source_line": "static uint32 get32(vorb *f)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1361, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "getn": { + "name": "getn", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "z", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint8 *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint8" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint8 *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint8" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1363, + "column": 1, + "source_line": "static int getn(vorb *z, uint8 *data, int n)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1363, + "column": 1, + "source_line": "static int getn(vorb *z, uint8 *data, int n)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1380, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "skip": { + "name": "skip", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "z", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1382, + "column": 1, + "source_line": "static void skip(vorb *z, int n)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1382, + "column": 1, + "source_line": "static void skip(vorb *z, int n)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1395, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "set_file_offset": { + "name": "set_file_offset", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "loc", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int loc" + }, + "declared_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int loc" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1397, + "column": 1, + "source_line": "static int set_file_offset(stb_vorbis *f, unsigned int loc)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1397, + "column": 1, + "source_line": "static int set_file_offset(stb_vorbis *f, unsigned int loc)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1426, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "capture_pattern": { + "name": "capture_pattern", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1431, + "column": 1, + "source_line": "static int capture_pattern(vorb *f)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1431, + "column": 1, + "source_line": "static int capture_pattern(vorb *f)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1438, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "start_page_no_capturepattern": { + "name": "start_page_no_capturepattern", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1444, + "column": 1, + "source_line": "static int start_page_no_capturepattern(vorb *f)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1444, + "column": 1, + "source_line": "static int start_page_no_capturepattern(vorb *f)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1495, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "start_page": { + "name": "start_page", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1497, + "column": 1, + "source_line": "static int start_page(vorb *f)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1497, + "column": 1, + "source_line": "static int start_page(vorb *f)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1501, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "start_packet": { + "name": "start_packet", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1503, + "column": 1, + "source_line": "static int start_packet(vorb *f)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1503, + "column": 1, + "source_line": "static int start_packet(vorb *f)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1516, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "maybe_start_packet": { + "name": "maybe_start_packet", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1518, + "column": 1, + "source_line": "static int maybe_start_packet(vorb *f)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1518, + "column": 1, + "source_line": "static int maybe_start_packet(vorb *f)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1537, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "next_segment": { + "name": "next_segment", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1539, + "column": 1, + "source_line": "static int next_segment(vorb *f)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1539, + "column": 1, + "source_line": "static int next_segment(vorb *f)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1558, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "get8_packet_raw": { + "name": "get8_packet_raw", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1563, + "column": 1, + "source_line": "static int get8_packet_raw(vorb *f)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1563, + "column": 1, + "source_line": "static int get8_packet_raw(vorb *f)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1573, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "get8_packet": { + "name": "get8_packet", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1575, + "column": 1, + "source_line": "static int get8_packet(vorb *f)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1575, + "column": 1, + "source_line": "static int get8_packet(vorb *f)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1580, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "get32_packet": { + "name": "get32_packet", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1582, + "column": 1, + "source_line": "static int get32_packet(vorb *f)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1582, + "column": 1, + "source_line": "static int get32_packet(vorb *f)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1590, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "flush_packet": { + "name": "flush_packet", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1592, + "column": 1, + "source_line": "static void flush_packet(vorb *f)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1592, + "column": 1, + "source_line": "static void flush_packet(vorb *f)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1595, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "get_bits": { + "name": "get_bits", + "result_type": { + "reference": "uint32" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1599, + "column": 1, + "source_line": "static uint32 get_bits(vorb *f, int n)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1599, + "column": 1, + "source_line": "static uint32 get_bits(vorb *f, int n)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1628, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "codebook_decode_scalar_raw": { + "name": "codebook_decode_scalar_raw", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "Codebook *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "Codebook" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "Codebook *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "Codebook" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1656, + "column": 1, + "source_line": "static int codebook_decode_scalar_raw(vorb *f, Codebook *c)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1656, + "column": 1, + "source_line": "static int codebook_decode_scalar_raw(vorb *f, Codebook *c)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1713, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "codebook_decode_scalar": { + "name": "codebook_decode_scalar", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "Codebook *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "Codebook" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "Codebook *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "Codebook" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1733, + "column": 1, + "source_line": "static int codebook_decode_scalar(vorb *f, Codebook *c)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1733, + "column": 1, + "source_line": "static int codebook_decode_scalar(vorb *f, Codebook *c)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1748, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "codebook_decode_start": { + "name": "codebook_decode_start", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "Codebook *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "Codebook" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "Codebook *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "Codebook" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1775, + "column": 1, + "source_line": "static int codebook_decode_start(vorb *f, Codebook *c)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1775, + "column": 1, + "source_line": "static int codebook_decode_start(vorb *f, Codebook *c)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1793, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "codebook_decode": { + "name": "codebook_decode", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "Codebook *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "Codebook" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "Codebook *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "Codebook" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "output", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *output", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *output", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1795, + "column": 1, + "source_line": "static int codebook_decode(vorb *f, Codebook *c, float *output, int len)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1795, + "column": 1, + "source_line": "static int codebook_decode(vorb *f, Codebook *c, float *output, int len)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1832, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "codebook_decode_step": { + "name": "codebook_decode_step", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "Codebook *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "Codebook" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "Codebook *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "Codebook" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "output", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *output", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *output", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "step", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int step" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int step" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1834, + "column": 1, + "source_line": "static int codebook_decode_step(vorb *f, Codebook *c, float *output, int len, int step)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1834, + "column": 1, + "source_line": "static int codebook_decode_step(vorb *f, Codebook *c, float *output, int len, int step)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1863, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "codebook_decode_deinterleave_repeat": { + "name": "codebook_decode_deinterleave_repeat", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "Codebook *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "Codebook" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "Codebook *c", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "Codebook" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "outputs", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float **outputs", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float **outputs", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ch", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ch" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ch" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "c_inter_p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *c_inter_p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *c_inter_p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p_inter_p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *p_inter_p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *p_inter_p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "total_decode", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int total_decode" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int total_decode" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1865, + "column": 1, + "source_line": "static int codebook_decode_deinterleave_repeat(vorb *f, Codebook *c, float **outputs, int ch, int *c_inter_p, int *p_inter_p, int len, int total_decode)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1865, + "column": 1, + "source_line": "static int codebook_decode_deinterleave_repeat(vorb *f, Codebook *c, float **outputs, int ch, int *c_inter_p, int *p_inter_p, int len, int total_decode)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1933, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "predict_point": { + "name": "predict_point", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1935, + "column": 1, + "source_line": "static int predict_point(int x, int x0, int x1, int y0, int y1)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 1935, + "column": 1, + "source_line": "static int predict_point(int x, int x0, int x1, int y0, int y1)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 1943, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "residue_decode": { + "name": "residue_decode", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "book", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "Codebook *book", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "Codebook" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "Codebook *book", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "Codebook" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "target", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *target", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *target", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "offset", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int offset" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int offset" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "rtype", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int rtype" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int rtype" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2083, + "column": 1, + "source_line": "static int residue_decode(vorb *f, Codebook *book, float *target, int offset, int n, int rtype)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 2083, + "column": 1, + "source_line": "static int residue_decode(vorb *f, Codebook *book, float *target, int offset, int n, int rtype)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 2100, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "decode_residue": { + "name": "decode_residue", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "residue_buffers", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *residue_buffers[]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *residue_buffers[]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": null, + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ch", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ch" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int ch" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "rn", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int rn" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int rn" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "do_not_decode", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint8 *do_not_decode", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint8" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint8 *do_not_decode", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint8" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2104, + "column": 1, + "source_line": "static void decode_residue(vorb *f, float *residue_buffers[], int ch, int n, int rn, uint8 *do_not_decode)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 2104, + "column": 1, + "source_line": "static void decode_residue(vorb *f, float *residue_buffers[], int ch, int n, int rn, uint8 *do_not_decode)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 2284, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "inverse_mdct_slow": { + "name": "inverse_mdct_slow", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2289, + "column": 1, + "source_line": "void inverse_mdct_slow(float *buffer, int n)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 2289, + "column": 1, + "source_line": "void inverse_mdct_slow(float *buffer, int n)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 2309, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "dct_iv_slow": { + "name": "dct_iv_slow", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2333, + "column": 1, + "source_line": "void dct_iv_slow(float *buffer, int n)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 2333, + "column": 1, + "source_line": "void dct_iv_slow(float *buffer, int n)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 2348, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "mdct_init": { + "name": "mdct_init", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "lookup", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "mdct_lookup *lookup", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "mdct_lookup" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "mdct_lookup *lookup", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "mdct_lookup" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "extern" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": false, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2382, + "column": 1, + "source_line": "extern void mdct_init(mdct_lookup *lookup, int n);" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 2382, + "column": 1, + "source_line": "extern void mdct_init(mdct_lookup *lookup, int n);" + }, + "end": null, + "declaration_locations": [] + }, + "mdct_clear": { + "name": "mdct_clear", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "l", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "mdct_lookup *l", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "mdct_lookup" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "mdct_lookup *l", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "mdct_lookup" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "extern" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": false, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2383, + "column": 1, + "source_line": "extern void mdct_clear(mdct_lookup *l);" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 2383, + "column": 1, + "source_line": "extern void mdct_clear(mdct_lookup *l);" + }, + "end": null, + "declaration_locations": [] + }, + "mdct_backward": { + "name": "mdct_backward", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "init", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "mdct_lookup *init", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "mdct_lookup" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "mdct_lookup *init", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "mdct_lookup" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "in", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *in", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *in", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "out", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *out", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *out", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "extern" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": false, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2384, + "column": 1, + "source_line": "extern void mdct_backward(mdct_lookup *init, float *in, float *out);" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 2384, + "column": 1, + "source_line": "extern void mdct_backward(mdct_lookup *init, float *in, float *out);" + }, + "end": null, + "declaration_locations": [] + }, + "inverse_mdct": { + "name": "inverse_mdct", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "blocktype", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int blocktype" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int blocktype" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2388, + "column": 1, + "source_line": "void inverse_mdct(float *buffer, int n, vorb *f, int blocktype)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 2388, + "column": 1, + "source_line": "void inverse_mdct(float *buffer, int n, vorb *f, int blocktype)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 2401, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "imdct_step3_iter0_loop": { + "name": "imdct_step3_iter0_loop", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "e", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *e", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *e", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "i_off", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int i_off" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int i_off" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "k_off", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int k_off" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int k_off" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "A", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *A", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *A", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2408, + "column": 1, + "source_line": "static void imdct_step3_iter0_loop(int n, float *e, int i_off, int k_off, float *A)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 2408, + "column": 1, + "source_line": "static void imdct_step3_iter0_loop(int n, float *e, int i_off, int k_off, float *A)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 2451, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "imdct_step3_inner_r_loop": { + "name": "imdct_step3_inner_r_loop", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "lim", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int lim" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int lim" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "e", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *e", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *e", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "d0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int d0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int d0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "k_off", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int k_off" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int k_off" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "A", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *A", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *A", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "k1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int k1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int k1" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2453, + "column": 1, + "source_line": "static void imdct_step3_inner_r_loop(int lim, float *e, int d0, int k_off, float *A, int k1)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 2453, + "column": 1, + "source_line": "static void imdct_step3_inner_r_loop(int lim, float *e, int d0, int k_off, float *A, int k1)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 2501, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "imdct_step3_inner_s_loop": { + "name": "imdct_step3_inner_s_loop", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "e", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *e", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *e", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "i_off", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int i_off" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int i_off" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "k_off", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int k_off" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int k_off" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "A", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *A", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *A", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "a_off", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a_off" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int a_off" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "k0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int k0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int k0" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2503, + "column": 1, + "source_line": "static void imdct_step3_inner_s_loop(int n, float *e, int i_off, int k_off, float *A, int a_off, int k0)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 2503, + "column": 1, + "source_line": "static void imdct_step3_inner_s_loop(int n, float *e, int i_off, int k_off, float *A, int a_off, int k0)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 2552, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "imdct_step3_inner_s_loop_ld654": { + "name": "imdct_step3_inner_s_loop_ld654", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "e", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *e", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *e", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "i_off", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int i_off" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int i_off" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "A", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *A", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *A", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "base_n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int base_n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int base_n" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2586, + "column": 1, + "source_line": "static void imdct_step3_inner_s_loop_ld654(int n, float *e, int i_off, float *A, int base_n)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 2586, + "column": 1, + "source_line": "static void imdct_step3_inner_s_loop_ld654(int n, float *e, int i_off, float *A, int base_n)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 2627, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "inverse_mdct_naive": { + "name": "inverse_mdct_naive", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2933, + "column": 1, + "source_line": "void inverse_mdct_naive(float *buffer, int n)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 2933, + "column": 1, + "source_line": "void inverse_mdct_naive(float *buffer, int n)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 3056, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "get_window": { + "name": "get_window", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 3059, + "column": 1, + "source_line": "static float *get_window(vorb *f, int len)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 3059, + "column": 1, + "source_line": "static float *get_window(vorb *f, int len)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 3065, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "do_floor": { + "name": "do_floor", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "map", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "Mapping *map", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "Mapping" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "Mapping *map", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "Mapping" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "i", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int i" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int i" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "target", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *target", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *target", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "finalY", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "YTYPE *finalY", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "YTYPE" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "YTYPE *finalY", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "YTYPE" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "step2_flag", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint8 *step2_flag", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint8" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint8 *step2_flag", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint8" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 3072, + "column": 1, + "source_line": "static int do_floor(vorb *f, Mapping *map, int i, int n, float *target, YTYPE *finalY, uint8 *step2_flag)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 3072, + "column": 1, + "source_line": "static int do_floor(vorb *f, Mapping *map, int i, int n, float *target, YTYPE *finalY, uint8 *step2_flag)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 3108, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "vorbis_decode_initial": { + "name": "vorbis_decode_initial", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p_left_start", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *p_left_start", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *p_left_start", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p_left_end", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *p_left_end", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *p_left_end", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p_right_start", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *p_right_start", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *p_right_start", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p_right_end", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *p_right_end", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *p_right_end", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mode", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *mode", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *mode", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 3124, + "column": 1, + "source_line": "static int vorbis_decode_initial(vorb *f, int *p_left_start, int *p_left_end, int *p_right_start, int *p_right_end, int *mode)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 3124, + "column": 1, + "source_line": "static int vorbis_decode_initial(vorb *f, int *p_left_start, int *p_left_end, int *p_right_start, int *p_right_end, int *mode)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 3178, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "vorbis_decode_packet_rest": { + "name": "vorbis_decode_packet_rest", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *len", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *len", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "m", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "Mode *m", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "Mode" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "Mode *m", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "Mode" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "left_start", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int left_start" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int left_start" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "left_end", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int left_end" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int left_end" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "right_start", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int right_start" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int right_start" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "right_end", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int right_end" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int right_end" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p_left", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *p_left", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *p_left", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 3180, + "column": 1, + "source_line": "static int vorbis_decode_packet_rest(vorb *f, int *len, Mode *m, int left_start, int left_end, int right_start, int right_end, int *p_left)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 3180, + "column": 1, + "source_line": "static int vorbis_decode_packet_rest(vorb *f, int *len, Mode *m, int left_start, int left_end, int right_start, int right_end, int *p_left)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 3447, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "vorbis_decode_packet": { + "name": "vorbis_decode_packet", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *len", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *len", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p_left", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *p_left", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *p_left", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p_right", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *p_right", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *p_right", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 3449, + "column": 1, + "source_line": "static int vorbis_decode_packet(vorb *f, int *len, int *p_left, int *p_right)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 3449, + "column": 1, + "source_line": "static int vorbis_decode_packet(vorb *f, int *len, int *p_left, int *p_right)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 3454, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "vorbis_finish_frame": { + "name": "vorbis_finish_frame", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "left", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int left" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int left" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "right", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int right" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int right" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 3456, + "column": 1, + "source_line": "static int vorbis_finish_frame(stb_vorbis *f, int len, int left, int right)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 3456, + "column": 1, + "source_line": "static int vorbis_finish_frame(stb_vorbis *f, int len, int left, int right)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 3507, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "vorbis_pump_first_frame": { + "name": "vorbis_pump_first_frame", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 3509, + "column": 1, + "source_line": "static int vorbis_pump_first_frame(stb_vorbis *f)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 3509, + "column": 1, + "source_line": "static int vorbis_pump_first_frame(stb_vorbis *f)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 3516, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "is_whole_packet_present": { + "name": "is_whole_packet_present", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 3519, + "column": 1, + "source_line": "static int is_whole_packet_present(stb_vorbis *f)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 3519, + "column": 1, + "source_line": "static int is_whole_packet_present(stb_vorbis *f)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 3577, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "start_decoder": { + "name": "start_decoder", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 3580, + "column": 1, + "source_line": "static int start_decoder(vorb *f)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 3580, + "column": 1, + "source_line": "static int start_decoder(vorb *f)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 4206, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "vorbis_deinit": { + "name": "vorbis_deinit", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 4208, + "column": 1, + "source_line": "static void vorbis_deinit(stb_vorbis *p)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 4208, + "column": 1, + "source_line": "static void vorbis_deinit(stb_vorbis *p)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 4269, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_vorbis_close": { + "name": "stb_vorbis_close", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 4271, + "column": 1, + "source_line": "void stb_vorbis_close(stb_vorbis *p)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 4271, + "column": 1, + "source_line": "void stb_vorbis_close(stb_vorbis *p)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 4276, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "vorbis_init": { + "name": "vorbis_init", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "p", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *p", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "z", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stb_vorbis_alloc *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis_alloc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stb_vorbis_alloc *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis_alloc" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 4278, + "column": 1, + "source_line": "static void vorbis_init(stb_vorbis *p, const stb_vorbis_alloc *z)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 4278, + "column": 1, + "source_line": "static void vorbis_init(stb_vorbis *p, const stb_vorbis_alloc *z)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 4295, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_vorbis_get_sample_offset": { + "name": "stb_vorbis_get_sample_offset", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 4297, + "column": 1, + "source_line": "int stb_vorbis_get_sample_offset(stb_vorbis *f)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 4297, + "column": 1, + "source_line": "int stb_vorbis_get_sample_offset(stb_vorbis *f)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 4303, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_vorbis_get_info": { + "name": "stb_vorbis_get_info", + "result_type": { + "reference": "stb_vorbis_info" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 4305, + "column": 1, + "source_line": "stb_vorbis_info stb_vorbis_get_info(stb_vorbis *f)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 4305, + "column": 1, + "source_line": "stb_vorbis_info stb_vorbis_get_info(stb_vorbis *f)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 4315, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_vorbis_get_comment": { + "name": "stb_vorbis_get_comment", + "result_type": { + "reference": "stb_vorbis_comment" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 4317, + "column": 1, + "source_line": "stb_vorbis_comment stb_vorbis_get_comment(stb_vorbis *f)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 4317, + "column": 1, + "source_line": "stb_vorbis_comment stb_vorbis_get_comment(stb_vorbis *f)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 4324, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_vorbis_get_error": { + "name": "stb_vorbis_get_error", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 4326, + "column": 1, + "source_line": "int stb_vorbis_get_error(stb_vorbis *f)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 4326, + "column": 1, + "source_line": "int stb_vorbis_get_error(stb_vorbis *f)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 4331, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "vorbis_alloc": { + "name": "vorbis_alloc", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 4333, + "column": 1, + "source_line": "static stb_vorbis * vorbis_alloc(stb_vorbis *f)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 4333, + "column": 1, + "source_line": "static stb_vorbis * vorbis_alloc(stb_vorbis *f)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 4337, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_vorbis_flush_pushdata": { + "name": "stb_vorbis_flush_pushdata", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 4341, + "column": 1, + "source_line": "void stb_vorbis_flush_pushdata(stb_vorbis *f)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 4341, + "column": 1, + "source_line": "void stb_vorbis_flush_pushdata(stb_vorbis *f)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 4351, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "vorbis_search_for_page_pushdata": { + "name": "vorbis_search_for_page_pushdata", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint8 *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint8" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint8 *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint8" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "data_len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int data_len" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int data_len" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 4353, + "column": 1, + "source_line": "static int vorbis_search_for_page_pushdata(vorb *f, uint8 *data, int data_len)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 4353, + "column": 1, + "source_line": "static int vorbis_search_for_page_pushdata(vorb *f, uint8 *data, int data_len)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 4441, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_vorbis_decode_frame_pushdata": { + "name": "stb_vorbis_decode_frame_pushdata", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const uint8 *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint8" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const uint8 *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint8" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "data_len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int data_len" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int data_len" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "channels", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *channels", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *channels", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "output", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float ***output", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float ***output", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "samples", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *samples", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *samples", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 4444, + "column": 1, + "source_line": "int stb_vorbis_decode_frame_pushdata(" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 4444, + "column": 1, + "source_line": "int stb_vorbis_decode_frame_pushdata(" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 4512, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_vorbis_open_pushdata": { + "name": "stb_vorbis_open_pushdata", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "parameters": [ + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const unsigned char *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [ + "const" + ], + "source_text": "const unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const unsigned char *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [ + "const" + ], + "source_text": "const unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "data_len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int data_len" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int data_len" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "data_used", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *data_used", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *data_used", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "error", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *error", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *error", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "alloc", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stb_vorbis_alloc *alloc", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis_alloc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stb_vorbis_alloc *alloc", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis_alloc" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 4514, + "column": 1, + "source_line": "stb_vorbis *stb_vorbis_open_pushdata(" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 4514, + "column": 1, + "source_line": "stb_vorbis *stb_vorbis_open_pushdata(" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 4542, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_vorbis_get_file_offset": { + "name": "stb_vorbis_get_file_offset", + "result_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 4545, + "column": 1, + "source_line": "unsigned int stb_vorbis_get_file_offset(stb_vorbis *f)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 4545, + "column": 1, + "source_line": "unsigned int stb_vorbis_get_file_offset(stb_vorbis *f)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 4554, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "vorbis_find_page": { + "name": "vorbis_find_page", + "result_type": { + "reference": "uint32" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "end", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint32 *end", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint32" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint32 *end", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint32" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "last", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint32 *last", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint32" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "uint32 *last", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint32" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 4561, + "column": 1, + "source_line": "static uint32 vorbis_find_page(stb_vorbis *f, uint32 *end, uint32 *last)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 4561, + "column": 1, + "source_line": "static uint32 vorbis_find_page(stb_vorbis *f, uint32 *end, uint32 *last)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 4629, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "get_seek_page_info": { + "name": "get_seek_page_info", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "z", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "ProbedPage *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "ProbedPage" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "ProbedPage *z", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "ProbedPage" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 4643, + "column": 1, + "source_line": "static int get_seek_page_info(stb_vorbis *f, ProbedPage *z)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 4643, + "column": 1, + "source_line": "static int get_seek_page_info(stb_vorbis *f, ProbedPage *z)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 4671, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "go_to_page_before": { + "name": "go_to_page_before", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "limit_offset", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int limit_offset" + }, + "declared_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int limit_offset" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 4675, + "column": 1, + "source_line": "static int go_to_page_before(stb_vorbis *f, unsigned int limit_offset)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 4675, + "column": 1, + "source_line": "static int go_to_page_before(stb_vorbis *f, unsigned int limit_offset)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 4694, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "seek_to_sample_coarse": { + "name": "seek_to_sample_coarse", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "sample_number", + "type": { + "reference": "uint32" + }, + "declared_type": { + "reference": "uint32" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 4700, + "column": 1, + "source_line": "static int seek_to_sample_coarse(stb_vorbis *f, uint32 sample_number)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 4700, + "column": 1, + "source_line": "static int seek_to_sample_coarse(stb_vorbis *f, uint32 sample_number)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 4852, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "peek_decode_initial": { + "name": "peek_decode_initial", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "vorb *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "vorb" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p_left_start", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *p_left_start", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *p_left_start", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p_left_end", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *p_left_end", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *p_left_end", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p_right_start", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *p_right_start", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *p_right_start", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "p_right_end", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *p_right_end", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *p_right_end", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mode", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *mode", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *mode", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 4855, + "column": 1, + "source_line": "static int peek_decode_initial(vorb *f, int *p_left_start, int *p_left_end, int *p_right_start, int *p_right_end, int *mode)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 4855, + "column": 1, + "source_line": "static int peek_decode_initial(vorb *f, int *p_left_start, int *p_left_end, int *p_right_start, int *p_right_end, int *mode)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 4878, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_vorbis_seek_frame": { + "name": "stb_vorbis_seek_frame", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "sample_number", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int sample_number" + }, + "declared_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int sample_number" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 4880, + "column": 1, + "source_line": "int stb_vorbis_seek_frame(stb_vorbis *f, unsigned int sample_number)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 4880, + "column": 1, + "source_line": "int stb_vorbis_seek_frame(stb_vorbis *f, unsigned int sample_number)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 4917, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_vorbis_seek": { + "name": "stb_vorbis_seek", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "sample_number", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int sample_number" + }, + "declared_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int sample_number" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 4919, + "column": 1, + "source_line": "int stb_vorbis_seek(stb_vorbis *f, unsigned int sample_number)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 4919, + "column": 1, + "source_line": "int stb_vorbis_seek(stb_vorbis *f, unsigned int sample_number)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 4934, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_vorbis_seek_start": { + "name": "stb_vorbis_seek_start", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 4936, + "column": 1, + "source_line": "int stb_vorbis_seek_start(stb_vorbis *f)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 4936, + "column": 1, + "source_line": "int stb_vorbis_seek_start(stb_vorbis *f)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 4944, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_vorbis_stream_length_in_samples": { + "name": "stb_vorbis_stream_length_in_samples", + "result_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 4946, + "column": 1, + "source_line": "unsigned int stb_vorbis_stream_length_in_samples(stb_vorbis *f)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 4946, + "column": 1, + "source_line": "unsigned int stb_vorbis_stream_length_in_samples(stb_vorbis *f)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 5019, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_vorbis_stream_length_in_seconds": { + "name": "stb_vorbis_stream_length_in_seconds", + "result_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5021, + "column": 1, + "source_line": "float stb_vorbis_stream_length_in_seconds(stb_vorbis *f)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 5021, + "column": 1, + "source_line": "float stb_vorbis_stream_length_in_seconds(stb_vorbis *f)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 5024, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_vorbis_get_frame_float": { + "name": "stb_vorbis_get_frame_float", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "channels", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *channels", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *channels", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "output", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float ***output", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float ***output", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5028, + "column": 1, + "source_line": "int stb_vorbis_get_frame_float(stb_vorbis *f, int *channels, float ***output)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 5028, + "column": 1, + "source_line": "int stb_vorbis_get_frame_float(stb_vorbis *f, int *channels, float ***output)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 5048, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_vorbis_open_file_section": { + "name": "stb_vorbis_open_file_section", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "parameters": [ + { + "name": "file", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "FILE *file", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "FILE" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "FILE *file", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "FILE" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "close_on_free", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int close_on_free" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int close_on_free" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "error", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *error", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *error", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "alloc", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stb_vorbis_alloc *alloc", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis_alloc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stb_vorbis_alloc *alloc", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis_alloc" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "length", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int length" + }, + "declared_type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int length" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5052, + "column": 1, + "source_line": "stb_vorbis * stb_vorbis_open_file_section(FILE *file, int close_on_free, int *error, const stb_vorbis_alloc *alloc, unsigned int length)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 5052, + "column": 1, + "source_line": "stb_vorbis * stb_vorbis_open_file_section(FILE *file, int close_on_free, int *error, const stb_vorbis_alloc *alloc, unsigned int length)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 5071, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_vorbis_open_file": { + "name": "stb_vorbis_open_file", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "parameters": [ + { + "name": "file", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "FILE *file", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "FILE" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "FILE *file", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "FILE" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "close_on_free", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int close_on_free" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int close_on_free" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "error", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *error", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *error", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "alloc", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stb_vorbis_alloc *alloc", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis_alloc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stb_vorbis_alloc *alloc", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis_alloc" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5073, + "column": 1, + "source_line": "stb_vorbis * stb_vorbis_open_file(FILE *file, int close_on_free, int *error, const stb_vorbis_alloc *alloc)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 5073, + "column": 1, + "source_line": "stb_vorbis * stb_vorbis_open_file(FILE *file, int close_on_free, int *error, const stb_vorbis_alloc *alloc)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 5081, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_vorbis_open_filename": { + "name": "stb_vorbis_open_filename", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "parameters": [ + { + "name": "filename", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *filename", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *filename", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "error", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *error", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *error", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "alloc", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stb_vorbis_alloc *alloc", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis_alloc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stb_vorbis_alloc *alloc", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis_alloc" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5083, + "column": 1, + "source_line": "stb_vorbis * stb_vorbis_open_filename(const char *filename, int *error, const stb_vorbis_alloc *alloc)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 5083, + "column": 1, + "source_line": "stb_vorbis * stb_vorbis_open_filename(const char *filename, int *error, const stb_vorbis_alloc *alloc)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 5096, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_vorbis_open_memory": { + "name": "stb_vorbis_open_memory", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "parameters": [ + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const unsigned char *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [ + "const" + ], + "source_text": "const unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const unsigned char *data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [ + "const" + ], + "source_text": "const unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "error", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *error", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *error", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "alloc", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stb_vorbis_alloc *alloc", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis_alloc" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const stb_vorbis_alloc *alloc", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis_alloc" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5099, + "column": 1, + "source_line": "stb_vorbis * stb_vorbis_open_memory(const unsigned char *data, int len, int *error, const stb_vorbis_alloc *alloc)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 5099, + "column": 1, + "source_line": "stb_vorbis * stb_vorbis_open_memory(const unsigned char *data, int len, int *error, const stb_vorbis_alloc *alloc)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 5124, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "copy_samples": { + "name": "copy_samples", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "dest", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short *dest", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short *dest", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "src", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *src", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *src", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5165, + "column": 1, + "source_line": "static void copy_samples(short *dest, float *src, int len)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 5165, + "column": 1, + "source_line": "static void copy_samples(short *dest, float *src, int len)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 5176, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "compute_samples": { + "name": "compute_samples", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "mask", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mask" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mask" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "output", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short *output", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short *output", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "num_c", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_c" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_c" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float **data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float **data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "d_offset", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int d_offset" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int d_offset" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5178, + "column": 1, + "source_line": "static void compute_samples(int mask, short *output, int num_c, float **data, int d_offset, int len)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 5178, + "column": 1, + "source_line": "static void compute_samples(int mask, short *output, int num_c, float **data, int d_offset, int len)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 5202, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "compute_stereo_samples": { + "name": "compute_stereo_samples", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "output", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short *output", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short *output", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "num_c", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_c" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_c" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float **data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float **data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "d_offset", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int d_offset" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int d_offset" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5204, + "column": 1, + "source_line": "static void compute_stereo_samples(short *output, int num_c, float **data, int d_offset, int len)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 5204, + "column": 1, + "source_line": "static void compute_stereo_samples(short *output, int num_c, float **data, int d_offset, int len)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 5242, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "convert_samples_short": { + "name": "convert_samples_short", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "buf_c", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int buf_c" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int buf_c" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short **buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short **buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b_offset", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b_offset" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int b_offset" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "data_c", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int data_c" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int data_c" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float **data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float **data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "d_offset", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int d_offset" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int d_offset" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "samples", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int samples" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int samples" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5244, + "column": 1, + "source_line": "static void convert_samples_short(int buf_c, short **buffer, int b_offset, int data_c, float **data, int d_offset, int samples)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 5244, + "column": 1, + "source_line": "static void convert_samples_short(int buf_c, short **buffer, int b_offset, int data_c, float **data, int d_offset, int samples)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 5258, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_vorbis_get_frame_short": { + "name": "stb_vorbis_get_frame_short", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "num_c", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_c" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_c" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short **buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short **buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "num_samples", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_samples" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_samples" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5260, + "column": 1, + "source_line": "int stb_vorbis_get_frame_short(stb_vorbis *f, int num_c, short **buffer, int num_samples)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 5260, + "column": 1, + "source_line": "int stb_vorbis_get_frame_short(stb_vorbis *f, int num_c, short **buffer, int num_samples)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 5268, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "convert_channels_short_interleaved": { + "name": "convert_channels_short_interleaved", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "buf_c", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int buf_c" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int buf_c" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short *buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short *buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "data_c", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int data_c" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int data_c" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "data", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float **data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float **data", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "d_offset", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int d_offset" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int d_offset" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5270, + "column": 1, + "source_line": "static void convert_channels_short_interleaved(int buf_c, short *buffer, int data_c, float **data, int d_offset, int len)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 5270, + "column": 1, + "source_line": "static void convert_channels_short_interleaved(int buf_c, short *buffer, int data_c, float **data, int d_offset, int len)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 5294, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_vorbis_get_frame_short_interleaved": { + "name": "stb_vorbis_get_frame_short_interleaved", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "num_c", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_c" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_c" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short *buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short *buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "num_shorts", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_shorts" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_shorts" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5296, + "column": 1, + "source_line": "int stb_vorbis_get_frame_short_interleaved(stb_vorbis *f, int num_c, short *buffer, int num_shorts)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 5296, + "column": 1, + "source_line": "int stb_vorbis_get_frame_short_interleaved(stb_vorbis *f, int num_c, short *buffer, int num_shorts)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 5307, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_vorbis_get_samples_short_interleaved": { + "name": "stb_vorbis_get_samples_short_interleaved", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "channels", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int channels" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int channels" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short *buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short *buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "num_shorts", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_shorts" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_shorts" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5309, + "column": 1, + "source_line": "int stb_vorbis_get_samples_short_interleaved(stb_vorbis *f, int channels, short *buffer, int num_shorts)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 5309, + "column": 1, + "source_line": "int stb_vorbis_get_samples_short_interleaved(stb_vorbis *f, int channels, short *buffer, int num_shorts)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 5326, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_vorbis_get_samples_short": { + "name": "stb_vorbis_get_samples_short", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "channels", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int channels" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int channels" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short **buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short **buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5328, + "column": 1, + "source_line": "int stb_vorbis_get_samples_short(stb_vorbis *f, int channels, short **buffer, int len)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 5328, + "column": 1, + "source_line": "int stb_vorbis_get_samples_short(stb_vorbis *f, int channels, short **buffer, int len)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 5343, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_vorbis_decode_filename": { + "name": "stb_vorbis_decode_filename", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "filename", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *filename", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *filename", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "channels", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *channels", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *channels", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "sample_rate", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *sample_rate", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *sample_rate", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "output", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short **output", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short **output", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5346, + "column": 1, + "source_line": "int stb_vorbis_decode_filename(const char *filename, int *channels, int *sample_rate, short **output)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 5346, + "column": 1, + "source_line": "int stb_vorbis_decode_filename(const char *filename, int *channels, int *sample_rate, short **output)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 5383, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_vorbis_decode_memory": { + "name": "stb_vorbis_decode_memory", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "mem", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const uint8 *mem", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint8" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const uint8 *mem", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "uint8" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "channels", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *channels", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *channels", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "sample_rate", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *sample_rate", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *sample_rate", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "output", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short **output", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "short **output", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CShort", + "qualifiers": [], + "source_text": "short" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5386, + "column": 1, + "source_line": "int stb_vorbis_decode_memory(const uint8 *mem, int len, int *channels, int *sample_rate, short **output)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 5386, + "column": 1, + "source_line": "int stb_vorbis_decode_memory(const uint8 *mem, int len, int *channels, int *sample_rate, short **output)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 5423, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_vorbis_get_samples_float_interleaved": { + "name": "stb_vorbis_get_samples_float_interleaved", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "channels", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int channels" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int channels" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float *buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "num_floats", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_floats" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_floats" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5426, + "column": 1, + "source_line": "int stb_vorbis_get_samples_float_interleaved(stb_vorbis *f, int channels, float *buffer, int num_floats)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 5426, + "column": 1, + "source_line": "int stb_vorbis_get_samples_float_interleaved(stb_vorbis *f, int channels, float *buffer, int num_floats)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 5451, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stb_vorbis_get_samples_float": { + "name": "stb_vorbis_get_samples_float", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "f", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stb_vorbis *f", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stb_vorbis" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "channels", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int channels" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int channels" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float **buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float **buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "num_samples", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_samples" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_samples" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5453, + "column": 1, + "source_line": "int stb_vorbis_get_samples_float(stb_vorbis *f, int channels, float **buffer, int num_samples)" + }, + "start": { + "filename": "stb/stb_vorbis.c", + "line": 5453, + "column": 1, + "source_line": "int stb_vorbis_get_samples_float(stb_vorbis *f, int channels, float **buffer, int num_samples)" + }, + "end": { + "filename": "stb/stb_vorbis.c", + "line": 5477, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + } + }, + "structs": { + "stb_vorbis": { + "reference": "struct stb_vorbis" + } + }, + "unions": {}, + "enums": {}, + "typedefs": { + "uint8": { + "reference": "uint8" + }, + "int8": { + "reference": "int8" + }, + "uint16": { + "reference": "uint16" + }, + "int16": { + "reference": "int16" + }, + "uint32": { + "reference": "uint32" + }, + "int32": { + "reference": "int32" + }, + "codetype": { + "reference": "codetype" + }, + "Codebook": { + "reference": "Codebook" + }, + "Floor0": { + "reference": "Floor0" + }, + "Floor1": { + "reference": "Floor1" + }, + "Floor": { + "reference": "Floor" + }, + "Residue": { + "reference": "Residue" + }, + "MappingChannel": { + "reference": "MappingChannel" + }, + "Mapping": { + "reference": "Mapping" + }, + "Mode": { + "reference": "Mode" + }, + "CRCscan": { + "reference": "CRCscan" + }, + "ProbedPage": { + "reference": "ProbedPage" + }, + "vorb": { + "reference": "vorb" + }, + "stbv__floor_ordering": { + "reference": "stbv__floor_ordering" + }, + "mdct_lookup": { + "reference": "mdct_lookup" + }, + "YTYPE": { + "reference": "YTYPE" + }, + "float_conv": { + "reference": "float_conv" + }, + "stb_vorbis_float_size_test": { + "reference": "stb_vorbis_float_size_test" + } + }, + "variables": { + "crc_table": { + "name": "crc_table", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "static uint32 crc_table[256]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "256", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "reference": "uint32" + } + ] + }, + "storage": [ + "static" + ], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 991, + "column": 1, + "source_line": "static uint32 crc_table[256];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + "integer_divide_table": { + "name": "integer_divide_table", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int8 integer_divide_table[DIVTAB_NUMER][DIVTAB_DENOM]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "DIVTAB_NUMER", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "DIVTAB_DENOM", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "reference": "int8" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2031, + "column": 1, + "source_line": "int8 integer_divide_table[DIVTAB_NUMER][DIVTAB_DENOM]; // 2KB" + }, + "callback_policy": null, + "declaration_locations": [] + }, + "M1": { + "name": "M1", + "type": { + "reference": "mdct_lookup" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2386, + "column": 1, + "source_line": "mdct_lookup M1,M2;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + "M2": { + "name": "M2", + "type": { + "reference": "mdct_lookup" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2386, + "column": 1, + "source_line": "mdct_lookup M1,M2;" + }, + "callback_policy": null, + "declaration_locations": [] + } + }, + "macros": { + "STB_VORBIS_INCLUDE_STB_VORBIS_H": { + "name": "STB_VORBIS_INCLUDE_STB_VORBIS_H", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 75, + "column": 1, + "source_line": "#define STB_VORBIS_INCLUDE_STB_VORBIS_H" + } + }, + "STB_VORBIS_NO_STDIO": { + "name": "STB_VORBIS_NO_STDIO", + "value": "1", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 558, + "column": 4, + "source_line": " #define STB_VORBIS_NO_STDIO 1" + } + }, + "STB_VORBIS_MAX_CHANNELS": { + "name": "STB_VORBIS_MAX_CHANNELS", + "value": "16", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 461, + "column": 1, + "source_line": "#define STB_VORBIS_MAX_CHANNELS 16 // enough for anyone?" + } + }, + "STB_VORBIS_PUSHDATA_CRC_COUNT": { + "name": "STB_VORBIS_PUSHDATA_CRC_COUNT", + "value": "4", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 477, + "column": 1, + "source_line": "#define STB_VORBIS_PUSHDATA_CRC_COUNT 4" + } + }, + "STB_VORBIS_FAST_HUFFMAN_LENGTH": { + "name": "STB_VORBIS_FAST_HUFFMAN_LENGTH", + "value": "10", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 486, + "column": 1, + "source_line": "#define STB_VORBIS_FAST_HUFFMAN_LENGTH 10" + } + }, + "STB_VORBIS_FAST_HUFFMAN_SHORT": { + "name": "STB_VORBIS_FAST_HUFFMAN_SHORT", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 500, + "column": 1, + "source_line": "#define STB_VORBIS_FAST_HUFFMAN_SHORT" + } + }, + "STB_VORBIS_NO_INTEGER_CONVERSION": { + "name": "STB_VORBIS_NO_INTEGER_CONVERSION", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 553, + "column": 4, + "source_line": " #define STB_VORBIS_NO_INTEGER_CONVERSION" + } + }, + "STB_VORBIS_ENDIAN": { + "name": "STB_VORBIS_ENDIAN", + "value": "1", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 570, + "column": 6, + "source_line": " #define STB_VORBIS_ENDIAN 1" + } + }, + "NULL": { + "name": "NULL", + "value": "0", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 595, + "column": 4, + "source_line": " #define NULL 0" + } + }, + "malloc": { + "name": "malloc", + "value": "0", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 596, + "column": 4, + "source_line": " #define malloc(s) 0" + } + }, + "free": { + "name": "free", + "value": "((void) 0)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 597, + "column": 4, + "source_line": " #define free(s) ((void) 0)" + } + }, + "realloc": { + "name": "realloc", + "value": "0", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 598, + "column": 4, + "source_line": " #define realloc(s) 0" + } + }, + "__forceinline": { + "name": "__forceinline", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 620, + "column": 7, + "source_line": " #define __forceinline" + } + }, + "alloca": { + "name": "alloca", + "value": "__builtin_alloca", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 614, + "column": 4, + "source_line": " #define alloca __builtin_alloca" + } + }, + "CHECK": { + "name": "CHECK", + "value": "((void) 0)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 637, + "column": 1, + "source_line": "#define CHECK(f) ((void) 0)" + } + }, + "MAX_BLOCKSIZE_LOG": { + "name": "MAX_BLOCKSIZE_LOG", + "value": "13", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 640, + "column": 1, + "source_line": "#define MAX_BLOCKSIZE_LOG 13 // from specification" + } + }, + "MAX_BLOCKSIZE": { + "name": "MAX_BLOCKSIZE", + "value": "(1 << MAX_BLOCKSIZE_LOG)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 641, + "column": 1, + "source_line": "#define MAX_BLOCKSIZE (1 << MAX_BLOCKSIZE_LOG)" + } + }, + "TRUE": { + "name": "TRUE", + "value": "1", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 652, + "column": 1, + "source_line": "#define TRUE 1" + } + }, + "FALSE": { + "name": "FALSE", + "value": "0", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 653, + "column": 1, + "source_line": "#define FALSE 0" + } + }, + "STBV_NOTUSED": { + "name": "STBV_NOTUSED", + "value": "(void)sizeof(v)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 661, + "column": 1, + "source_line": "#define STBV_NOTUSED(v) (void)sizeof(v)" + } + }, + "FAST_HUFFMAN_TABLE_SIZE": { + "name": "FAST_HUFFMAN_TABLE_SIZE", + "value": "(1 << STB_VORBIS_FAST_HUFFMAN_LENGTH)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 677, + "column": 1, + "source_line": "#define FAST_HUFFMAN_TABLE_SIZE (1 << STB_VORBIS_FAST_HUFFMAN_LENGTH)" + } + }, + "FAST_HUFFMAN_TABLE_MASK": { + "name": "FAST_HUFFMAN_TABLE_MASK", + "value": "(FAST_HUFFMAN_TABLE_SIZE - 1)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 678, + "column": 1, + "source_line": "#define FAST_HUFFMAN_TABLE_MASK (FAST_HUFFMAN_TABLE_SIZE - 1)" + } + }, + "IS_PUSH_MODE": { + "name": "IS_PUSH_MODE", + "value": "((f)->push_mode)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 908, + "column": 4, + "source_line": " #define IS_PUSH_MODE(f) ((f)->push_mode)" + } + }, + "array_size_required": { + "name": "array_size_required", + "value": "(count*(sizeof(void *)+(size)))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 928, + "column": 1, + "source_line": "#define array_size_required(count,size) (count*(sizeof(void *)+(size)))" + } + }, + "temp_alloc": { + "name": "temp_alloc", + "value": "(f->alloc.alloc_buffer ? setup_temp_malloc(f,size) : alloca(size))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 930, + "column": 1, + "source_line": "#define temp_alloc(f,size) (f->alloc.alloc_buffer ? setup_temp_malloc(f,size) : alloca(size))" + } + }, + "temp_free": { + "name": "temp_free", + "value": "(void)0", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 931, + "column": 1, + "source_line": "#define temp_free(f,p) (void)0" + } + }, + "temp_alloc_save": { + "name": "temp_alloc_save", + "value": "((f)->temp_offset)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 932, + "column": 1, + "source_line": "#define temp_alloc_save(f) ((f)->temp_offset)" + } + }, + "temp_alloc_restore": { + "name": "temp_alloc_restore", + "value": "((f)->temp_offset = (p))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 933, + "column": 1, + "source_line": "#define temp_alloc_restore(f,p) ((f)->temp_offset = (p))" + } + }, + "temp_block_array": { + "name": "temp_block_array", + "value": "make_block_array(temp_alloc(f,array_size_required(count,size)), count, size)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 935, + "column": 1, + "source_line": "#define temp_block_array(f,count,size) make_block_array(temp_alloc(f,array_size_required(count,size)), count, size)" + } + }, + "CRC32_POLY": { + "name": "CRC32_POLY", + "value": "0x04c11db7", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 989, + "column": 1, + "source_line": "#define CRC32_POLY 0x04c11db7 // from spec" + } + }, + "M_PI": { + "name": "M_PI", + "value": "3.14159265358979323846264f", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1046, + "column": 3, + "source_line": " #define M_PI 3.14159265358979323846264f // from CRC" + } + }, + "NO_CODE": { + "name": "NO_CODE", + "value": "255", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1050, + "column": 1, + "source_line": "#define NO_CODE 255" + } + }, + "STBV_CDECL": { + "name": "STBV_CDECL", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1159, + "column": 1, + "source_line": "#define STBV_CDECL" + } + }, + "USE_MEMORY": { + "name": "USE_MEMORY", + "value": "((z)->stream)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1334, + "column": 4, + "source_line": " #define USE_MEMORY(z) ((z)->stream)" + } + }, + "PAGEFLAG_continued_packet": { + "name": "PAGEFLAG_continued_packet", + "value": "1", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1440, + "column": 1, + "source_line": "#define PAGEFLAG_continued_packet 1" + } + }, + "PAGEFLAG_first_page": { + "name": "PAGEFLAG_first_page", + "value": "2", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1441, + "column": 1, + "source_line": "#define PAGEFLAG_first_page 2" + } + }, + "PAGEFLAG_last_page": { + "name": "PAGEFLAG_last_page", + "value": "4", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1442, + "column": 1, + "source_line": "#define PAGEFLAG_last_page 4" + } + }, + "EOP": { + "name": "EOP", + "value": "(-1)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1560, + "column": 1, + "source_line": "#define EOP (-1)" + } + }, + "INVALID_BITS": { + "name": "INVALID_BITS", + "value": "(-1)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1561, + "column": 1, + "source_line": "#define INVALID_BITS (-1)" + } + }, + "DECODE_RAW": { + "name": "DECODE_RAW", + "value": "var = codebook_decode_scalar(f,c);", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1750, + "column": 1, + "source_line": "#define DECODE_RAW(var,f,c) var = codebook_decode_scalar(f,c);" + } + }, + "DECODE": { + "name": "DECODE", + "value": "DECODE_RAW(var,f,c) if (c->sparse) var = c->sorted_values[var];", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1754, + "column": 1, + "source_line": "#define DECODE(var,f,c) \\" + } + }, + "DECODE_VQ": { + "name": "DECODE_VQ", + "value": "DECODE(var,f,c)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1761, + "column": 3, + "source_line": " #define DECODE_VQ(var,f,c) DECODE(var,f,c)" + } + }, + "CODEBOOK_ELEMENT": { + "name": "CODEBOOK_ELEMENT", + "value": "(c->multiplicands[off])", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1771, + "column": 1, + "source_line": "#define CODEBOOK_ELEMENT(c,off) (c->multiplicands[off])" + } + }, + "CODEBOOK_ELEMENT_FAST": { + "name": "CODEBOOK_ELEMENT_FAST", + "value": "(c->multiplicands[off])", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1772, + "column": 1, + "source_line": "#define CODEBOOK_ELEMENT_FAST(c,off) (c->multiplicands[off])" + } + }, + "CODEBOOK_ELEMENT_BASE": { + "name": "CODEBOOK_ELEMENT_BASE", + "value": "(0)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1773, + "column": 1, + "source_line": "#define CODEBOOK_ELEMENT_BASE(c) (0)" + } + }, + "LINE_OP": { + "name": "LINE_OP", + "value": "a = b", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2025, + "column": 1, + "source_line": "#define LINE_OP(a,b) a = b" + } + }, + "DIVTAB_NUMER": { + "name": "DIVTAB_NUMER", + "value": "32", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2029, + "column": 1, + "source_line": "#define DIVTAB_NUMER 32" + } + }, + "DIVTAB_DENOM": { + "name": "DIVTAB_DENOM", + "value": "64", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2030, + "column": 1, + "source_line": "#define DIVTAB_DENOM 64" + } + }, + "LIBVORBIS_MDCT": { + "name": "LIBVORBIS_MDCT", + "value": "0", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 2365, + "column": 1, + "source_line": "#define LIBVORBIS_MDCT 0" + } + }, + "SAMPLE_unknown": { + "name": "SAMPLE_unknown", + "value": "0xffffffff", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 4632, + "column": 1, + "source_line": "#define SAMPLE_unknown 0xffffffff" + } + }, + "PLAYBACK_MONO": { + "name": "PLAYBACK_MONO", + "value": "1", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5127, + "column": 1, + "source_line": "#define PLAYBACK_MONO 1" + } + }, + "PLAYBACK_LEFT": { + "name": "PLAYBACK_LEFT", + "value": "2", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5128, + "column": 1, + "source_line": "#define PLAYBACK_LEFT 2" + } + }, + "PLAYBACK_RIGHT": { + "name": "PLAYBACK_RIGHT", + "value": "4", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5129, + "column": 1, + "source_line": "#define PLAYBACK_RIGHT 4" + } + }, + "L": { + "name": "L", + "value": "(PLAYBACK_LEFT | PLAYBACK_MONO)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5131, + "column": 1, + "source_line": "#define L (PLAYBACK_LEFT | PLAYBACK_MONO)" + } + }, + "C": { + "name": "C", + "value": "(PLAYBACK_LEFT | PLAYBACK_RIGHT | PLAYBACK_MONO)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5132, + "column": 1, + "source_line": "#define C (PLAYBACK_LEFT | PLAYBACK_RIGHT | PLAYBACK_MONO)" + } + }, + "R": { + "name": "R", + "value": "(PLAYBACK_RIGHT | PLAYBACK_MONO)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5133, + "column": 1, + "source_line": "#define R (PLAYBACK_RIGHT | PLAYBACK_MONO)" + } + }, + "FASTDEF": { + "name": "FASTDEF", + "value": null, + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5162, + "column": 4, + "source_line": " #define FASTDEF(x)" + } + }, + "MAGIC": { + "name": "MAGIC", + "value": "(1.5f * (1 << (23-SHIFT)) + 0.5f/(1 << SHIFT))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5155, + "column": 4, + "source_line": " #define MAGIC(SHIFT) (1.5f * (1 << (23-SHIFT)) + 0.5f/(1 << SHIFT))" + } + }, + "ADDEND": { + "name": "ADDEND", + "value": "(((150-SHIFT) << 23) + (1 << 22))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5156, + "column": 4, + "source_line": " #define ADDEND(SHIFT) (((150-SHIFT) << 23) + (1 << 22))" + } + }, + "FAST_SCALED_FLOAT_TO_INT": { + "name": "FAST_SCALED_FLOAT_TO_INT", + "value": "((int) ((x) * (1 << (s))))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5160, + "column": 4, + "source_line": " #define FAST_SCALED_FLOAT_TO_INT(temp,x,s) ((int) ((x) * (1 << (s))))" + } + }, + "check_endianness": { + "name": "check_endianness", + "value": null, + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5161, + "column": 4, + "source_line": " #define check_endianness()" + } + }, + "STB_BUFFER_SIZE": { + "name": "STB_BUFFER_SIZE", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 5241, + "column": 4, + "source_line": " #undef STB_BUFFER_SIZE" + } + } + }, + "includes": { + "stb/stb_vorbis.c:stdio.h": { + "target": "stdio.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 578, + "column": 1, + "source_line": "#include " + } + }, + "stb/stb_vorbis.c:stdlib.h": { + "target": "stdlib.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 582, + "column": 4, + "source_line": " #include " + } + }, + "stb/stb_vorbis.c:string.h": { + "target": "string.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 583, + "column": 4, + "source_line": " #include " + } + }, + "stb/stb_vorbis.c:assert.h": { + "target": "assert.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 584, + "column": 4, + "source_line": " #include " + } + }, + "stb/stb_vorbis.c:math.h": { + "target": "math.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 585, + "column": 4, + "source_line": " #include " + } + }, + "stb/stb_vorbis.c:malloc.h": { + "target": "malloc.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 589, + "column": 7, + "source_line": " #include " + } + }, + "stb/stb_vorbis.c:alloca.h": { + "target": "alloca.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 592, + "column": 7, + "source_line": " #include " + } + }, + "stb/stb_vorbis.c:limits.h": { + "target": "limits.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 601, + "column": 1, + "source_line": "#include " + } + }, + "stb/stb_vorbis.c:crtdbg.h": { + "target": "crtdbg.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 634, + "column": 1, + "source_line": "#include " + } + } + }, + "functions_by_file": { + "stb/stb_vorbis.c": [ + "error", + "make_block_array", + "setup_malloc", + "setup_free", + "setup_temp_malloc", + "setup_temp_free", + "crc32_init", + "bit_reverse", + "square", + "ilog", + "float32_unpack", + "add_entry", + "compute_codewords", + "compute_accelerated_huffman", + "include_in_sort", + "compute_sorted_huffman", + "vorbis_validate", + "lookup1_values", + "compute_twiddle_factors", + "compute_window", + "compute_bitreverse", + "init_blocksize", + "neighbors", + "get8", + "get32", + "getn", + "skip", + "set_file_offset", + "capture_pattern", + "start_page_no_capturepattern", + "start_page", + "start_packet", + "maybe_start_packet", + "next_segment", + "get8_packet_raw", + "get8_packet", + "get32_packet", + "flush_packet", + "get_bits", + "codebook_decode_scalar_raw", + "codebook_decode_scalar", + "codebook_decode_start", + "codebook_decode", + "codebook_decode_step", + "codebook_decode_deinterleave_repeat", + "predict_point", + "residue_decode", + "decode_residue", + "inverse_mdct_slow", + "dct_iv_slow", + "mdct_init", + "mdct_clear", + "mdct_backward", + "inverse_mdct", + "imdct_step3_iter0_loop", + "imdct_step3_inner_r_loop", + "imdct_step3_inner_s_loop", + "imdct_step3_inner_s_loop_ld654", + "inverse_mdct_naive", + "get_window", + "do_floor", + "vorbis_decode_initial", + "vorbis_decode_packet_rest", + "vorbis_decode_packet", + "vorbis_finish_frame", + "vorbis_pump_first_frame", + "is_whole_packet_present", + "start_decoder", + "vorbis_deinit", + "stb_vorbis_close", + "vorbis_init", + "stb_vorbis_get_sample_offset", + "stb_vorbis_get_info", + "stb_vorbis_get_comment", + "stb_vorbis_get_error", + "vorbis_alloc", + "stb_vorbis_flush_pushdata", + "vorbis_search_for_page_pushdata", + "stb_vorbis_decode_frame_pushdata", + "stb_vorbis_open_pushdata", + "stb_vorbis_get_file_offset", + "vorbis_find_page", + "get_seek_page_info", + "go_to_page_before", + "seek_to_sample_coarse", + "peek_decode_initial", + "stb_vorbis_seek_frame", + "stb_vorbis_seek", + "stb_vorbis_seek_start", + "stb_vorbis_stream_length_in_samples", + "stb_vorbis_stream_length_in_seconds", + "stb_vorbis_get_frame_float", + "stb_vorbis_open_file_section", + "stb_vorbis_open_file", + "stb_vorbis_open_filename", + "stb_vorbis_open_memory", + "copy_samples", + "compute_samples", + "compute_stereo_samples", + "convert_samples_short", + "stb_vorbis_get_frame_short", + "convert_channels_short_interleaved", + "stb_vorbis_get_frame_short_interleaved", + "stb_vorbis_get_samples_short_interleaved", + "stb_vorbis_get_samples_short", + "stb_vorbis_decode_filename", + "stb_vorbis_decode_memory", + "stb_vorbis_get_samples_float_interleaved", + "stb_vorbis_get_samples_float" + ] + }, + "enum_constants": { + "VORBIS_packet_id": { + "name": "VORBIS_packet_id", + "value": "1", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1649, + "column": 1, + "source_line": "enum" + } + }, + "VORBIS_packet_comment": { + "name": "VORBIS_packet_comment", + "value": "3", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1649, + "column": 1, + "source_line": "enum" + } + }, + "VORBIS_packet_setup": { + "name": "VORBIS_packet_setup", + "value": "5", + "source_location": { + "filename": "stb/stb_vorbis.c", + "line": 1649, + "column": 1, + "source_line": "enum" + } + } + }, + "include_graph": { + "stb/stb_vorbis.c": [] + }, + "system_includes": { + "stb/stb_vorbis.c": [ + "alloca.h", + "assert.h", + "crtdbg.h", + "limits.h", + "malloc.h", + "math.h", + "stdio.h", + "stdlib.h", + "string.h" + ] + }, + "unresolved_includes": { + "stb/stb_vorbis.c": [] + }, + "header_source_pairs": {}, + "diagnostics": [ + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'malloc' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 596, + "column": 4, + "source_line": " #define malloc(s) 0" + }, + "unit_kind": "macro", + "unit_name": "malloc" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'free' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 597, + "column": 4, + "source_line": " #define free(s) ((void) 0)" + }, + "unit_kind": "macro", + "unit_name": "free" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'realloc' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 598, + "column": 4, + "source_line": " #define realloc(s) 0" + }, + "unit_kind": "macro", + "unit_name": "realloc" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'CHECK' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 635, + "column": 1, + "source_line": "#define CHECK(f) _CrtIsValidHeapPointer(f->channel_buffers[1])" + }, + "unit_kind": "macro", + "unit_name": "CHECK" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'CHECK' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 637, + "column": 1, + "source_line": "#define CHECK(f) ((void) 0)" + }, + "unit_kind": "macro", + "unit_name": "CHECK" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBV_NOTUSED' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 659, + "column": 1, + "source_line": "#define STBV_NOTUSED(v) (void)(v)" + }, + "unit_kind": "macro", + "unit_name": "STBV_NOTUSED" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBV_NOTUSED' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 661, + "column": 1, + "source_line": "#define STBV_NOTUSED(v) (void)sizeof(v)" + }, + "unit_kind": "macro", + "unit_name": "STBV_NOTUSED" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'IS_PUSH_MODE' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 904, + "column": 4, + "source_line": " #define IS_PUSH_MODE(f) FALSE" + }, + "unit_kind": "macro", + "unit_name": "IS_PUSH_MODE" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'IS_PUSH_MODE' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 906, + "column": 4, + "source_line": " #define IS_PUSH_MODE(f) TRUE" + }, + "unit_kind": "macro", + "unit_name": "IS_PUSH_MODE" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'IS_PUSH_MODE' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 908, + "column": 4, + "source_line": " #define IS_PUSH_MODE(f) ((f)->push_mode)" + }, + "unit_kind": "macro", + "unit_name": "IS_PUSH_MODE" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'array_size_required' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 928, + "column": 1, + "source_line": "#define array_size_required(count,size) (count*(sizeof(void *)+(size)))" + }, + "unit_kind": "macro", + "unit_name": "array_size_required" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'temp_alloc' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 930, + "column": 1, + "source_line": "#define temp_alloc(f,size) (f->alloc.alloc_buffer ? setup_temp_malloc(f,size) : alloca(size))" + }, + "unit_kind": "macro", + "unit_name": "temp_alloc" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'temp_free' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 931, + "column": 1, + "source_line": "#define temp_free(f,p) (void)0" + }, + "unit_kind": "macro", + "unit_name": "temp_free" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'temp_alloc_save' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 932, + "column": 1, + "source_line": "#define temp_alloc_save(f) ((f)->temp_offset)" + }, + "unit_kind": "macro", + "unit_name": "temp_alloc_save" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'temp_alloc_restore' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 933, + "column": 1, + "source_line": "#define temp_alloc_restore(f,p) ((f)->temp_offset = (p))" + }, + "unit_kind": "macro", + "unit_name": "temp_alloc_restore" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'temp_block_array' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 935, + "column": 1, + "source_line": "#define temp_block_array(f,count,size) make_block_array(temp_alloc(f,array_size_required(count,size)), count, size)" + }, + "unit_kind": "macro", + "unit_name": "temp_block_array" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'USE_MEMORY' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 1332, + "column": 4, + "source_line": " #define USE_MEMORY(z) TRUE" + }, + "unit_kind": "macro", + "unit_name": "USE_MEMORY" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'USE_MEMORY' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 1334, + "column": 4, + "source_line": " #define USE_MEMORY(z) ((z)->stream)" + }, + "unit_kind": "macro", + "unit_name": "USE_MEMORY" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'DECODE_RAW' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 1717, + "column": 1, + "source_line": "#define DECODE_RAW(var, f,c) \\" + }, + "unit_kind": "macro", + "unit_name": "DECODE_RAW" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'DECODE_RAW' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 1750, + "column": 1, + "source_line": "#define DECODE_RAW(var,f,c) var = codebook_decode_scalar(f,c);" + }, + "unit_kind": "macro", + "unit_name": "DECODE_RAW" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'DECODE' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 1754, + "column": 1, + "source_line": "#define DECODE(var,f,c) \\" + }, + "unit_kind": "macro", + "unit_name": "DECODE" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'DECODE_VQ' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 1759, + "column": 3, + "source_line": " #define DECODE_VQ(var,f,c) DECODE_RAW(var,f,c)" + }, + "unit_kind": "macro", + "unit_name": "DECODE_VQ" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'DECODE_VQ' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 1761, + "column": 3, + "source_line": " #define DECODE_VQ(var,f,c) DECODE(var,f,c)" + }, + "unit_kind": "macro", + "unit_name": "DECODE_VQ" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'CODEBOOK_ELEMENT' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 1771, + "column": 1, + "source_line": "#define CODEBOOK_ELEMENT(c,off) (c->multiplicands[off])" + }, + "unit_kind": "macro", + "unit_name": "CODEBOOK_ELEMENT" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'CODEBOOK_ELEMENT_FAST' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 1772, + "column": 1, + "source_line": "#define CODEBOOK_ELEMENT_FAST(c,off) (c->multiplicands[off])" + }, + "unit_kind": "macro", + "unit_name": "CODEBOOK_ELEMENT_FAST" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'CODEBOOK_ELEMENT_BASE' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 1773, + "column": 1, + "source_line": "#define CODEBOOK_ELEMENT_BASE(c) (0)" + }, + "unit_kind": "macro", + "unit_name": "CODEBOOK_ELEMENT_BASE" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'LINE_OP' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 2023, + "column": 1, + "source_line": "#define LINE_OP(a,b) a *= b" + }, + "unit_kind": "macro", + "unit_name": "LINE_OP" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'LINE_OP' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 2025, + "column": 1, + "source_line": "#define LINE_OP(a,b) a = b" + }, + "unit_kind": "macro", + "unit_name": "LINE_OP" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'FASTDEF' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 5153, + "column": 4, + "source_line": " #define FASTDEF(x) float_conv x" + }, + "unit_kind": "macro", + "unit_name": "FASTDEF" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'MAGIC' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 5155, + "column": 4, + "source_line": " #define MAGIC(SHIFT) (1.5f * (1 << (23-SHIFT)) + 0.5f/(1 << SHIFT))" + }, + "unit_kind": "macro", + "unit_name": "MAGIC" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'ADDEND' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 5156, + "column": 4, + "source_line": " #define ADDEND(SHIFT) (((150-SHIFT) << 23) + (1 << 22))" + }, + "unit_kind": "macro", + "unit_name": "ADDEND" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'FAST_SCALED_FLOAT_TO_INT' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 5157, + "column": 4, + "source_line": " #define FAST_SCALED_FLOAT_TO_INT(temp,x,s) (temp.f = (x) + MAGIC(s), temp.i - ADDEND(s))" + }, + "unit_kind": "macro", + "unit_name": "FAST_SCALED_FLOAT_TO_INT" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'check_endianness' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 5158, + "column": 4, + "source_line": " #define check_endianness()" + }, + "unit_kind": "macro", + "unit_name": "check_endianness" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'FAST_SCALED_FLOAT_TO_INT' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 5160, + "column": 4, + "source_line": " #define FAST_SCALED_FLOAT_TO_INT(temp,x,s) ((int) ((x) * (1 << (s))))" + }, + "unit_kind": "macro", + "unit_name": "FAST_SCALED_FLOAT_TO_INT" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'check_endianness' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 5161, + "column": 4, + "source_line": " #define check_endianness()" + }, + "unit_kind": "macro", + "unit_name": "check_endianness" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'FASTDEF' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 5162, + "column": 4, + "source_line": " #define FASTDEF(x)" + }, + "unit_kind": "macro", + "unit_name": "FASTDEF" + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '\"C\"'.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 86, + "column": 1, + "source_line": "extern \"C\" {" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro '__forceinline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 1003, + "column": 1, + "source_line": "static __forceinline uint32 crc32_update(uint32 crc, uint8 byte)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "__forceinline" + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'uint32_compare(const void *p, const void *q)'.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 1162, + "column": 1, + "source_line": "static int STBV_CDECL uint32_compare(const void *p, const void *q)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: 'point_compare(const void *p, const void *q)'.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 1320, + "column": 1, + "source_line": "static int STBV_CDECL point_compare(const void *p, const void *q)" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 1429, + "column": 1, + "source_line": "static uint8 ogg_page_header[4] = { 0x4f, 0x67, 0x67, 0x53 };" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro '__forceinline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 1634, + "column": 1, + "source_line": "static __forceinline void prep_huffman(vorb *f)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "__forceinline" + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 1946, + "column": 1, + "source_line": "static float inverse_db_table[256] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro '__forceinline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 2034, + "column": 1, + "source_line": "static __forceinline void draw_line(float *output, int x0, int y0, int x1, int y1, int n)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "__forceinline" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro '__forceinline'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 2554, + "column": 1, + "source_line": "static __forceinline void iter_54(float *z)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "__forceinline" + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 5135, + "column": 1, + "source_line": "static int8 channel_position[7][6] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_CONFLICTING_TYPEDEF", + "message": "Conflicting typedef declarations for 'YTYPE'.", + "severity": "error", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 3070, + "column": 1, + "source_line": "typedef int YTYPE;" + }, + "unit_kind": "typedef", + "unit_name": "YTYPE" + }, + { + "code": "C_CONFLICTING_FUNCTION_DECLARATION", + "message": "Conflicting declarations for function 'inverse_mdct_slow'.", + "severity": "error", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 2312, + "column": 1, + "source_line": "void inverse_mdct_slow(float *buffer, int n, vorb *f, int blocktype)" + }, + "unit_kind": "function", + "unit_name": "inverse_mdct_slow" + }, + { + "code": "C_CONFLICTING_FUNCTION_DECLARATION", + "message": "Conflicting declarations for function 'inverse_mdct_slow'.", + "severity": "error", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 2350, + "column": 1, + "source_line": "void inverse_mdct_slow(float *buffer, int n, vorb *f, int blocktype)" + }, + "unit_kind": "function", + "unit_name": "inverse_mdct_slow" + }, + { + "code": "C_DUPLICATE_FUNCTION_DEFINITION", + "message": "Duplicate definition for function 'inverse_mdct'.", + "severity": "error", + "location": { + "filename": "stb/stb_vorbis.c", + "line": 2629, + "column": 1, + "source_line": "static void inverse_mdct(float *buffer, int n, vorb *f, int blocktype)" + }, + "unit_kind": "function", + "unit_name": "inverse_mdct" + } + ] +} diff --git a/tests/parser/c/fixtures/stb/stb_voxel_render.json b/tests/parser/c/fixtures/stb/stb_voxel_render.json new file mode 100644 index 000000000..f3a91dab2 --- /dev/null +++ b/tests/parser/c/fixtures/stb/stb_voxel_render.json @@ -0,0 +1,16396 @@ +{ + "files": { + "stb/stb_voxel_render.h": { + "filename": "stb/stb_voxel_render.h", + "language": "c", + "parser_status": "partial", + "preprocessing": "raw", + "functions": [ + { + "name": "stbvox_build_default_palette", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1544, + "column": 1, + "source_line": "static void stbvox_build_default_palette(void)" + }, + "start": { + "filename": "stb/stb_voxel_render.h", + "line": 1544, + "column": 1, + "source_line": "static void stbvox_build_default_palette(void)" + }, + "end": { + "filename": "stb/stb_voxel_render.h", + "line": 1553, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbvox_compute_mesh_face_value", + "result_type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbvox_mesh_face", + "name": "stbvox_mesh_face", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "tex1", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char tex1" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1343, + "column": 7, + "source_line": " unsigned char tex1,tex2,color,face_info;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "tex2", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char tex2" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1343, + "column": 7, + "source_line": " unsigned char tex1,tex2,color,face_info;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "color", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char color" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1343, + "column": 7, + "source_line": " unsigned char tex1,tex2,color,face_info;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "face_info", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char face_info" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1343, + "column": 7, + "source_line": " unsigned char tex1,tex2,color,face_info;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_voxel_render.h:1341:4", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1341, + "column": 4, + "source_line": " typedef struct" + } + }, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1341, + "column": 4, + "source_line": " typedef struct" + }, + "declaration_locations": [] + }, + "parameters": [ + { + "name": "mm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbvox_mesh_maker", + "name": "stbvox_mesh_maker", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": "stbvox_mesh_maker", + "members": [ + { + "name": "input", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbvox_input_description", + "name": "stbvox_input_description", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": "stbvox_input_description", + "members": [ + { + "name": "lighting_at_vertices", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char lighting_at_vertices" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 728, + "column": 4, + "source_line": " unsigned char lighting_at_vertices;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "rgb", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_rgb *rgb", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbvox_rgb", + "name": "stbvox_rgb", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "r", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char r" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 713, + "column": 4, + "source_line": " unsigned char r,g,b;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "g", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char g" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 713, + "column": 4, + "source_line": " unsigned char r,g,b;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "b", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char b" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 713, + "column": 4, + "source_line": " unsigned char r,g,b;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_voxel_render.h:711:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 711, + "column": 1, + "source_line": "typedef struct" + } + }, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 711, + "column": 1, + "source_line": "typedef struct" + }, + "declaration_locations": [] + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 742, + "column": 4, + "source_line": " stbvox_rgb *rgb;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "lighting", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *lighting", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 746, + "column": 4, + "source_line": " unsigned char *lighting;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "blocktype", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_block_type *blocktype", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbvox_block_type", + "name": "stbvox_block_type", + "type": { + "model": "CUnsignedShort", + "qualifiers": [], + "source_text": "typedef unsigned short stbvox_block_type" + }, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 705, + "column": 1, + "source_line": "typedef unsigned short stbvox_block_type;" + }, + "declaration_locations": [] + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 767, + "column": 4, + "source_line": " stbvox_block_type *blocktype;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "geometry", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *geometry", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 780, + "column": 4, + "source_line": " unsigned char *geometry;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "block_geometry", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *block_geometry", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 787, + "column": 4, + "source_line": " unsigned char *block_geometry;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "block_tex1", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *block_tex1", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 794, + "column": 4, + "source_line": " unsigned char *block_tex1;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "block_tex1_face", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char (*block_tex1_face)[6]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "6", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 797, + "column": 4, + "source_line": " unsigned char (*block_tex1_face)[6];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "tex2", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *tex2", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 804, + "column": 4, + "source_line": " unsigned char *tex2;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "block_tex2", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *block_tex2", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 808, + "column": 4, + "source_line": " unsigned char *block_tex2;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "block_tex2_face", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char (*block_tex2_face)[6]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "6", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 811, + "column": 4, + "source_line": " unsigned char (*block_tex2_face)[6];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "color", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *color", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 816, + "column": 4, + "source_line": " unsigned char *color;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "block_color", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *block_color", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 821, + "column": 4, + "source_line": " unsigned char *block_color;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "block_color_face", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char (*block_color_face)[6]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "6", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 826, + "column": 4, + "source_line": " unsigned char (*block_color_face)[6];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "block_texlerp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *block_texlerp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 831, + "column": 4, + "source_line": " unsigned char *block_texlerp;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "block_texlerp_face", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char (*block_texlerp_face)[6]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "6", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 836, + "column": 4, + "source_line": " unsigned char (*block_texlerp_face)[6];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "block_vheight", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *block_vheight", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 840, + "column": 4, + "source_line": " unsigned char *block_vheight;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "selector", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *selector", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 846, + "column": 4, + "source_line": " unsigned char *selector;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "block_selector", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *block_selector", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 849, + "column": 4, + "source_line": " unsigned char *block_selector;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "side_texrot", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *side_texrot", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 852, + "column": 4, + "source_line": " unsigned char *side_texrot;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "block_side_texrot", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *block_side_texrot", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 857, + "column": 4, + "source_line": " unsigned char *block_side_texrot;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "overlay", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *overlay", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 862, + "column": 4, + "source_line": " unsigned char *overlay; // index into palettes listed below" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "overlay_tex1", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char (*overlay_tex1)[6]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "6", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 867, + "column": 4, + "source_line": " unsigned char (*overlay_tex1)[6];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "overlay_tex2", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char (*overlay_tex2)[6]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "6", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 872, + "column": 4, + "source_line": " unsigned char (*overlay_tex2)[6];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "overlay_color", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char (*overlay_color)[6]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "6", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 877, + "column": 4, + "source_line": " unsigned char (*overlay_color)[6];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "overlay_side_texrot", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *overlay_side_texrot", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 881, + "column": 4, + "source_line": " unsigned char *overlay_side_texrot;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "rotate", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *rotate", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 886, + "column": 4, + "source_line": " unsigned char *rotate;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "tex2_for_tex1", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *tex2_for_tex1", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 895, + "column": 4, + "source_line": " unsigned char *tex2_for_tex1;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "tex2_replace", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *tex2_replace", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 902, + "column": 4, + "source_line": " unsigned char *tex2_replace;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "tex2_facemask", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *tex2_facemask", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 909, + "column": 4, + "source_line": " unsigned char *tex2_facemask;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "extended_color", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *extended_color", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 915, + "column": 4, + "source_line": " unsigned char *extended_color;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "ecolor_color", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *ecolor_color", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 919, + "column": 4, + "source_line": " unsigned char *ecolor_color;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "ecolor_facemask", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *ecolor_facemask", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 924, + "column": 4, + "source_line": " unsigned char *ecolor_facemask;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "color2", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *color2", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 930, + "column": 4, + "source_line": " unsigned char *color2;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "color2_facemask", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *color2_facemask", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 935, + "column": 4, + "source_line": " unsigned char *color2_facemask;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "color3", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *color3", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 940, + "column": 4, + "source_line": " unsigned char *color3;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "color3_facemask", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *color3_facemask", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 945, + "column": 4, + "source_line": " unsigned char *color3_facemask;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "texlerp_simple", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *texlerp_simple", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 950, + "column": 4, + "source_line": " unsigned char *texlerp_simple;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "texlerp", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *texlerp", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 967, + "column": 4, + "source_line": " unsigned char *texlerp;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "texlerp_vert3", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned short *texlerp_vert3", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedShort", + "qualifiers": [], + "source_text": "unsigned short" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 977, + "column": 4, + "source_line": " unsigned short *texlerp_vert3;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "texlerp_face3", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned short *texlerp_face3", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedShort", + "qualifiers": [], + "source_text": "unsigned short" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 988, + "column": 4, + "source_line": " unsigned short *texlerp_face3; // e:3,n:3,w:3,s:3,u:2,d:2" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "vheight", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *vheight", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 996, + "column": 4, + "source_line": " unsigned char *vheight; // STBVOX_MAKE_VHEIGHT -- sw:2, se:2, nw:2, ne:2, doesn't rotate" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "packed_compact", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *packed_compact", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1001, + "column": 4, + "source_line": " unsigned char *packed_compact;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": null, + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 726, + "column": 1, + "source_line": "struct stbvox_input_description" + } + }, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 234, + "column": 1, + "source_line": "typedef struct stbvox_input_description stbvox_input_description;" + }, + "declaration_locations": [] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1184, + "column": 4, + "source_line": " stbvox_input_description input;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "cur_x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int cur_x" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1185, + "column": 4, + "source_line": " int cur_x, cur_y, cur_z; // last unprocessed voxel if it splits into multiple buffers" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "cur_y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int cur_y" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1185, + "column": 4, + "source_line": " int cur_x, cur_y, cur_z; // last unprocessed voxel if it splits into multiple buffers" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "cur_z", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int cur_z" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1185, + "column": 4, + "source_line": " int cur_x, cur_y, cur_z; // last unprocessed voxel if it splits into multiple buffers" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "x0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1186, + "column": 4, + "source_line": " int x0,y0,z0,x1,y1,z1;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "y0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1186, + "column": 4, + "source_line": " int x0,y0,z0,x1,y1,z1;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "z0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int z0" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1186, + "column": 4, + "source_line": " int x0,y0,z0,x1,y1,z1;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "x1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1186, + "column": 4, + "source_line": " int x0,y0,z0,x1,y1,z1;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "y1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1186, + "column": 4, + "source_line": " int x0,y0,z0,x1,y1,z1;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "z1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int z1" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1186, + "column": 4, + "source_line": " int x0,y0,z0,x1,y1,z1;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "x_stride_in_bytes", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x_stride_in_bytes" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1187, + "column": 4, + "source_line": " int x_stride_in_bytes;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "y_stride_in_bytes", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y_stride_in_bytes" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1188, + "column": 4, + "source_line": " int y_stride_in_bytes;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "config_dirty", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int config_dirty" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1189, + "column": 4, + "source_line": " int config_dirty;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "default_mesh", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int default_mesh" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1190, + "column": 4, + "source_line": " int default_mesh;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "tags", + "type": { + "model": "CUnsignedInt", + "qualifiers": [], + "source_text": "unsigned int tags" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1191, + "column": 4, + "source_line": " unsigned int tags;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "cube_vertex_offset", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int cube_vertex_offset[6][4]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "6", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "4", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1193, + "column": 4, + "source_line": " int cube_vertex_offset[6][4]; // this allows access per-vertex data stored block-centered (like texlerp, ambient)" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "vertex_gather_offset", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int vertex_gather_offset[6][4]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "6", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "4", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1194, + "column": 4, + "source_line": " int vertex_gather_offset[6][4];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "pos_x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int pos_x" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1196, + "column": 4, + "source_line": " int pos_x,pos_y,pos_z;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "pos_y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int pos_y" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1196, + "column": 4, + "source_line": " int pos_x,pos_y,pos_z;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "pos_z", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int pos_z" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1196, + "column": 4, + "source_line": " int pos_x,pos_y,pos_z;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "full", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int full" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1197, + "column": 4, + "source_line": " int full;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "output_cur", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *output_cur [STBVOX_MAX_MESHES][STBVOX_MAX_MESH_SLOTS]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STBVOX_MAX_MESHES", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STBVOX_MAX_MESH_SLOTS", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1200, + "column": 4, + "source_line": " char *output_cur [STBVOX_MAX_MESHES][STBVOX_MAX_MESH_SLOTS];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "output_end", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *output_end [STBVOX_MAX_MESHES][STBVOX_MAX_MESH_SLOTS]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STBVOX_MAX_MESHES", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STBVOX_MAX_MESH_SLOTS", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1201, + "column": 4, + "source_line": " char *output_end [STBVOX_MAX_MESHES][STBVOX_MAX_MESH_SLOTS];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "output_buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char *output_buffer[STBVOX_MAX_MESHES][STBVOX_MAX_MESH_SLOTS]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STBVOX_MAX_MESHES", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STBVOX_MAX_MESH_SLOTS", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1202, + "column": 4, + "source_line": " char *output_buffer[STBVOX_MAX_MESHES][STBVOX_MAX_MESH_SLOTS];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "output_len", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int output_len [STBVOX_MAX_MESHES][STBVOX_MAX_MESH_SLOTS]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STBVOX_MAX_MESHES", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STBVOX_MAX_MESH_SLOTS", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1203, + "column": 4, + "source_line": " int output_len [STBVOX_MAX_MESHES][STBVOX_MAX_MESH_SLOTS];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "output_size", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int output_size [STBVOX_MAX_MESHES][STBVOX_MAX_MESH_SLOTS]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STBVOX_MAX_MESHES", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STBVOX_MAX_MESH_SLOTS", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1206, + "column": 4, + "source_line": " int output_size [STBVOX_MAX_MESHES][STBVOX_MAX_MESH_SLOTS]; // per quad" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "output_step", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int output_step [STBVOX_MAX_MESHES][STBVOX_MAX_MESH_SLOTS]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STBVOX_MAX_MESHES", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "STBVOX_MAX_MESH_SLOTS", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1207, + "column": 4, + "source_line": " int output_step [STBVOX_MAX_MESHES][STBVOX_MAX_MESH_SLOTS]; // per vertex or per face, depending" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "num_mesh_slots", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int num_mesh_slots" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1208, + "column": 4, + "source_line": " int num_mesh_slots;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "default_tex_scale", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float default_tex_scale[128][2]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "128", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "2", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1210, + "column": 4, + "source_line": " float default_tex_scale[128][2];" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": null, + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1182, + "column": 1, + "source_line": "struct stbvox_mesh_maker" + } + }, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 233, + "column": 1, + "source_line": "typedef struct stbvox_mesh_maker stbvox_mesh_maker;" + }, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "rot", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbvox_rotate", + "name": "stbvox_rotate", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "block", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char block" + }, + "storage": [], + "initializer": null, + "bit_width": "2", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2019, + "column": 4, + "source_line": " unsigned char block:2;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "overlay", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char overlay" + }, + "storage": [], + "initializer": null, + "bit_width": "2", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2020, + "column": 4, + "source_line": " unsigned char overlay:2;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "facerot", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char facerot" + }, + "storage": [], + "initializer": null, + "bit_width": "2", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2021, + "column": 4, + "source_line": " unsigned char facerot:2;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "ecolor", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char ecolor" + }, + "storage": [], + "initializer": null, + "bit_width": "2", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2022, + "column": 4, + "source_line": " unsigned char ecolor:2;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_voxel_render.h:2017:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2017, + "column": 1, + "source_line": "typedef struct" + } + }, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2017, + "column": 1, + "source_line": "typedef struct" + }, + "declaration_locations": [] + }, + "declared_type": { + "reference": "stbvox_rotate" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "face", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int face" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int face" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "v_off", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v_off" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v_off" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "normal", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int normal" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int normal" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2042, + "column": 1, + "source_line": "stbvox_mesh_face stbvox_compute_mesh_face_value(stbvox_mesh_maker *mm, stbvox_rotate rot, int face, int v_off, int normal)" + }, + "start": { + "filename": "stb/stb_voxel_render.h", + "line": 2042, + "column": 1, + "source_line": "stbvox_mesh_face stbvox_compute_mesh_face_value(stbvox_mesh_maker *mm, stbvox_rotate rot, int face, int v_off, int normal)" + }, + "end": { + "filename": "stb/stb_voxel_render.h", + "line": 2143, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbvox_get_quad_vertex_pointer", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "mm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mesh", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mesh" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mesh" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "vertices", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_vertex **vertices", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbvox_mesh_vertex", + "name": "stbvox_mesh_vertex", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbvox_uint32", + "name": "stbvox_uint32", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "typedef uint32_t stbvox_uint32", + "name": "uint32_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1226, + "column": 4, + "source_line": " typedef uint32_t stbvox_uint32;" + }, + "declaration_locations": [] + }, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1321, + "column": 4, + "source_line": " typedef stbvox_uint32 stbvox_mesh_vertex;" + }, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_vertex **vertices", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_vertex" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "face", + "type": { + "reference": "stbvox_mesh_face" + }, + "declared_type": { + "reference": "stbvox_mesh_face" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2651, + "column": 1, + "source_line": "void stbvox_get_quad_vertex_pointer(stbvox_mesh_maker *mm, int mesh, stbvox_mesh_vertex **vertices, stbvox_mesh_face face)" + }, + "start": { + "filename": "stb/stb_voxel_render.h", + "line": 2651, + "column": 1, + "source_line": "void stbvox_get_quad_vertex_pointer(stbvox_mesh_maker *mm, int mesh, stbvox_mesh_vertex **vertices, stbvox_mesh_face face)" + }, + "end": { + "filename": "stb/stb_voxel_render.h", + "line": 2674, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbvox_make_mesh_for_face", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "mm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "rot", + "type": { + "reference": "stbvox_rotate" + }, + "declared_type": { + "reference": "stbvox_rotate" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "face", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int face" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int face" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "v_off", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v_off" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v_off" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "pos", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbvox_pos", + "name": "stbvox_pos", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": null, + "members": [ + { + "name": "x", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char x" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2027, + "column": 4, + "source_line": " unsigned char x,y,z;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "y", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char y" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2027, + "column": 4, + "source_line": " unsigned char x,y,z;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "z", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char z" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2027, + "column": 4, + "source_line": " unsigned char x,y,z;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": "struct@stb/stb_voxel_render.h:2025:1", + "is_incomplete": false, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2025, + "column": 1, + "source_line": "typedef struct" + } + }, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2025, + "column": 1, + "source_line": "typedef struct" + }, + "declaration_locations": [] + }, + "declared_type": { + "reference": "stbvox_pos" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "vertbase", + "type": { + "reference": "stbvox_mesh_vertex" + }, + "declared_type": { + "reference": "stbvox_mesh_vertex" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "face_coord", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_vertex *face_coord", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_vertex" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_vertex *face_coord", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_vertex" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mesh", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char mesh" + }, + "declared_type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char mesh" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "normal", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int normal" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int normal" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2676, + "column": 1, + "source_line": "void stbvox_make_mesh_for_face(stbvox_mesh_maker *mm, stbvox_rotate rot, int face, int v_off, stbvox_pos pos, stbvox_mesh_vertex vertbase, stbvox_mesh_vertex *face_coord, unsigned char mesh, int normal)" + }, + "start": { + "filename": "stb/stb_voxel_render.h", + "line": 2676, + "column": 1, + "source_line": "void stbvox_make_mesh_for_face(stbvox_mesh_maker *mm, stbvox_rotate rot, int face, int v_off, stbvox_pos pos, stbvox_mesh_vertex vertbase, stbvox_mesh_vertex *face_coord, unsigned char mesh, int normal)" + }, + "end": { + "filename": "stb/stb_voxel_render.h", + "line": 2830, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbvox_make_12_split_mesh_for_face", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "mm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "rot", + "type": { + "reference": "stbvox_rotate" + }, + "declared_type": { + "reference": "stbvox_rotate" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "face", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int face" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int face" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "v_off", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v_off" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v_off" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "pos", + "type": { + "reference": "stbvox_pos" + }, + "declared_type": { + "reference": "stbvox_pos" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "vertbase", + "type": { + "reference": "stbvox_mesh_vertex" + }, + "declared_type": { + "reference": "stbvox_mesh_vertex" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "face_coord", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_vertex *face_coord", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_vertex" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_vertex *face_coord", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_vertex" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mesh", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char mesh" + }, + "declared_type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char mesh" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ht", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *ht", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *ht", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2843, + "column": 1, + "source_line": "static void stbvox_make_12_split_mesh_for_face(stbvox_mesh_maker *mm, stbvox_rotate rot, int face, int v_off, stbvox_pos pos, stbvox_mesh_vertex vertbase, stbvox_mesh_vertex *face_coord, unsigned char mesh, unsigned char *ht)" + }, + "start": { + "filename": "stb/stb_voxel_render.h", + "line": 2843, + "column": 1, + "source_line": "static void stbvox_make_12_split_mesh_for_face(stbvox_mesh_maker *mm, stbvox_rotate rot, int face, int v_off, stbvox_pos pos, stbvox_mesh_vertex vertbase, stbvox_mesh_vertex *face_coord, unsigned char mesh, unsigned char *ht)" + }, + "end": { + "filename": "stb/stb_voxel_render.h", + "line": 2864, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbvox_make_03_split_mesh_for_face", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "mm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "rot", + "type": { + "reference": "stbvox_rotate" + }, + "declared_type": { + "reference": "stbvox_rotate" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "face", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int face" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int face" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "v_off", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v_off" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v_off" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "pos", + "type": { + "reference": "stbvox_pos" + }, + "declared_type": { + "reference": "stbvox_pos" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "vertbase", + "type": { + "reference": "stbvox_mesh_vertex" + }, + "declared_type": { + "reference": "stbvox_mesh_vertex" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "face_coord", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_vertex *face_coord", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_vertex" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_vertex *face_coord", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_vertex" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mesh", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char mesh" + }, + "declared_type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char mesh" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ht", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *ht", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *ht", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2866, + "column": 1, + "source_line": "static void stbvox_make_03_split_mesh_for_face(stbvox_mesh_maker *mm, stbvox_rotate rot, int face, int v_off, stbvox_pos pos, stbvox_mesh_vertex vertbase, stbvox_mesh_vertex *face_coord, unsigned char mesh, unsigned char *ht)" + }, + "start": { + "filename": "stb/stb_voxel_render.h", + "line": 2866, + "column": 1, + "source_line": "static void stbvox_make_03_split_mesh_for_face(stbvox_mesh_maker *mm, stbvox_rotate rot, int face, int v_off, stbvox_pos pos, stbvox_mesh_vertex vertbase, stbvox_mesh_vertex *face_coord, unsigned char mesh, unsigned char *ht)" + }, + "end": { + "filename": "stb/stb_voxel_render.h", + "line": 2886, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbvox_make_mesh_for_block", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "mm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "pos", + "type": { + "reference": "stbvox_pos" + }, + "declared_type": { + "reference": "stbvox_pos" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "v_off", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v_off" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v_off" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "vmesh", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_vertex *vmesh", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_vertex" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_vertex *vmesh", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_vertex" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2894, + "column": 1, + "source_line": "static void stbvox_make_mesh_for_block(stbvox_mesh_maker *mm, stbvox_pos pos, int v_off, stbvox_mesh_vertex *vmesh)" + }, + "start": { + "filename": "stb/stb_voxel_render.h", + "line": 2894, + "column": 1, + "source_line": "static void stbvox_make_mesh_for_block(stbvox_mesh_maker *mm, stbvox_pos pos, int v_off, stbvox_mesh_vertex *vmesh)" + }, + "end": { + "filename": "stb/stb_voxel_render.h", + "line": 2953, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbvox_make_mesh_for_block_with_geo", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "mm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "pos", + "type": { + "reference": "stbvox_pos" + }, + "declared_type": { + "reference": "stbvox_pos" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "v_off", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v_off" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v_off" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2963, + "column": 1, + "source_line": "static void stbvox_make_mesh_for_block_with_geo(stbvox_mesh_maker *mm, stbvox_pos pos, int v_off)" + }, + "start": { + "filename": "stb/stb_voxel_render.h", + "line": 2963, + "column": 1, + "source_line": "static void stbvox_make_mesh_for_block_with_geo(stbvox_mesh_maker *mm, stbvox_pos pos, int v_off)" + }, + "end": { + "filename": "stb/stb_voxel_render.h", + "line": 3397, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbvox_make_mesh_for_column", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "mm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "z0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int z0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int z0" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 3399, + "column": 1, + "source_line": "static void stbvox_make_mesh_for_column(stbvox_mesh_maker *mm, int x, int y, int z0)" + }, + "start": { + "filename": "stb/stb_voxel_render.h", + "line": 3399, + "column": 1, + "source_line": "static void stbvox_make_mesh_for_column(stbvox_mesh_maker *mm, int x, int y, int z0)" + }, + "end": { + "filename": "stb/stb_voxel_render.h", + "line": 3465, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbvox_bring_up_to_date", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "mm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 3467, + "column": 1, + "source_line": "static void stbvox_bring_up_to_date(stbvox_mesh_maker *mm)" + }, + "start": { + "filename": "stb/stb_voxel_render.h", + "line": 3467, + "column": 1, + "source_line": "static void stbvox_bring_up_to_date(stbvox_mesh_maker *mm)" + }, + "end": { + "filename": "stb/stb_voxel_render.h", + "line": 3489, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbvox_make_mesh", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "mm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 3491, + "column": 1, + "source_line": "int stbvox_make_mesh(stbvox_mesh_maker *mm)" + }, + "start": { + "filename": "stb/stb_voxel_render.h", + "line": 3491, + "column": 1, + "source_line": "int stbvox_make_mesh(stbvox_mesh_maker *mm)" + }, + "end": { + "filename": "stb/stb_voxel_render.h", + "line": 3520, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbvox_init_mesh_maker", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "mm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 3522, + "column": 1, + "source_line": "void stbvox_init_mesh_maker(stbvox_mesh_maker *mm)" + }, + "start": { + "filename": "stb/stb_voxel_render.h", + "line": 3522, + "column": 1, + "source_line": "void stbvox_init_mesh_maker(stbvox_mesh_maker *mm)" + }, + "end": { + "filename": "stb/stb_voxel_render.h", + "line": 3529, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbvox_get_buffer_count", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "mm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 3531, + "column": 1, + "source_line": "int stbvox_get_buffer_count(stbvox_mesh_maker *mm)" + }, + "start": { + "filename": "stb/stb_voxel_render.h", + "line": 3531, + "column": 1, + "source_line": "int stbvox_get_buffer_count(stbvox_mesh_maker *mm)" + }, + "end": { + "filename": "stb/stb_voxel_render.h", + "line": 3535, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbvox_get_buffer_size_per_quad", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "mm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 3537, + "column": 1, + "source_line": "int stbvox_get_buffer_size_per_quad(stbvox_mesh_maker *mm, int n)" + }, + "start": { + "filename": "stb/stb_voxel_render.h", + "line": 3537, + "column": 1, + "source_line": "int stbvox_get_buffer_size_per_quad(stbvox_mesh_maker *mm, int n)" + }, + "end": { + "filename": "stb/stb_voxel_render.h", + "line": 3540, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbvox_reset_buffers", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "mm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 3542, + "column": 1, + "source_line": "void stbvox_reset_buffers(stbvox_mesh_maker *mm)" + }, + "start": { + "filename": "stb/stb_voxel_render.h", + "line": 3542, + "column": 1, + "source_line": "void stbvox_reset_buffers(stbvox_mesh_maker *mm)" + }, + "end": { + "filename": "stb/stb_voxel_render.h", + "line": 3549, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbvox_set_buffer", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "mm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mesh", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mesh" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mesh" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "slot", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int slot" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int slot" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "size_t len", + "name": "size_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 3551, + "column": 1, + "source_line": "void stbvox_set_buffer(stbvox_mesh_maker *mm, int mesh, int slot, void *buffer, size_t len)" + }, + "start": { + "filename": "stb/stb_voxel_render.h", + "line": 3551, + "column": 1, + "source_line": "void stbvox_set_buffer(stbvox_mesh_maker *mm, int mesh, int slot, void *buffer, size_t len)" + }, + "end": { + "filename": "stb/stb_voxel_render.h", + "line": 3564, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbvox_set_default_mesh", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "mm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mesh", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mesh" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mesh" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 3566, + "column": 1, + "source_line": "void stbvox_set_default_mesh(stbvox_mesh_maker *mm, int mesh)" + }, + "start": { + "filename": "stb/stb_voxel_render.h", + "line": 3566, + "column": 1, + "source_line": "void stbvox_set_default_mesh(stbvox_mesh_maker *mm, int mesh)" + }, + "end": { + "filename": "stb/stb_voxel_render.h", + "line": 3569, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbvox_get_quad_count", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "mm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mesh", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mesh" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mesh" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 3571, + "column": 1, + "source_line": "int stbvox_get_quad_count(stbvox_mesh_maker *mm, int mesh)" + }, + "start": { + "filename": "stb/stb_voxel_render.h", + "line": 3571, + "column": 1, + "source_line": "int stbvox_get_quad_count(stbvox_mesh_maker *mm, int mesh)" + }, + "end": { + "filename": "stb/stb_voxel_render.h", + "line": 3574, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbvox_get_input_description", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_input_description", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_input_description" + } + ] + }, + "parameters": [ + { + "name": "mm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 3576, + "column": 1, + "source_line": "stbvox_input_description *stbvox_get_input_description(stbvox_mesh_maker *mm)" + }, + "start": { + "filename": "stb/stb_voxel_render.h", + "line": 3576, + "column": 1, + "source_line": "stbvox_input_description *stbvox_get_input_description(stbvox_mesh_maker *mm)" + }, + "end": { + "filename": "stb/stb_voxel_render.h", + "line": 3579, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbvox_set_input_range", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "mm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "z0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int z0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int z0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "z1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int z1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int z1" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 3581, + "column": 1, + "source_line": "void stbvox_set_input_range(stbvox_mesh_maker *mm, int x0, int y0, int z0, int x1, int y1, int z1)" + }, + "start": { + "filename": "stb/stb_voxel_render.h", + "line": 3581, + "column": 1, + "source_line": "void stbvox_set_input_range(stbvox_mesh_maker *mm, int x0, int y0, int z0, int x1, int y1, int z1)" + }, + "end": { + "filename": "stb/stb_voxel_render.h", + "line": 3596, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbvox_get_transform", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "mm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "transform", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float transform[3][3]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "3", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float transform[3][3]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "3", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "3", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 3598, + "column": 1, + "source_line": "void stbvox_get_transform(stbvox_mesh_maker *mm, float transform[3][3])" + }, + "start": { + "filename": "stb/stb_voxel_render.h", + "line": 3598, + "column": 1, + "source_line": "void stbvox_get_transform(stbvox_mesh_maker *mm, float transform[3][3])" + }, + "end": { + "filename": "stb/stb_voxel_render.h", + "line": 3616, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbvox_get_bounds", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "mm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "bounds", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float bounds[2][3]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "3", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float bounds[2][3]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "2", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "3", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 3618, + "column": 1, + "source_line": "void stbvox_get_bounds(stbvox_mesh_maker *mm, float bounds[2][3])" + }, + "start": { + "filename": "stb/stb_voxel_render.h", + "line": 3618, + "column": 1, + "source_line": "void stbvox_get_bounds(stbvox_mesh_maker *mm, float bounds[2][3])" + }, + "end": { + "filename": "stb/stb_voxel_render.h", + "line": 3626, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbvox_set_mesh_coordinates", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "mm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "z", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int z" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int z" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 3628, + "column": 1, + "source_line": "void stbvox_set_mesh_coordinates(stbvox_mesh_maker *mm, int x, int y, int z)" + }, + "start": { + "filename": "stb/stb_voxel_render.h", + "line": 3628, + "column": 1, + "source_line": "void stbvox_set_mesh_coordinates(stbvox_mesh_maker *mm, int x, int y, int z)" + }, + "end": { + "filename": "stb/stb_voxel_render.h", + "line": 3633, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "stbvox_set_input_stride", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "mm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x_stride_in_bytes", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x_stride_in_bytes" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x_stride_in_bytes" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y_stride_in_bytes", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y_stride_in_bytes" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y_stride_in_bytes" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 3635, + "column": 1, + "source_line": "void stbvox_set_input_stride(stbvox_mesh_maker *mm, int x_stride_in_bytes, int y_stride_in_bytes)" + }, + "start": { + "filename": "stb/stb_voxel_render.h", + "line": 3635, + "column": 1, + "source_line": "void stbvox_set_input_stride(stbvox_mesh_maker *mm, int x_stride_in_bytes, int y_stride_in_bytes)" + }, + "end": { + "filename": "stb/stb_voxel_render.h", + "line": 3650, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "find_best_normal", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "z", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float z" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float z" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 3667, + "column": 1, + "source_line": "static char *find_best_normal(float x, float y, float z)" + }, + "start": { + "filename": "stb/stb_voxel_render.h", + "line": 3667, + "column": 1, + "source_line": "static char *find_best_normal(float x, float y, float z)" + }, + "end": { + "filename": "stb/stb_voxel_render.h", + "line": 3682, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "main", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "argc", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int argc" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int argc" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "argv", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char **argv", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char **argv", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 3684, + "column": 1, + "source_line": "int main(int argc, char **argv)" + }, + "start": { + "filename": "stb/stb_voxel_render.h", + "line": 3684, + "column": 1, + "source_line": "int main(int argc, char **argv)" + }, + "end": { + "filename": "stb/stb_voxel_render.h", + "line": 3702, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + } + ], + "structs": [ + { + "reference": "struct@stb/stb_voxel_render.h:711:1" + }, + { + "reference": "struct stbvox_input_description" + }, + { + "reference": "struct stbvox_mesh_maker" + }, + { + "reference": "struct@stb/stb_voxel_render.h:1341:4" + }, + { + "reference": "struct@stb/stb_voxel_render.h:2017:1" + }, + { + "reference": "struct@stb/stb_voxel_render.h:2025:1" + } + ], + "unions": [], + "enums": [ + { + "model": "CEnum", + "qualifiers": [], + "source_text": "", + "name": null, + "constants": [ + { + "name": "STBVOX_GEOM_empty", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 665, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVOX_GEOM_knockout", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 665, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVOX_GEOM_solid", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 665, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVOX_GEOM_transp", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 665, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVOX_GEOM_slab_upper", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 665, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVOX_GEOM_slab_lower", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 665, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVOX_GEOM_floor_slope_north_is_top", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 665, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVOX_GEOM_ceil_slope_north_is_bottom", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 665, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVOX_GEOM_floor_slope_north_is_top_as_wall_UNIMPLEMENTED", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 665, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVOX_GEOM_ceil_slope_north_is_bottom_as_wall_UNIMPLEMENTED", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 665, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVOX_GEOM_crossed_pair", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 665, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVOX_GEOM_force", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 665, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVOX_GEOM_floor_vheight_03", + "value": "12", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 665, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVOX_GEOM_floor_vheight_12", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 665, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVOX_GEOM_ceil_vheight_03", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 665, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVOX_GEOM_ceil_vheight_12", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 665, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVOX_GEOM_count", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 665, + "column": 1, + "source_line": "enum" + } + } + ], + "anonymous_id": "enum@stb/stb_voxel_render.h:665:1", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 665, + "column": 1, + "source_line": "enum" + } + }, + { + "model": "CEnum", + "qualifiers": [], + "source_text": "", + "name": null, + "constants": [ + { + "name": "STBVOX_FACE_east", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 692, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVOX_FACE_north", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 692, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVOX_FACE_west", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 692, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVOX_FACE_south", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 692, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVOX_FACE_up", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 692, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVOX_FACE_down", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 692, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVOX_FACE_count", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 692, + "column": 1, + "source_line": "enum" + } + } + ], + "anonymous_id": "enum@stb/stb_voxel_render.h:692:1", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 692, + "column": 1, + "source_line": "enum" + } + }, + { + "model": "CEnum", + "qualifiers": [], + "source_text": "", + "name": null, + "constants": [ + { + "name": "STBVOX_VERTEX_HEIGHT_0", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1035, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVOX_VERTEX_HEIGHT_half", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1035, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVOX_VERTEX_HEIGHT_1", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1035, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVOX_VERTEX_HEIGHT_one_and_a_half", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1035, + "column": 1, + "source_line": "enum" + } + } + ], + "anonymous_id": "enum@stb/stb_voxel_render.h:1035:1", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1035, + "column": 1, + "source_line": "enum" + } + }, + { + "model": "CEnum", + "qualifiers": [], + "source_text": "", + "name": null, + "constants": [ + { + "name": "STBVOX_TEXLERP_FACE_0", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1117, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVOX_TEXLERP_FACE_half", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1117, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVOX_TEXLERP_FACE_1", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1117, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVOX_TEXLERP_FACE_use_vert", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1117, + "column": 1, + "source_line": "enum" + } + } + ], + "anonymous_id": "enum@stb/stb_voxel_render.h:1117:1", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1117, + "column": 1, + "source_line": "enum" + } + }, + { + "model": "CEnum", + "qualifiers": [], + "source_text": "", + "name": null, + "constants": [ + { + "name": "STBVOX_TEXLERP_BASE_0", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1125, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVOX_TEXLERP_BASE_2_7", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1125, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVOX_TEXLERP_BASE_5_7", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1125, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVOX_TEXLERP_BASE_1", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1125, + "column": 1, + "source_line": "enum" + } + } + ], + "anonymous_id": "enum@stb/stb_voxel_render.h:1125:1", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1125, + "column": 1, + "source_line": "enum" + } + }, + { + "model": "CEnum", + "qualifiers": [], + "source_text": "", + "name": null, + "constants": [ + { + "name": "STBVOX_TEXLERP3_0_8", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1133, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVOX_TEXLERP3_1_8", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1133, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVOX_TEXLERP3_2_8", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1133, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVOX_TEXLERP3_3_8", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1133, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVOX_TEXLERP3_4_8", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1133, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVOX_TEXLERP3_5_8", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1133, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVOX_TEXLERP3_6_8", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1133, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVOX_TEXLERP3_7_8", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1133, + "column": 1, + "source_line": "enum" + } + } + ], + "anonymous_id": "enum@stb/stb_voxel_render.h:1133:1", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1133, + "column": 1, + "source_line": "enum" + } + }, + { + "model": "CEnum", + "qualifiers": [], + "source_text": "", + "name": null, + "constants": [ + { + "name": "STBVF_e", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVF_n", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVF_w", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVF_s", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVF_u", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVF_d", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVF_eu", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVF_ed", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVF_eu_wall", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVF_nu_wall", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVF_wu_wall", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVF_su_wall", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVF_ne_u", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVF_ne_d", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVF_nu", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVF_nd", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVF_ed_wall", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVF_nd_wall", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVF_wd_wall", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVF_sd_wall", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVF_nw_u", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVF_nw_d", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVF_wu", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVF_wd", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVF_ne_u_cross", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVF_nw_u_cross", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVF_sw_u_cross", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVF_se_u_cross", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVF_sw_u", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVF_sw_d", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVF_su", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVF_sd", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVF_se_u", + "value": "STBVF_su", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVF_se_d", + "value": "STBVF_sd", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVF_count", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + } + ], + "anonymous_id": "enum@stb/stb_voxel_render.h:1377:1", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + }, + { + "model": "CEnum", + "qualifiers": [], + "source_text": "", + "name": null, + "constants": [ + { + "name": "STBVOX_FT_none", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2146, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVOX_FT_upper", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2146, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVOX_FT_lower", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2146, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVOX_FT_solid", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2146, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVOX_FT_diag_012", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2146, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVOX_FT_diag_023", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2146, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVOX_FT_diag_013", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2146, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVOX_FT_diag_123", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2146, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVOX_FT_force", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2146, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVOX_FT_partial", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2146, + "column": 1, + "source_line": "enum" + } + }, + { + "name": "STBVOX_FT_count", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2146, + "column": 1, + "source_line": "enum" + } + } + ], + "anonymous_id": "enum@stb/stb_voxel_render.h:2146:1", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2146, + "column": 1, + "source_line": "enum" + } + } + ], + "typedefs": [ + { + "reference": "stbvox_mesh_maker" + }, + { + "reference": "stbvox_input_description" + }, + { + "reference": "stbvox_block_type" + }, + { + "reference": "stbvox_rgb" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "stbvox_uint16", + "name": "stbvox_uint16", + "type": { + "model": "CTypedef", + "qualifiers": [], + "source_text": "typedef uint16_t stbvox_uint16", + "name": "uint16_t", + "type": null, + "source_location": null, + "declaration_locations": [] + }, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1225, + "column": 4, + "source_line": " typedef uint16_t stbvox_uint16;" + }, + "declaration_locations": [] + }, + { + "reference": "stbvox_uint32" + }, + { + "reference": "stbvox_mesh_vertex" + }, + { + "reference": "stbvox_mesh_face" + }, + { + "reference": "stbvox_rotate" + }, + { + "reference": "stbvox_pos" + } + ], + "variables": [ + { + "name": "stbvox_default_palette", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "static float stbvox_default_palette[64][4]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "64", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "4", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "storage": [ + "static" + ], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1542, + "column": 1, + "source_line": "static float stbvox_default_palette[64][4];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "stbvox_dummy_transform", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "static float stbvox_dummy_transform[3][3]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "3", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "3", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "storage": [ + "static" + ], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1985, + "column": 1, + "source_line": "static float stbvox_dummy_transform[3][3];" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "macros": [ + { + "name": "INCLUDE_STB_VOXEL_RENDER_H", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 229, + "column": 1, + "source_line": "#define INCLUDE_STB_VOXEL_RENDER_H" + } + }, + { + "name": "STBVXDEC", + "value": "static", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 237, + "column": 1, + "source_line": "#define STBVXDEC static" + } + }, + { + "name": "STBVXDEC", + "value": "extern", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 239, + "column": 1, + "source_line": "#define STBVXDEC extern" + } + }, + { + "name": "STBVOX_COLOR_TEX1_ENABLE", + "value": "64", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 716, + "column": 1, + "source_line": "#define STBVOX_COLOR_TEX1_ENABLE 64" + } + }, + { + "name": "STBVOX_COLOR_TEX2_ENABLE", + "value": "128", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 717, + "column": 1, + "source_line": "#define STBVOX_COLOR_TEX2_ENABLE 128" + } + }, + { + "name": "STBVOX_FACE_NONE", + "value": "7", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1145, + "column": 1, + "source_line": "#define STBVOX_FACE_NONE 7" + } + }, + { + "name": "STBVOX_BLOCKTYPE_EMPTY", + "value": "0", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1147, + "column": 1, + "source_line": "#define STBVOX_BLOCKTYPE_EMPTY 0" + } + }, + { + "name": "STBVOX_BLOCKTYPE_HOLE", + "value": "65535", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1150, + "column": 1, + "source_line": "#define STBVOX_BLOCKTYPE_HOLE 65535" + } + }, + { + "name": "STBVOX_BLOCKTYPE_HOLE", + "value": "255", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1152, + "column": 1, + "source_line": "#define STBVOX_BLOCKTYPE_HOLE 255" + } + }, + { + "name": "STBVOX_MAKE_GEOMETRY", + "value": "((geom) + (rotate)*16 + (vheight)*64)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1155, + "column": 1, + "source_line": "#define STBVOX_MAKE_GEOMETRY(geom, rotate, vheight) ((geom) + (rotate)*16 + (vheight)*64)" + } + }, + { + "name": "STBVOX_MAKE_VHEIGHT", + "value": "((v_sw) + (v_se)*4 + (v_nw)*16 + (v_ne)*64)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1156, + "column": 1, + "source_line": "#define STBVOX_MAKE_VHEIGHT(v_sw, v_se, v_nw, v_ne) ((v_sw) + (v_se)*4 + (v_nw)*16 + (v_ne)*64)" + } + }, + { + "name": "STBVOX_MAKE_MATROT", + "value": "((block) + (overlay)*4 + (color)*64)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1157, + "column": 1, + "source_line": "#define STBVOX_MAKE_MATROT(block, overlay, color) ((block) + (overlay)*4 + (color)*64)" + } + }, + { + "name": "STBVOX_MAKE_TEX2_REPLACE", + "value": "((tex2) + ((tex2_replace_face) & 3)*64)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1158, + "column": 1, + "source_line": "#define STBVOX_MAKE_TEX2_REPLACE(tex2, tex2_replace_face) ((tex2) + ((tex2_replace_face) & 3)*64)" + } + }, + { + "name": "STBVOX_MAKE_TEXLERP", + "value": "((ew2) + (ns2)*4 + (ud2)*16 + (vert)*64)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1159, + "column": 1, + "source_line": "#define STBVOX_MAKE_TEXLERP(ns2, ew2, ud2, vert) ((ew2) + (ns2)*4 + (ud2)*16 + (vert)*64)" + } + }, + { + "name": "STBVOX_MAKE_TEXLERP_SIMPLE", + "value": "((vert)*32 + (face)*4 + (baselerp))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1160, + "column": 1, + "source_line": "#define STBVOX_MAKE_TEXLERP_SIMPLE(baselerp,vert,face) ((vert)*32 + (face)*4 + (baselerp))" + } + }, + { + "name": "STBVOX_MAKE_TEXLERP1", + "value": "STBVOX_MAKE_TEXLERP(s2, w2, d2, vert)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1161, + "column": 1, + "source_line": "#define STBVOX_MAKE_TEXLERP1(vert,e2,n2,w2,s2,u4,d2) STBVOX_MAKE_TEXLERP(s2, w2, d2, vert)" + } + }, + { + "name": "STBVOX_MAKE_TEXLERP2", + "value": "((u2)*16 + (n2)*4 + (s2))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1162, + "column": 1, + "source_line": "#define STBVOX_MAKE_TEXLERP2(vert,e2,n2,w2,s2,u4,d2) ((u2)*16 + (n2)*4 + (s2))" + } + }, + { + "name": "STBVOX_MAKE_FACE_MASK", + "value": "((e)+(n)*2+(w)*4+(s)*8+(u)*16+(d)*32)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1163, + "column": 1, + "source_line": "#define STBVOX_MAKE_FACE_MASK(e,n,w,s,u,d) ((e)+(n)*2+(w)*4+(s)*8+(u)*16+(d)*32)" + } + }, + { + "name": "STBVOX_MAKE_SIDE_TEXROT", + "value": "((e)+(n)*4+(w)*16+(s)*64)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1164, + "column": 1, + "source_line": "#define STBVOX_MAKE_SIDE_TEXROT(e,n,w,s) ((e)+(n)*4+(w)*16+(s)*64)" + } + }, + { + "name": "STBVOX_MAKE_COLOR", + "value": "((color)+(t1)*64+(t2)*128)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1165, + "column": 1, + "source_line": "#define STBVOX_MAKE_COLOR(color,t1,t2) ((color)+(t1)*64+(t2)*128)" + } + }, + { + "name": "STBVOX_MAKE_TEXLERP_VERT3", + "value": "((e)+(n)*8+(w)*64+(s)*512+(u)*4096)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1166, + "column": 1, + "source_line": "#define STBVOX_MAKE_TEXLERP_VERT3(e,n,w,s,u) ((e)+(n)*8+(w)*64+(s)*512+(u)*4096)" + } + }, + { + "name": "STBVOX_MAKE_TEXLERP_FACE3", + "value": "((e)+(n)*8+(w)*64+(s)*512+(u)*4096+(d)*16384)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1167, + "column": 1, + "source_line": "#define STBVOX_MAKE_TEXLERP_FACE3(e,n,w,s,u,d) ((e)+(n)*8+(w)*64+(s)*512+(u)*4096+(d)*16384)" + } + }, + { + "name": "STBVOX_MAKE_PACKED_COMPACT", + "value": "((rot)+4*(vheight)+16*(use)+32*(texlerp))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1168, + "column": 1, + "source_line": "#define STBVOX_MAKE_PACKED_COMPACT(rot, vheight, texlerp, def) ((rot)+4*(vheight)+16*(use)+32*(texlerp))" + } + }, + { + "name": "STBVOX_MAKE_LIGHTING_EXT", + "value": "(((lighting)&~3)+(rot))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1170, + "column": 1, + "source_line": "#define STBVOX_MAKE_LIGHTING_EXT(lighting, rot) (((lighting)&~3)+(rot))" + } + }, + { + "name": "STBVOX_MAKE_LIGHTING", + "value": "(lighting)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1171, + "column": 1, + "source_line": "#define STBVOX_MAKE_LIGHTING(lighting) (lighting)" + } + }, + { + "name": "STBVOX_MAX_MESHES", + "value": "2", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1174, + "column": 1, + "source_line": "#define STBVOX_MAX_MESHES 2 // opaque & transparent" + } + }, + { + "name": "STBVOX_MAX_MESH_SLOTS", + "value": "3", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1177, + "column": 1, + "source_line": "#define STBVOX_MAX_MESH_SLOTS 3 // one vertex & two faces, or two vertex and one face" + } + }, + { + "name": "STBVOX_NOTUSED", + "value": "(void)(v)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1233, + "column": 4, + "source_line": " #define STBVOX_NOTUSED(v) (void)(v)" + } + }, + { + "name": "STBVOX_NOTUSED", + "value": "(void)sizeof(v)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1235, + "column": 4, + "source_line": " #define STBVOX_NOTUSED(v) (void)sizeof(v)" + } + }, + { + "name": "STBVOX_ICONFIG_VERTEX_32", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1294, + "column": 4, + "source_line": " #define STBVOX_ICONFIG_VERTEX_32" + } + }, + { + "name": "STBVOX_ICONFIG_FACE1_1", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1295, + "column": 4, + "source_line": " #define STBVOX_ICONFIG_FACE1_1" + } + }, + { + "name": "STBVOX_ICONFIG_VERTEX_32", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1299, + "column": 4, + "source_line": " #define STBVOX_ICONFIG_VERTEX_32" + } + }, + { + "name": "STBVOX_ICONFIG_FACE1_1", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1300, + "column": 4, + "source_line": " #define STBVOX_ICONFIG_FACE1_1" + } + }, + { + "name": "STBVOX_ICONFIG_UNTEXTURED", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1301, + "column": 4, + "source_line": " #define STBVOX_ICONFIG_UNTEXTURED" + } + }, + { + "name": "STBVOX_ICONFIG_FACE_ATTRIBUTE", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1308, + "column": 1, + "source_line": "#define STBVOX_ICONFIG_FACE_ATTRIBUTE" + } + }, + { + "name": "STBVOX_ICONFIG_GLSL", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1313, + "column": 1, + "source_line": "#define STBVOX_ICONFIG_GLSL" + } + }, + { + "name": "STBVOX_ICONFIG_OPENGL_3_1_COMPATIBILITY", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1317, + "column": 1, + "source_line": "#define STBVOX_ICONFIG_OPENGL_3_1_COMPATIBILITY" + } + }, + { + "name": "stbvox_vertex_encode", + "value": "((stbvox_uint32) ((x)+((y)<<7)+((z)<<14)+((ao)<<23)+((texlerp)<<29)))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1322, + "column": 4, + "source_line": " #define stbvox_vertex_encode(x,y,z,ao,texlerp) \\" + } + }, + { + "name": "stbvox_vertex_encode", + "value": "((stbvox_uint16) ((z)+((ao)<<7)+((texlerp)<<13)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1326, + "column": 4, + "source_line": " #define stbvox_vertex_encode(x,y,z,ao,texlerp) \\" + } + }, + { + "name": "stbvox_vertex_encode", + "value": "((stbvox_uint16) ((x)+((z)<<6))+((ao)<<10))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1330, + "column": 4, + "source_line": " #define stbvox_vertex_encode(x,y,z,ao,texlerp) \\" + } + }, + { + "name": "stbvox_vertex_encode", + "value": "((stbvox_uint8) ((z)+((ao)<<6))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1334, + "column": 4, + "source_line": " #define stbvox_vertex_encode(x,y,z,ao,texlerp) \\" + } + }, + { + "name": "STBVOX_RSQRT2", + "value": "0.7071067811865f", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1452, + "column": 1, + "source_line": "#define STBVOX_RSQRT2 0.7071067811865f" + } + }, + { + "name": "STBVOX_RSQRT3", + "value": "0.5773502691896f", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1453, + "column": 1, + "source_line": "#define STBVOX_RSQRT3 0.5773502691896f" + } + }, + { + "name": "STBVOX_SHADER_VERSION", + "value": "\"#version 150 compatibility\\n\"", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1561, + "column": 4, + "source_line": " #define STBVOX_SHADER_VERSION \"#version 150 compatibility\\n\"" + } + }, + { + "name": "STBVOX_SHADER_VERSION", + "value": "\"#version 130\\n\"", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1563, + "column": 4, + "source_line": " #define STBVOX_SHADER_VERSION \"#version 130\\n\"" + } + }, + { + "name": "STBVOX_SHADER_VERSION", + "value": "\"#version 150\\n\"", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1565, + "column": 4, + "source_line": " #define STBVOX_SHADER_VERSION \"#version 150\\n\"" + } + }, + { + "name": "STBVOX_SHADER_VERSION", + "value": "\"\"", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1567, + "column": 4, + "source_line": " #define STBVOX_SHADER_VERSION \"\"" + } + }, + { + "name": "STBVOX_TEXBUF", + "value": "1", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1988, + "column": 1, + "source_line": "#define STBVOX_TEXBUF 1" + } + }, + { + "name": "STBVOX_TEXBUF", + "value": "0", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1990, + "column": 1, + "source_line": "#define STBVOX_TEXBUF 0" + } + }, + { + "name": "STBVOX_GET_GEO", + "value": "((geom_data) & 15)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2015, + "column": 1, + "source_line": "#define STBVOX_GET_GEO(geom_data) ((geom_data) & 15)" + } + }, + { + "name": "STBVOX_ROTATE", + "value": "stbvox_rotate_face[x][r]", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2040, + "column": 1, + "source_line": "#define STBVOX_ROTATE(x,r) stbvox_rotate_face[x][r] // (((x)+(r))&3)" + } + }, + { + "name": "STBVOX_MAX_GEOM", + "value": "16", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2304, + "column": 1, + "source_line": "#define STBVOX_MAX_GEOM 16" + } + }, + { + "name": "STBVOX_NUM_ROTATION", + "value": "4", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2305, + "column": 1, + "source_line": "#define STBVOX_NUM_ROTATION 4" + } + }, + { + "name": "STBVOX_HEIGHTS", + "value": "{ stbvox_vertex_encode(0,0,a,0,0), stbvox_vertex_encode(0,0,b,0,0), stbvox_vertex_encode(0,0,c,0,0), stbvox_vertex_encode(0,0,d,0,0), stbvox_vertex_encode(0,0,e,0,0), stbvox_vertex_encode(0,0,f,0,0), stbvox_vertex_encode(0,0,g,0,0), stbvox_vertex_encode(0,0,h,0,0) }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2392, + "column": 4, + "source_line": " #define STBVOX_HEIGHTS(a,b,c,d,e,f,g,h) \\" + } + }, + { + "name": "STBVOX_USE_PACKED", + "value": "((f) == STBVOX_FACE_up || (f) == STBVOX_FACE_down)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2686, + "column": 7, + "source_line": " #define STBVOX_USE_PACKED(f) ((f) == STBVOX_FACE_up || (f) == STBVOX_FACE_down)" + } + }, + { + "name": "STBVOX_USE_PACKED", + "value": "((f) == STBVOX_FACE_up )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2688, + "column": 7, + "source_line": " #define STBVOX_USE_PACKED(f) ((f) == STBVOX_FACE_up )" + } + }, + { + "name": "STBVOX_USE_PACKED", + "value": "( (f) == STBVOX_FACE_down)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2690, + "column": 7, + "source_line": " #define STBVOX_USE_PACKED(f) ( (f) == STBVOX_FACE_down)" + } + }, + { + "name": "STBVOX_GET_LIGHTING", + "value": "((light) & ~3)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2790, + "column": 13, + "source_line": " #define STBVOX_GET_LIGHTING(light) ((light) & ~3)" + } + }, + { + "name": "STBVOX_LIGHTING_ROUNDOFF", + "value": "8", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2791, + "column": 13, + "source_line": " #define STBVOX_LIGHTING_ROUNDOFF 8" + } + }, + { + "name": "STBVOX_GET_LIGHTING", + "value": "(light)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2793, + "column": 13, + "source_line": " #define STBVOX_GET_LIGHTING(light) (light)" + } + }, + { + "name": "STBVOX_LIGHTING_ROUNDOFF", + "value": "2", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2794, + "column": 13, + "source_line": " #define STBVOX_LIGHTING_ROUNDOFF 2" + } + }, + { + "name": "STBVOX_CONFIG_PRECISION_Z", + "value": "1", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2890, + "column": 1, + "source_line": "#define STBVOX_CONFIG_PRECISION_Z 1" + } + } + ], + "includes": [ + { + "target": "stdlib.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 231, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "stdlib.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1218, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "assert.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1219, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "string.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1220, + "column": 1, + "source_line": "#include // memset" + } + }, + { + "target": "stdint.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1224, + "column": 4, + "source_line": " #include " + } + } + ], + "raw_directives": [ + { + "directive": "ifndef", + "argument": "INCLUDE_STB_VOXEL_RENDER_H", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 228, + "column": 1, + "source_line": "#ifndef INCLUDE_STB_VOXEL_RENDER_H" + } + }, + { + "directive": "ifdef", + "argument": "STB_VOXEL_RENDER_STATIC", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 236, + "column": 1, + "source_line": "#ifdef STB_VOXEL_RENDER_STATIC" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 238, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 240, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "__cplusplus", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 242, + "column": 1, + "source_line": "#ifdef __cplusplus" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 244, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "0", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 607, + "column": 1, + "source_line": "#if 0" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 653, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "__cplusplus", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 655, + "column": 1, + "source_line": "#ifdef __cplusplus" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 657, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBVOX_CONFIG_BLOCKTYPE_SHORT", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 704, + "column": 1, + "source_line": "#ifdef STBVOX_CONFIG_BLOCKTYPE_SHORT" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 706, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 708, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBVOX_BLOCKTYPE_SHORT", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1149, + "column": 1, + "source_line": "#ifdef STBVOX_BLOCKTYPE_SHORT" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1151, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1153, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBVOX_MAX_MESHES", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1173, + "column": 1, + "source_line": "#ifndef STBVOX_MAX_MESHES" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1175, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1213, + "column": 1, + "source_line": "#endif // INCLUDE_STB_VOXEL_RENDER_H" + } + }, + { + "directive": "ifdef", + "argument": "STB_VOXEL_RENDER_IMPLEMENTATION", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1216, + "column": 1, + "source_line": "#ifdef STB_VOXEL_RENDER_IMPLEMENTATION" + } + }, + { + "directive": "ifndef", + "argument": "_MSC_VER", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1223, + "column": 1, + "source_line": "#ifndef _MSC_VER" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1227, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1230, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "_MSC_VER", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1232, + "column": 1, + "source_line": "#ifdef _MSC_VER" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1234, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1236, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBVOX_CONFIG_MODE", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1240, + "column": 1, + "source_line": "#ifndef STBVOX_CONFIG_MODE" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1242, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "defined(STBVOX_CONFIG_ROTATION_IN_LIGHTING) && defined(STBVOX_CONFIG_VHEIGHT_IN_LIGHTING)", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1244, + "column": 1, + "source_line": "#if defined(STBVOX_CONFIG_ROTATION_IN_LIGHTING) && defined(STBVOX_CONFIG_VHEIGHT_IN_LIGHTING)" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1246, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "STBVOX_CONFIG_MODE==0 || STBVOX_CONFIG_MODE==1", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1292, + "column": 1, + "source_line": "#if STBVOX_CONFIG_MODE==0 || STBVOX_CONFIG_MODE==1" + } + }, + { + "directive": "elif", + "argument": "STBVOX_CONFIG_MODE==20 || STBVOX_CONFIG_MODE==21", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1297, + "column": 1, + "source_line": "#elif STBVOX_CONFIG_MODE==20 || STBVOX_CONFIG_MODE==21" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1303, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1305, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "STBVOX_CONFIG_MODE==0 || STBVOX_CONFIG_MODE==20", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1307, + "column": 1, + "source_line": "#if STBVOX_CONFIG_MODE==0 || STBVOX_CONFIG_MODE==20" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1309, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBVOX_CONFIG_HLSL", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1311, + "column": 1, + "source_line": "#ifndef STBVOX_CONFIG_HLSL" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1314, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBVOX_CONFIG_OPENGL_MODELVIEW", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1316, + "column": 1, + "source_line": "#ifdef STBVOX_CONFIG_OPENGL_MODELVIEW" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1318, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "defined(STBVOX_ICONFIG_VERTEX_32)", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1320, + "column": 1, + "source_line": "#if defined(STBVOX_ICONFIG_VERTEX_32)" + } + }, + { + "directive": "elif", + "argument": "defined(STBVOX_ICONFIG_VERTEX_16_1)", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1324, + "column": 1, + "source_line": "#elif defined(STBVOX_ICONFIG_VERTEX_16_1) // mode=2" + } + }, + { + "directive": "elif", + "argument": "defined(STBVOX_ICONFIG_VERTEX_16_2)", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1328, + "column": 1, + "source_line": "#elif defined(STBVOX_ICONFIG_VERTEX_16_2) // mode=3" + } + }, + { + "directive": "elif", + "argument": "defined(STBVOX_ICONFIG_VERTEX_8)", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1332, + "column": 1, + "source_line": "#elif defined(STBVOX_ICONFIG_VERTEX_8)" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1336, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1338, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBVOX_ICONFIG_FACE1_1", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1340, + "column": 1, + "source_line": "#ifdef STBVOX_ICONFIG_FACE1_1" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1345, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1347, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "if", + "argument": "defined(STBVOX_ICONFIG_OPENGL_3_1_COMPATIBILITY)", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1560, + "column": 1, + "source_line": "#if defined(STBVOX_ICONFIG_OPENGL_3_1_COMPATIBILITY)" + } + }, + { + "directive": "elif", + "argument": "defined(STBVOX_ICONFIG_OPENGL_3_0)", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1562, + "column": 1, + "source_line": "#elif defined(STBVOX_ICONFIG_OPENGL_3_0)" + } + }, + { + "directive": "elif", + "argument": "defined(STBVOX_ICONFIG_GLSL)", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1564, + "column": 1, + "source_line": "#elif defined(STBVOX_ICONFIG_GLSL)" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1566, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1568, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBVOX_ICONFIG_FACE_ATTRIBUTE", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1574, + "column": 4, + "source_line": " #ifdef STBVOX_ICONFIG_FACE_ATTRIBUTE // NOT TAG_face_sampled" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1576, + "column": 4, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1578, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "STBVOX_ICONFIG_FACE_ARRAY_2", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1580, + "column": 4, + "source_line": " #ifdef STBVOX_ICONFIG_FACE_ARRAY_2" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1582, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STBVOX_CONFIG_OPENGL_MODELVIEW", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1598, + "column": 7, + "source_line": " #ifndef STBVOX_CONFIG_OPENGL_MODELVIEW" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1600, + "column": 7, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "STBVOX_ICONFIG_FACE_ATTRIBUTE", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1612, + "column": 7, + "source_line": " #ifdef STBVOX_ICONFIG_FACE_ATTRIBUTE" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1614, + "column": 7, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1617, + "column": 7, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "STBVOX_DEBUG_TEST_NORMALS", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1631, + "column": 7, + "source_line": " #ifdef STBVOX_DEBUG_TEST_NORMALS" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1634, + "column": 7, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STBVOX_CONFIG_OPENGL_MODELVIEW", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1636, + "column": 7, + "source_line": " #ifndef STBVOX_CONFIG_OPENGL_MODELVIEW" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1638, + "column": 7, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1640, + "column": 7, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "defined(STBVOX_ICONFIG_GLSL)", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1651, + "column": 7, + "source_line": " #if defined(STBVOX_ICONFIG_GLSL)" + } + }, + { + "directive": "elif", + "argument": "defined(STBVOX_CONFIG_HLSL)", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1653, + "column": 7, + "source_line": " #elif defined(STBVOX_CONFIG_HLSL)" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1655, + "column": 7, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1657, + "column": 7, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STBVOX_ICONFIG_UNTEXTURED", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1676, + "column": 7, + "source_line": " #ifndef STBVOX_ICONFIG_UNTEXTURED" + } + }, + { + "directive": "ifdef", + "argument": "STBVOX_CONFIG_PREFER_TEXBUFFER", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1680, + "column": 10, + "source_line": " #ifdef STBVOX_CONFIG_PREFER_TEXBUFFER" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1684, + "column": 10, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1688, + "column": 10, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1689, + "column": 7, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "defined(STBVOX_CONFIG_LIGHTING) || defined(STBVOX_CONFIG_LIGHTING_SIMPLE)", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1693, + "column": 7, + "source_line": " #if defined(STBVOX_CONFIG_LIGHTING) || defined(STBVOX_CONFIG_LIGHTING_SIMPLE)" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1695, + "column": 7, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "defined(STBVOX_CONFIG_FOG) || defined(STBVOX_CONFIG_FOG_SMOOTHSTEP)", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1696, + "column": 7, + "source_line": " #if defined(STBVOX_CONFIG_FOG) || defined(STBVOX_CONFIG_FOG_SMOOTHSTEP)" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1698, + "column": 7, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STBVOX_ICONFIG_UNTEXTURED", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1705, + "column": 7, + "source_line": " #ifndef STBVOX_ICONFIG_UNTEXTURED" + } + }, + { + "directive": "ifndef", + "argument": "STBVOX_CONFIG_PREFER_TEXBUFFER", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1712, + "column": 10, + "source_line": " #ifndef STBVOX_CONFIG_PREFER_TEXBUFFER" + } + }, + { + "directive": "ifndef", + "argument": "STBVOX_CONFIG_DISABLE_TEX2", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1718, + "column": 13, + "source_line": " #ifndef STBVOX_CONFIG_DISABLE_TEX2" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1720, + "column": 13, + "source_line": " #endif" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1721, + "column": 10, + "source_line": " #else" + } + }, + { + "directive": "ifndef", + "argument": "STBVOX_CONFIG_DISABLE_TEX2", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1726, + "column": 13, + "source_line": " #ifndef STBVOX_CONFIG_DISABLE_TEX2" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1728, + "column": 13, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1729, + "column": 10, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STBVOX_CONFIG_DISABLE_TEX2", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1731, + "column": 10, + "source_line": " #ifndef STBVOX_CONFIG_DISABLE_TEX2" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1734, + "column": 10, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STBVOX_CONFIG_DISABLE_TEX2", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1741, + "column": 10, + "source_line": " #ifndef STBVOX_CONFIG_DISABLE_TEX2" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1743, + "column": 10, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "STBVOX_CONFIG_TEX1_EDGE_CLAMP", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1745, + "column": 10, + "source_line": " #ifdef STBVOX_CONFIG_TEX1_EDGE_CLAMP" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1748, + "column": 10, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1750, + "column": 10, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STBVOX_CONFIG_DISABLE_TEX2", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1752, + "column": 10, + "source_line": " #ifndef STBVOX_CONFIG_DISABLE_TEX2" + } + }, + { + "directive": "ifdef", + "argument": "STBVOX_CONFIG_TEX2_EDGE_CLAMP", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1753, + "column": 10, + "source_line": " #ifdef STBVOX_CONFIG_TEX2_EDGE_CLAMP" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1756, + "column": 10, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1758, + "column": 10, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1759, + "column": 10, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STBVOX_CONFIG_DISABLE_TEX2", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1767, + "column": 10, + "source_line": " #ifndef STBVOX_CONFIG_DISABLE_TEX2" + } + }, + { + "directive": "ifdef", + "argument": "STBVOX_CONFIG_PREMULTIPLIED_ALPHA", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1770, + "column": 13, + "source_line": " #ifdef STBVOX_CONFIG_PREMULTIPLIED_ALPHA" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1772, + "column": 13, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1774, + "column": 13, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "STBVOX_CONFIG_PREMULTIPLIED_ALPHA", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1779, + "column": 13, + "source_line": " #ifdef STBVOX_CONFIG_PREMULTIPLIED_ALPHA" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1781, + "column": 13, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1783, + "column": 13, + "source_line": " #endif" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1786, + "column": 10, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1788, + "column": 10, + "source_line": " #endif" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1790, + "column": 7, + "source_line": " #else // UNTEXTURED" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1796, + "column": 7, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "STBVOX_ICONFIG_VARYING_VERTEX_NORMALS", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1798, + "column": 7, + "source_line": " #ifdef STBVOX_ICONFIG_VARYING_VERTEX_NORMALS" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1802, + "column": 7, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1804, + "column": 7, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "defined(STBVOX_ICONFIG_LIGHTING) || defined(STBVOX_CONFIG_LIGHTING_SIMPLE)", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1813, + "column": 7, + "source_line": " #if defined(STBVOX_ICONFIG_LIGHTING) || defined(STBVOX_CONFIG_LIGHTING_SIMPLE)" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1815, + "column": 7, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1817, + "column": 7, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "defined(STBVOX_ICONFIG_FOG) || defined(STBVOX_CONFIG_FOG_SMOOTHSTEP)", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1821, + "column": 7, + "source_line": " #if defined(STBVOX_ICONFIG_FOG) || defined(STBVOX_CONFIG_FOG_SMOOTHSTEP)" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1824, + "column": 7, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "STBVOX_CONFIG_UNPREMULTIPLY", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1826, + "column": 7, + "source_line": " #ifdef STBVOX_CONFIG_UNPREMULTIPLY" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1828, + "column": 7, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1830, + "column": 7, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "STBVOX_CONFIG_LIGHTING_SIMPLE", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1834, + "column": 4, + "source_line": " #ifdef STBVOX_CONFIG_LIGHTING_SIMPLE" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1844, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "STBVOX_CONFIG_FOG_SMOOTHSTEP", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1846, + "column": 4, + "source_line": " #ifdef STBVOX_CONFIG_FOG_SMOOTHSTEP" + } + }, + { + "directive": "ifdef", + "argument": "STBVOX_CONFIG_PREMULTIPLIED_ALPHA", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1855, + "column": 7, + "source_line": " #ifdef STBVOX_CONFIG_PREMULTIPLIED_ALPHA" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1857, + "column": 7, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1859, + "column": 7, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1861, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STBVOX_ICONFIG_UNTEXTURED", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1878, + "column": 4, + "source_line": " #ifndef STBVOX_ICONFIG_UNTEXTURED" + } + }, + { + "directive": "ifdef", + "argument": "STBVOX_CONFIG_PREFER_TEXBUFFER", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1882, + "column": 7, + "source_line": " #ifdef STBVOX_CONFIG_PREFER_TEXBUFFER" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1885, + "column": 7, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1888, + "column": 7, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1889, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STBVOX_ICONFIG_UNTEXTURED", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1898, + "column": 4, + "source_line": " #ifndef STBVOX_ICONFIG_UNTEXTURED" + } + }, + { + "directive": "ifndef", + "argument": "STBVOX_CONFIG_PREFER_TEXBUFFER", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1905, + "column": 7, + "source_line": " #ifndef STBVOX_CONFIG_PREFER_TEXBUFFER" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1912, + "column": 7, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1918, + "column": 7, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STBVOX_CONFIG_DISABLE_TEX2", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1920, + "column": 7, + "source_line": " #ifndef STBVOX_CONFIG_DISABLE_TEX2" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1923, + "column": 7, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "STBVOX_CONFIG_TEX1_EDGE_CLAMP", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1935, + "column": 7, + "source_line": " #ifdef STBVOX_CONFIG_TEX1_EDGE_CLAMP" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1938, + "column": 7, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1940, + "column": 7, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STBVOX_CONFIG_DISABLE_TEX2", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1945, + "column": 7, + "source_line": " #ifndef STBVOX_CONFIG_DISABLE_TEX2" + } + }, + { + "directive": "ifdef", + "argument": "STBVOX_CONFIG_TEX2_EDGE_CLAMP", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1947, + "column": 10, + "source_line": " #ifdef STBVOX_CONFIG_TEX2_EDGE_CLAMP" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1950, + "column": 10, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1952, + "column": 10, + "source_line": " #endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1959, + "column": 7, + "source_line": " #endif" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1961, + "column": 4, + "source_line": " #else // UNTEXTURED" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1963, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "STBVOX_CONFIG_PREFER_TEXBUFFER", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1987, + "column": 1, + "source_line": "#ifdef STBVOX_CONFIG_PREFER_TEXBUFFER" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1989, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1991, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBVOX_ICONFIG_UNTEXTURED", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2049, + "column": 4, + "source_line": " #ifdef STBVOX_ICONFIG_UNTEXTURED" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2057, + "column": 4, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2139, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "STBVOX_CONFIG_OPTIMIZED_VHEIGHT", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2425, + "column": 1, + "source_line": "#ifdef STBVOX_CONFIG_OPTIMIZED_VHEIGHT" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2519, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2649, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBVOX_ICONFIG_FACE_ATTRIBUTE", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2664, + "column": 4, + "source_line": " #ifdef STBVOX_ICONFIG_FACE_ATTRIBUTE" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2670, + "column": 4, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2673, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "defined(STBVOX_CONFIG_DOWN_TEXLERP_PACKED) && defined(STBVOX_CONFIG_UP_TEXLERP_PACKED)", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2685, + "column": 4, + "source_line": " #if defined(STBVOX_CONFIG_DOWN_TEXLERP_PACKED) && defined(STBVOX_CONFIG_UP_TEXLERP_PACKED)" + } + }, + { + "directive": "elif", + "argument": "defined(STBVOX_CONFIG_UP_TEXLERP_PACKED)", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2687, + "column": 4, + "source_line": " #elif defined(STBVOX_CONFIG_UP_TEXLERP_PACKED)" + } + }, + { + "directive": "elif", + "argument": "defined(STBVOX_CONFIG_DOWN_TEXLERP_PACKED)", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2689, + "column": 4, + "source_line": " #elif defined(STBVOX_CONFIG_DOWN_TEXLERP_PACKED)" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2691, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "defined(STBVOX_CONFIG_DOWN_TEXLERP_PACKED) || defined(STBVOX_CONFIG_UP_TEXLERP_PACKED)", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2693, + "column": 4, + "source_line": " #if defined(STBVOX_CONFIG_DOWN_TEXLERP_PACKED) || defined(STBVOX_CONFIG_UP_TEXLERP_PACKED)" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2707, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "defined(STBVOX_CONFIG_UP_TEXLERP_PACKED) || defined(STBVOX_CONFIG_DOWN_TEXLERP_PACKED)", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2762, + "column": 7, + "source_line": " #if defined(STBVOX_CONFIG_UP_TEXLERP_PACKED) || defined(STBVOX_CONFIG_DOWN_TEXLERP_PACKED)" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2764, + "column": 7, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "defined(STBVOX_CONFIG_UP_TEXLERP_PACKED) || defined(STBVOX_CONFIG_DOWN_TEXLERP_PACKED)", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2768, + "column": 4, + "source_line": " #if defined(STBVOX_CONFIG_UP_TEXLERP_PACKED) || defined(STBVOX_CONFIG_DOWN_TEXLERP_PACKED)" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2770, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "defined(STBVOX_CONFIG_ROTATION_IN_LIGHTING) || defined(STBVOX_CONFIG_VHEIGHT_IN_LIGHTING)", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2789, + "column": 13, + "source_line": " #if defined(STBVOX_CONFIG_ROTATION_IN_LIGHTING) || defined(STBVOX_CONFIG_VHEIGHT_IN_LIGHTING)" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2792, + "column": 13, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2795, + "column": 13, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STBVOX_CONFIG_OPTIMIZED_VHEIGHT", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2841, + "column": 1, + "source_line": "#ifndef STBVOX_CONFIG_OPTIMIZED_VHEIGHT" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2887, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "STBVOX_CONFIG_PRECISION_Z", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2889, + "column": 1, + "source_line": "#ifndef STBVOX_CONFIG_PRECISION_Z" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2891, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "STBVOX_CONFIG_ROTATION_IN_LIGHTING", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2918, + "column": 4, + "source_line": " #ifdef STBVOX_CONFIG_ROTATION_IN_LIGHTING" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2920, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STBVOX_CONFIG_ROTATION_IN_LIGHTING", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 3006, + "column": 10, + "source_line": " #ifndef STBVOX_CONFIG_ROTATION_IN_LIGHTING" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 3016, + "column": 10, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STBVOX_CONFIG_ROTATION_IN_LIGHTING", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 3018, + "column": 10, + "source_line": " #ifndef STBVOX_CONFIG_ROTATION_IN_LIGHTING" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 3027, + "column": 10, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STBVOX_CONFIG_ROTATION_IN_LIGHTING", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 3031, + "column": 4, + "source_line": " #ifndef STBVOX_CONFIG_ROTATION_IN_LIGHTING" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 3041, + "column": 4, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 3049, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "STBVOX_CONFIG_VHEIGHT_IN_LIGHTING", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 3210, + "column": 7, + "source_line": " #ifdef STBVOX_CONFIG_VHEIGHT_IN_LIGHTING" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 3215, + "column": 7, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 3247, + "column": 7, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STBVOX_CONFIG_OPTIMIZED_VHEIGHT", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 3299, + "column": 10, + "source_line": " #ifndef STBVOX_CONFIG_OPTIMIZED_VHEIGHT" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 3309, + "column": 10, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 3311, + "column": 10, + "source_line": " #endif" + } + }, + { + "directive": "ifndef", + "argument": "STBVOX_CONFIG_OPTIMIZED_VHEIGHT", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 3319, + "column": 10, + "source_line": " #ifndef STBVOX_CONFIG_OPTIMIZED_VHEIGHT" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 3329, + "column": 10, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 3331, + "column": 10, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "STBVOX_CONFIG_PRECISION_Z == 1", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 3448, + "column": 7, + "source_line": " #if STBVOX_CONFIG_PRECISION_Z == 1" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 3450, + "column": 7, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 3452, + "column": 7, + "source_line": " #endif" + } + }, + { + "directive": "ifdef", + "argument": "STBVOX_ICONFIG_FACE_ATTRIBUTE", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 3471, + "column": 7, + "source_line": " #ifdef STBVOX_ICONFIG_FACE_ATTRIBUTE" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 3477, + "column": 7, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 3485, + "column": 7, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "STBVOX_CONFIG_PRECISION_Z==1", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 3603, + "column": 4, + "source_line": " #if STBVOX_CONFIG_PRECISION_Z==1" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 3605, + "column": 4, + "source_line": " #else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 3607, + "column": 4, + "source_line": " #endif" + } + }, + { + "directive": "if", + "argument": "0", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 3657, + "column": 1, + "source_line": "#if 0" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 3703, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 3765, + "column": 1, + "source_line": "#endif // STB_VOXEL_RENDER_IMPLEMENTATION" + } + } + ], + "macro_dependencies": [ + { + "name": "STBVXDEC", + "context": "declaration", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1970, + "column": 1, + "source_line": "STBVXDEC char *stbvox_get_vertex_shader(void)" + }, + "source_text": "STBVXDEC char *stbvox_get_vertex_shader(void)" + }, + { + "name": "STBVXDEC", + "context": "declaration", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1975, + "column": 1, + "source_line": "STBVXDEC char *stbvox_get_fragment_shader(void)" + }, + "source_text": "STBVXDEC char *stbvox_get_fragment_shader(void)" + }, + { + "name": "STBVXDEC", + "context": "declaration", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1980, + "column": 1, + "source_line": "STBVXDEC char *stbvox_get_fragment_shader_alpha_only(void)" + }, + "source_text": "STBVXDEC char *stbvox_get_fragment_shader_alpha_only(void)" + }, + { + "name": "STBVXDEC", + "context": "declaration", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2006, + "column": 1, + "source_line": "STBVXDEC int stbvox_get_uniform_info(stbvox_uniform_info *info, int uniform)" + }, + "source_text": "STBVXDEC int stbvox_get_uniform_info(stbvox_uniform_info *info, int uniform)" + } + ], + "diagnostics": [ + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBVOX_MAKE_GEOMETRY' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1155, + "column": 1, + "source_line": "#define STBVOX_MAKE_GEOMETRY(geom, rotate, vheight) ((geom) + (rotate)*16 + (vheight)*64)" + }, + "unit_kind": "macro", + "unit_name": "STBVOX_MAKE_GEOMETRY" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBVOX_MAKE_VHEIGHT' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1156, + "column": 1, + "source_line": "#define STBVOX_MAKE_VHEIGHT(v_sw, v_se, v_nw, v_ne) ((v_sw) + (v_se)*4 + (v_nw)*16 + (v_ne)*64)" + }, + "unit_kind": "macro", + "unit_name": "STBVOX_MAKE_VHEIGHT" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBVOX_MAKE_MATROT' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1157, + "column": 1, + "source_line": "#define STBVOX_MAKE_MATROT(block, overlay, color) ((block) + (overlay)*4 + (color)*64)" + }, + "unit_kind": "macro", + "unit_name": "STBVOX_MAKE_MATROT" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBVOX_MAKE_TEX2_REPLACE' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1158, + "column": 1, + "source_line": "#define STBVOX_MAKE_TEX2_REPLACE(tex2, tex2_replace_face) ((tex2) + ((tex2_replace_face) & 3)*64)" + }, + "unit_kind": "macro", + "unit_name": "STBVOX_MAKE_TEX2_REPLACE" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBVOX_MAKE_TEXLERP' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1159, + "column": 1, + "source_line": "#define STBVOX_MAKE_TEXLERP(ns2, ew2, ud2, vert) ((ew2) + (ns2)*4 + (ud2)*16 + (vert)*64)" + }, + "unit_kind": "macro", + "unit_name": "STBVOX_MAKE_TEXLERP" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBVOX_MAKE_TEXLERP_SIMPLE' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1160, + "column": 1, + "source_line": "#define STBVOX_MAKE_TEXLERP_SIMPLE(baselerp,vert,face) ((vert)*32 + (face)*4 + (baselerp))" + }, + "unit_kind": "macro", + "unit_name": "STBVOX_MAKE_TEXLERP_SIMPLE" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBVOX_MAKE_TEXLERP1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1161, + "column": 1, + "source_line": "#define STBVOX_MAKE_TEXLERP1(vert,e2,n2,w2,s2,u4,d2) STBVOX_MAKE_TEXLERP(s2, w2, d2, vert)" + }, + "unit_kind": "macro", + "unit_name": "STBVOX_MAKE_TEXLERP1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBVOX_MAKE_TEXLERP2' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1162, + "column": 1, + "source_line": "#define STBVOX_MAKE_TEXLERP2(vert,e2,n2,w2,s2,u4,d2) ((u2)*16 + (n2)*4 + (s2))" + }, + "unit_kind": "macro", + "unit_name": "STBVOX_MAKE_TEXLERP2" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBVOX_MAKE_FACE_MASK' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1163, + "column": 1, + "source_line": "#define STBVOX_MAKE_FACE_MASK(e,n,w,s,u,d) ((e)+(n)*2+(w)*4+(s)*8+(u)*16+(d)*32)" + }, + "unit_kind": "macro", + "unit_name": "STBVOX_MAKE_FACE_MASK" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBVOX_MAKE_SIDE_TEXROT' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1164, + "column": 1, + "source_line": "#define STBVOX_MAKE_SIDE_TEXROT(e,n,w,s) ((e)+(n)*4+(w)*16+(s)*64)" + }, + "unit_kind": "macro", + "unit_name": "STBVOX_MAKE_SIDE_TEXROT" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBVOX_MAKE_COLOR' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1165, + "column": 1, + "source_line": "#define STBVOX_MAKE_COLOR(color,t1,t2) ((color)+(t1)*64+(t2)*128)" + }, + "unit_kind": "macro", + "unit_name": "STBVOX_MAKE_COLOR" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBVOX_MAKE_TEXLERP_VERT3' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1166, + "column": 1, + "source_line": "#define STBVOX_MAKE_TEXLERP_VERT3(e,n,w,s,u) ((e)+(n)*8+(w)*64+(s)*512+(u)*4096)" + }, + "unit_kind": "macro", + "unit_name": "STBVOX_MAKE_TEXLERP_VERT3" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBVOX_MAKE_TEXLERP_FACE3' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1167, + "column": 1, + "source_line": "#define STBVOX_MAKE_TEXLERP_FACE3(e,n,w,s,u,d) ((e)+(n)*8+(w)*64+(s)*512+(u)*4096+(d)*16384)" + }, + "unit_kind": "macro", + "unit_name": "STBVOX_MAKE_TEXLERP_FACE3" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBVOX_MAKE_PACKED_COMPACT' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1168, + "column": 1, + "source_line": "#define STBVOX_MAKE_PACKED_COMPACT(rot, vheight, texlerp, def) ((rot)+4*(vheight)+16*(use)+32*(texlerp))" + }, + "unit_kind": "macro", + "unit_name": "STBVOX_MAKE_PACKED_COMPACT" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBVOX_MAKE_LIGHTING_EXT' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1170, + "column": 1, + "source_line": "#define STBVOX_MAKE_LIGHTING_EXT(lighting, rot) (((lighting)&~3)+(rot))" + }, + "unit_kind": "macro", + "unit_name": "STBVOX_MAKE_LIGHTING_EXT" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBVOX_MAKE_LIGHTING' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1171, + "column": 1, + "source_line": "#define STBVOX_MAKE_LIGHTING(lighting) (lighting)" + }, + "unit_kind": "macro", + "unit_name": "STBVOX_MAKE_LIGHTING" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBVOX_NOTUSED' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1233, + "column": 4, + "source_line": " #define STBVOX_NOTUSED(v) (void)(v)" + }, + "unit_kind": "macro", + "unit_name": "STBVOX_NOTUSED" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBVOX_NOTUSED' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1235, + "column": 4, + "source_line": " #define STBVOX_NOTUSED(v) (void)sizeof(v)" + }, + "unit_kind": "macro", + "unit_name": "STBVOX_NOTUSED" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbvox_vertex_encode' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1322, + "column": 4, + "source_line": " #define stbvox_vertex_encode(x,y,z,ao,texlerp) \\" + }, + "unit_kind": "macro", + "unit_name": "stbvox_vertex_encode" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbvox_vertex_encode' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1326, + "column": 4, + "source_line": " #define stbvox_vertex_encode(x,y,z,ao,texlerp) \\" + }, + "unit_kind": "macro", + "unit_name": "stbvox_vertex_encode" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbvox_vertex_encode' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1330, + "column": 4, + "source_line": " #define stbvox_vertex_encode(x,y,z,ao,texlerp) \\" + }, + "unit_kind": "macro", + "unit_name": "stbvox_vertex_encode" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbvox_vertex_encode' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1334, + "column": 4, + "source_line": " #define stbvox_vertex_encode(x,y,z,ao,texlerp) \\" + }, + "unit_kind": "macro", + "unit_name": "stbvox_vertex_encode" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBVOX_GET_GEO' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2015, + "column": 1, + "source_line": "#define STBVOX_GET_GEO(geom_data) ((geom_data) & 15)" + }, + "unit_kind": "macro", + "unit_name": "STBVOX_GET_GEO" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBVOX_ROTATE' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2040, + "column": 1, + "source_line": "#define STBVOX_ROTATE(x,r) stbvox_rotate_face[x][r] // (((x)+(r))&3)" + }, + "unit_kind": "macro", + "unit_name": "STBVOX_ROTATE" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBVOX_HEIGHTS' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2392, + "column": 4, + "source_line": " #define STBVOX_HEIGHTS(a,b,c,d,e,f,g,h) \\" + }, + "unit_kind": "macro", + "unit_name": "STBVOX_HEIGHTS" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBVOX_USE_PACKED' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2686, + "column": 7, + "source_line": " #define STBVOX_USE_PACKED(f) ((f) == STBVOX_FACE_up || (f) == STBVOX_FACE_down)" + }, + "unit_kind": "macro", + "unit_name": "STBVOX_USE_PACKED" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBVOX_USE_PACKED' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2688, + "column": 7, + "source_line": " #define STBVOX_USE_PACKED(f) ((f) == STBVOX_FACE_up )" + }, + "unit_kind": "macro", + "unit_name": "STBVOX_USE_PACKED" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBVOX_USE_PACKED' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2690, + "column": 7, + "source_line": " #define STBVOX_USE_PACKED(f) ( (f) == STBVOX_FACE_down)" + }, + "unit_kind": "macro", + "unit_name": "STBVOX_USE_PACKED" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBVOX_GET_LIGHTING' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2790, + "column": 13, + "source_line": " #define STBVOX_GET_LIGHTING(light) ((light) & ~3)" + }, + "unit_kind": "macro", + "unit_name": "STBVOX_GET_LIGHTING" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBVOX_GET_LIGHTING' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2793, + "column": 13, + "source_line": " #define STBVOX_GET_LIGHTING(light) (light)" + }, + "unit_kind": "macro", + "unit_name": "STBVOX_GET_LIGHTING" + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '\"C\"'.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 243, + "column": 1, + "source_line": "extern \"C\" {" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1428, + "column": 1, + "source_line": "static float stbvox_default_texgen[2][32][3] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1455, + "column": 1, + "source_line": "static float stbvox_default_normals[32][3] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1494, + "column": 1, + "source_line": "static float stbvox_default_texscale[128][4] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1514, + "column": 1, + "source_line": "static unsigned char stbvox_default_palette_compact[64][3] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1534, + "column": 1, + "source_line": "static float stbvox_default_ambient[4][4] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1570, + "column": 1, + "source_line": "static const char *stbvox_vertex_program =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1646, + "column": 1, + "source_line": "static const char *stbvox_fragment_program =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1866, + "column": 1, + "source_line": "static const char *stbvox_fragment_program_alpha_only =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBVXDEC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1970, + "column": 1, + "source_line": "STBVXDEC char *stbvox_get_vertex_shader(void)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBVXDEC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBVXDEC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1975, + "column": 1, + "source_line": "STBVXDEC char *stbvox_get_fragment_shader(void)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBVXDEC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBVXDEC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1980, + "column": 1, + "source_line": "STBVXDEC char *stbvox_get_fragment_shader_alpha_only(void)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBVXDEC" + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1993, + "column": 1, + "source_line": "static stbvox_uniform_info stbvox_uniforms[] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBVXDEC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2006, + "column": 1, + "source_line": "STBVXDEC int stbvox_get_uniform_info(stbvox_uniform_info *info, int uniform)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBVXDEC" + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2030, + "column": 1, + "source_line": "static unsigned char stbvox_rotate_face[6][4] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2162, + "column": 1, + "source_line": "static unsigned char stbvox_face_lerp[6] = { 0,2,0,2,4,4 };" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2163, + "column": 1, + "source_line": "static unsigned char stbvox_vert3_lerp[5] = { 0,3,6,9,12 };" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2164, + "column": 1, + "source_line": "static unsigned char stbvox_vert_lerp_for_face_lerp[4] = { 0, 4, 7, 7 };" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2165, + "column": 1, + "source_line": "static unsigned char stbvox_face3_lerp[6] = { 0,3,6,9,12,14 };" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2166, + "column": 1, + "source_line": "static unsigned char stbvox_vert_lerp_for_simple[4] = { 0,2,5,7 };" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2167, + "column": 1, + "source_line": "static unsigned char stbvox_face3_updown[8] = { 0,2,5,7,0,2,5,7 }; // ignore top bit" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2170, + "column": 1, + "source_line": "static unsigned char stbvox_vertex_vector[6][4][3] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2181, + "column": 1, + "source_line": "static unsigned char stbvox_vertex_selector[6][4] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2191, + "column": 1, + "source_line": "static stbvox_mesh_vertex stbvox_vmesh_delta_normal[6][4] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2219, + "column": 1, + "source_line": "static stbvox_mesh_vertex stbvox_vmesh_pre_vheight[6][4] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2247, + "column": 1, + "source_line": "static stbvox_mesh_vertex stbvox_vmesh_delta_half_z[6][4] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2275, + "column": 1, + "source_line": "static stbvox_mesh_vertex stbvox_vmesh_crossed_pair[6][4] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2308, + "column": 1, + "source_line": "static unsigned char stbvox_hasface[STBVOX_MAX_GEOM][STBVOX_NUM_ROTATION] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2329, + "column": 1, + "source_line": "static unsigned char stbvox_facetype[STBVOX_GEOM_count][6] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2354, + "column": 1, + "source_line": "static unsigned char stbvox_floor_slope_for_rot[4] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2362, + "column": 1, + "source_line": "static unsigned char stbvox_ceil_slope_for_rot[4] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2372, + "column": 1, + "source_line": "static unsigned short stbvox_face_visible[STBVOX_FT_count] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2390, + "column": 1, + "source_line": "static stbvox_mesh_vertex stbvox_geometry_vheight[8][8] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2413, + "column": 1, + "source_line": "static unsigned char stbvox_rotate_vertex[8][4] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2427, + "column": 1, + "source_line": "static unsigned char stbvox_optimized_face_up_normal[4][4][4][4] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2523, + "column": 1, + "source_line": "static unsigned char stbvox_planar_face_up_normal[4][4][4] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2550, + "column": 1, + "source_line": "static unsigned char stbvox_face_up_normal_012[4][4][4] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2575, + "column": 1, + "source_line": "static unsigned char stbvox_face_up_normal_013[4][4][4] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2600, + "column": 1, + "source_line": "static unsigned char stbvox_face_up_normal_023[4][4][4] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2625, + "column": 1, + "source_line": "static unsigned char stbvox_face_up_normal_123[4][4][4] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2833, + "column": 1, + "source_line": "static unsigned char stbvox_reverse_face[STBVF_count] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 3659, + "column": 1, + "source_line": "static char *normal_names[32] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_CONFLICTING_TYPEDEF", + "message": "Conflicting typedef declarations for 'stbvox_block_type'.", + "severity": "error", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 707, + "column": 1, + "source_line": "typedef unsigned char stbvox_block_type;" + }, + "unit_kind": "typedef", + "unit_name": "stbvox_block_type" + }, + { + "code": "C_CONFLICTING_TYPEDEF", + "message": "Conflicting typedef declarations for 'stbvox_uint16'.", + "severity": "error", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1228, + "column": 4, + "source_line": " typedef unsigned short stbvox_uint16;" + }, + "unit_kind": "typedef", + "unit_name": "stbvox_uint16" + }, + { + "code": "C_CONFLICTING_TYPEDEF", + "message": "Conflicting typedef declarations for 'stbvox_uint32'.", + "severity": "error", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1229, + "column": 4, + "source_line": " typedef unsigned int stbvox_uint32;" + }, + "unit_kind": "typedef", + "unit_name": "stbvox_uint32" + }, + { + "code": "C_CONFLICTING_TYPEDEF", + "message": "Conflicting typedef declarations for 'stbvox_mesh_vertex'.", + "severity": "error", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1325, + "column": 4, + "source_line": " typedef stbvox_uint16 stbvox_mesh_vertex;" + }, + "unit_kind": "typedef", + "unit_name": "stbvox_mesh_vertex" + }, + { + "code": "C_CONFLICTING_TYPEDEF", + "message": "Conflicting typedef declarations for 'stbvox_mesh_vertex'.", + "severity": "error", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1329, + "column": 4, + "source_line": " typedef stbvox_uint16 stbvox_mesh_vertex;" + }, + "unit_kind": "typedef", + "unit_name": "stbvox_mesh_vertex" + }, + { + "code": "C_CONFLICTING_TYPEDEF", + "message": "Conflicting typedef declarations for 'stbvox_mesh_vertex'.", + "severity": "error", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1333, + "column": 4, + "source_line": " typedef stbvox_uint8 stbvox_mesh_vertex;" + }, + "unit_kind": "typedef", + "unit_name": "stbvox_mesh_vertex" + } + ] + } + }, + "functions": { + "stbvox_build_default_palette": { + "name": "stbvox_build_default_palette", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1544, + "column": 1, + "source_line": "static void stbvox_build_default_palette(void)" + }, + "start": { + "filename": "stb/stb_voxel_render.h", + "line": 1544, + "column": 1, + "source_line": "static void stbvox_build_default_palette(void)" + }, + "end": { + "filename": "stb/stb_voxel_render.h", + "line": 1553, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbvox_compute_mesh_face_value": { + "name": "stbvox_compute_mesh_face_value", + "result_type": { + "reference": "stbvox_mesh_face" + }, + "parameters": [ + { + "name": "mm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "rot", + "type": { + "reference": "stbvox_rotate" + }, + "declared_type": { + "reference": "stbvox_rotate" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "face", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int face" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int face" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "v_off", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v_off" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v_off" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "normal", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int normal" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int normal" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2042, + "column": 1, + "source_line": "stbvox_mesh_face stbvox_compute_mesh_face_value(stbvox_mesh_maker *mm, stbvox_rotate rot, int face, int v_off, int normal)" + }, + "start": { + "filename": "stb/stb_voxel_render.h", + "line": 2042, + "column": 1, + "source_line": "stbvox_mesh_face stbvox_compute_mesh_face_value(stbvox_mesh_maker *mm, stbvox_rotate rot, int face, int v_off, int normal)" + }, + "end": { + "filename": "stb/stb_voxel_render.h", + "line": 2143, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbvox_get_quad_vertex_pointer": { + "name": "stbvox_get_quad_vertex_pointer", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "mm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mesh", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mesh" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mesh" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "vertices", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_vertex **vertices", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_vertex" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_vertex **vertices", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_vertex" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "face", + "type": { + "reference": "stbvox_mesh_face" + }, + "declared_type": { + "reference": "stbvox_mesh_face" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2651, + "column": 1, + "source_line": "void stbvox_get_quad_vertex_pointer(stbvox_mesh_maker *mm, int mesh, stbvox_mesh_vertex **vertices, stbvox_mesh_face face)" + }, + "start": { + "filename": "stb/stb_voxel_render.h", + "line": 2651, + "column": 1, + "source_line": "void stbvox_get_quad_vertex_pointer(stbvox_mesh_maker *mm, int mesh, stbvox_mesh_vertex **vertices, stbvox_mesh_face face)" + }, + "end": { + "filename": "stb/stb_voxel_render.h", + "line": 2674, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbvox_make_mesh_for_face": { + "name": "stbvox_make_mesh_for_face", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "mm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "rot", + "type": { + "reference": "stbvox_rotate" + }, + "declared_type": { + "reference": "stbvox_rotate" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "face", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int face" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int face" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "v_off", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v_off" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v_off" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "pos", + "type": { + "reference": "stbvox_pos" + }, + "declared_type": { + "reference": "stbvox_pos" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "vertbase", + "type": { + "reference": "stbvox_mesh_vertex" + }, + "declared_type": { + "reference": "stbvox_mesh_vertex" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "face_coord", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_vertex *face_coord", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_vertex" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_vertex *face_coord", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_vertex" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mesh", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char mesh" + }, + "declared_type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char mesh" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "normal", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int normal" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int normal" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2676, + "column": 1, + "source_line": "void stbvox_make_mesh_for_face(stbvox_mesh_maker *mm, stbvox_rotate rot, int face, int v_off, stbvox_pos pos, stbvox_mesh_vertex vertbase, stbvox_mesh_vertex *face_coord, unsigned char mesh, int normal)" + }, + "start": { + "filename": "stb/stb_voxel_render.h", + "line": 2676, + "column": 1, + "source_line": "void stbvox_make_mesh_for_face(stbvox_mesh_maker *mm, stbvox_rotate rot, int face, int v_off, stbvox_pos pos, stbvox_mesh_vertex vertbase, stbvox_mesh_vertex *face_coord, unsigned char mesh, int normal)" + }, + "end": { + "filename": "stb/stb_voxel_render.h", + "line": 2830, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbvox_make_12_split_mesh_for_face": { + "name": "stbvox_make_12_split_mesh_for_face", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "mm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "rot", + "type": { + "reference": "stbvox_rotate" + }, + "declared_type": { + "reference": "stbvox_rotate" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "face", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int face" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int face" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "v_off", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v_off" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v_off" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "pos", + "type": { + "reference": "stbvox_pos" + }, + "declared_type": { + "reference": "stbvox_pos" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "vertbase", + "type": { + "reference": "stbvox_mesh_vertex" + }, + "declared_type": { + "reference": "stbvox_mesh_vertex" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "face_coord", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_vertex *face_coord", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_vertex" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_vertex *face_coord", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_vertex" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mesh", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char mesh" + }, + "declared_type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char mesh" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ht", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *ht", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *ht", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2843, + "column": 1, + "source_line": "static void stbvox_make_12_split_mesh_for_face(stbvox_mesh_maker *mm, stbvox_rotate rot, int face, int v_off, stbvox_pos pos, stbvox_mesh_vertex vertbase, stbvox_mesh_vertex *face_coord, unsigned char mesh, unsigned char *ht)" + }, + "start": { + "filename": "stb/stb_voxel_render.h", + "line": 2843, + "column": 1, + "source_line": "static void stbvox_make_12_split_mesh_for_face(stbvox_mesh_maker *mm, stbvox_rotate rot, int face, int v_off, stbvox_pos pos, stbvox_mesh_vertex vertbase, stbvox_mesh_vertex *face_coord, unsigned char mesh, unsigned char *ht)" + }, + "end": { + "filename": "stb/stb_voxel_render.h", + "line": 2864, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbvox_make_03_split_mesh_for_face": { + "name": "stbvox_make_03_split_mesh_for_face", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "mm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "rot", + "type": { + "reference": "stbvox_rotate" + }, + "declared_type": { + "reference": "stbvox_rotate" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "face", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int face" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int face" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "v_off", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v_off" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v_off" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "pos", + "type": { + "reference": "stbvox_pos" + }, + "declared_type": { + "reference": "stbvox_pos" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "vertbase", + "type": { + "reference": "stbvox_mesh_vertex" + }, + "declared_type": { + "reference": "stbvox_mesh_vertex" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "face_coord", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_vertex *face_coord", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_vertex" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_vertex *face_coord", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_vertex" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mesh", + "type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char mesh" + }, + "declared_type": { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char mesh" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "ht", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *ht", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "unsigned char *ht", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CUnsignedChar", + "qualifiers": [], + "source_text": "unsigned char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2866, + "column": 1, + "source_line": "static void stbvox_make_03_split_mesh_for_face(stbvox_mesh_maker *mm, stbvox_rotate rot, int face, int v_off, stbvox_pos pos, stbvox_mesh_vertex vertbase, stbvox_mesh_vertex *face_coord, unsigned char mesh, unsigned char *ht)" + }, + "start": { + "filename": "stb/stb_voxel_render.h", + "line": 2866, + "column": 1, + "source_line": "static void stbvox_make_03_split_mesh_for_face(stbvox_mesh_maker *mm, stbvox_rotate rot, int face, int v_off, stbvox_pos pos, stbvox_mesh_vertex vertbase, stbvox_mesh_vertex *face_coord, unsigned char mesh, unsigned char *ht)" + }, + "end": { + "filename": "stb/stb_voxel_render.h", + "line": 2886, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbvox_make_mesh_for_block": { + "name": "stbvox_make_mesh_for_block", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "mm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "pos", + "type": { + "reference": "stbvox_pos" + }, + "declared_type": { + "reference": "stbvox_pos" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "v_off", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v_off" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v_off" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "vmesh", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_vertex *vmesh", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_vertex" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_vertex *vmesh", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_vertex" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2894, + "column": 1, + "source_line": "static void stbvox_make_mesh_for_block(stbvox_mesh_maker *mm, stbvox_pos pos, int v_off, stbvox_mesh_vertex *vmesh)" + }, + "start": { + "filename": "stb/stb_voxel_render.h", + "line": 2894, + "column": 1, + "source_line": "static void stbvox_make_mesh_for_block(stbvox_mesh_maker *mm, stbvox_pos pos, int v_off, stbvox_mesh_vertex *vmesh)" + }, + "end": { + "filename": "stb/stb_voxel_render.h", + "line": 2953, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbvox_make_mesh_for_block_with_geo": { + "name": "stbvox_make_mesh_for_block_with_geo", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "mm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "pos", + "type": { + "reference": "stbvox_pos" + }, + "declared_type": { + "reference": "stbvox_pos" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "v_off", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v_off" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int v_off" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2963, + "column": 1, + "source_line": "static void stbvox_make_mesh_for_block_with_geo(stbvox_mesh_maker *mm, stbvox_pos pos, int v_off)" + }, + "start": { + "filename": "stb/stb_voxel_render.h", + "line": 2963, + "column": 1, + "source_line": "static void stbvox_make_mesh_for_block_with_geo(stbvox_mesh_maker *mm, stbvox_pos pos, int v_off)" + }, + "end": { + "filename": "stb/stb_voxel_render.h", + "line": 3397, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbvox_make_mesh_for_column": { + "name": "stbvox_make_mesh_for_column", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "mm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "z0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int z0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int z0" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 3399, + "column": 1, + "source_line": "static void stbvox_make_mesh_for_column(stbvox_mesh_maker *mm, int x, int y, int z0)" + }, + "start": { + "filename": "stb/stb_voxel_render.h", + "line": 3399, + "column": 1, + "source_line": "static void stbvox_make_mesh_for_column(stbvox_mesh_maker *mm, int x, int y, int z0)" + }, + "end": { + "filename": "stb/stb_voxel_render.h", + "line": 3465, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbvox_bring_up_to_date": { + "name": "stbvox_bring_up_to_date", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "mm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 3467, + "column": 1, + "source_line": "static void stbvox_bring_up_to_date(stbvox_mesh_maker *mm)" + }, + "start": { + "filename": "stb/stb_voxel_render.h", + "line": 3467, + "column": 1, + "source_line": "static void stbvox_bring_up_to_date(stbvox_mesh_maker *mm)" + }, + "end": { + "filename": "stb/stb_voxel_render.h", + "line": 3489, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbvox_make_mesh": { + "name": "stbvox_make_mesh", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "mm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 3491, + "column": 1, + "source_line": "int stbvox_make_mesh(stbvox_mesh_maker *mm)" + }, + "start": { + "filename": "stb/stb_voxel_render.h", + "line": 3491, + "column": 1, + "source_line": "int stbvox_make_mesh(stbvox_mesh_maker *mm)" + }, + "end": { + "filename": "stb/stb_voxel_render.h", + "line": 3520, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbvox_init_mesh_maker": { + "name": "stbvox_init_mesh_maker", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "mm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 3522, + "column": 1, + "source_line": "void stbvox_init_mesh_maker(stbvox_mesh_maker *mm)" + }, + "start": { + "filename": "stb/stb_voxel_render.h", + "line": 3522, + "column": 1, + "source_line": "void stbvox_init_mesh_maker(stbvox_mesh_maker *mm)" + }, + "end": { + "filename": "stb/stb_voxel_render.h", + "line": 3529, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbvox_get_buffer_count": { + "name": "stbvox_get_buffer_count", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "mm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 3531, + "column": 1, + "source_line": "int stbvox_get_buffer_count(stbvox_mesh_maker *mm)" + }, + "start": { + "filename": "stb/stb_voxel_render.h", + "line": 3531, + "column": 1, + "source_line": "int stbvox_get_buffer_count(stbvox_mesh_maker *mm)" + }, + "end": { + "filename": "stb/stb_voxel_render.h", + "line": 3535, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbvox_get_buffer_size_per_quad": { + "name": "stbvox_get_buffer_size_per_quad", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "mm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "n", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int n" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 3537, + "column": 1, + "source_line": "int stbvox_get_buffer_size_per_quad(stbvox_mesh_maker *mm, int n)" + }, + "start": { + "filename": "stb/stb_voxel_render.h", + "line": 3537, + "column": 1, + "source_line": "int stbvox_get_buffer_size_per_quad(stbvox_mesh_maker *mm, int n)" + }, + "end": { + "filename": "stb/stb_voxel_render.h", + "line": 3540, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbvox_reset_buffers": { + "name": "stbvox_reset_buffers", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "mm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 3542, + "column": 1, + "source_line": "void stbvox_reset_buffers(stbvox_mesh_maker *mm)" + }, + "start": { + "filename": "stb/stb_voxel_render.h", + "line": 3542, + "column": 1, + "source_line": "void stbvox_reset_buffers(stbvox_mesh_maker *mm)" + }, + "end": { + "filename": "stb/stb_voxel_render.h", + "line": 3549, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbvox_set_buffer": { + "name": "stbvox_set_buffer", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "mm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mesh", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mesh" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mesh" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "slot", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int slot" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int slot" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "buffer", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *buffer", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "reference": "size_t" + }, + "declared_type": { + "reference": "size_t" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 3551, + "column": 1, + "source_line": "void stbvox_set_buffer(stbvox_mesh_maker *mm, int mesh, int slot, void *buffer, size_t len)" + }, + "start": { + "filename": "stb/stb_voxel_render.h", + "line": 3551, + "column": 1, + "source_line": "void stbvox_set_buffer(stbvox_mesh_maker *mm, int mesh, int slot, void *buffer, size_t len)" + }, + "end": { + "filename": "stb/stb_voxel_render.h", + "line": 3564, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbvox_set_default_mesh": { + "name": "stbvox_set_default_mesh", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "mm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mesh", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mesh" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mesh" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 3566, + "column": 1, + "source_line": "void stbvox_set_default_mesh(stbvox_mesh_maker *mm, int mesh)" + }, + "start": { + "filename": "stb/stb_voxel_render.h", + "line": 3566, + "column": 1, + "source_line": "void stbvox_set_default_mesh(stbvox_mesh_maker *mm, int mesh)" + }, + "end": { + "filename": "stb/stb_voxel_render.h", + "line": 3569, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbvox_get_quad_count": { + "name": "stbvox_get_quad_count", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "mm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "mesh", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mesh" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int mesh" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 3571, + "column": 1, + "source_line": "int stbvox_get_quad_count(stbvox_mesh_maker *mm, int mesh)" + }, + "start": { + "filename": "stb/stb_voxel_render.h", + "line": 3571, + "column": 1, + "source_line": "int stbvox_get_quad_count(stbvox_mesh_maker *mm, int mesh)" + }, + "end": { + "filename": "stb/stb_voxel_render.h", + "line": 3574, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbvox_get_input_description": { + "name": "stbvox_get_input_description", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_input_description", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_input_description" + } + ] + }, + "parameters": [ + { + "name": "mm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 3576, + "column": 1, + "source_line": "stbvox_input_description *stbvox_get_input_description(stbvox_mesh_maker *mm)" + }, + "start": { + "filename": "stb/stb_voxel_render.h", + "line": 3576, + "column": 1, + "source_line": "stbvox_input_description *stbvox_get_input_description(stbvox_mesh_maker *mm)" + }, + "end": { + "filename": "stb/stb_voxel_render.h", + "line": 3579, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbvox_set_input_range": { + "name": "stbvox_set_input_range", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "mm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "z0", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int z0" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int z0" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y1" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "z1", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int z1" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int z1" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 3581, + "column": 1, + "source_line": "void stbvox_set_input_range(stbvox_mesh_maker *mm, int x0, int y0, int z0, int x1, int y1, int z1)" + }, + "start": { + "filename": "stb/stb_voxel_render.h", + "line": 3581, + "column": 1, + "source_line": "void stbvox_set_input_range(stbvox_mesh_maker *mm, int x0, int y0, int z0, int x1, int y1, int z1)" + }, + "end": { + "filename": "stb/stb_voxel_render.h", + "line": 3596, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbvox_get_transform": { + "name": "stbvox_get_transform", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "mm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "transform", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float transform[3][3]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "3", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float transform[3][3]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "3", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "3", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 3598, + "column": 1, + "source_line": "void stbvox_get_transform(stbvox_mesh_maker *mm, float transform[3][3])" + }, + "start": { + "filename": "stb/stb_voxel_render.h", + "line": 3598, + "column": 1, + "source_line": "void stbvox_get_transform(stbvox_mesh_maker *mm, float transform[3][3])" + }, + "end": { + "filename": "stb/stb_voxel_render.h", + "line": 3616, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbvox_get_bounds": { + "name": "stbvox_get_bounds", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "mm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "bounds", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float bounds[2][3]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "3", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "float bounds[2][3]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "2", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "3", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 3618, + "column": 1, + "source_line": "void stbvox_get_bounds(stbvox_mesh_maker *mm, float bounds[2][3])" + }, + "start": { + "filename": "stb/stb_voxel_render.h", + "line": 3618, + "column": 1, + "source_line": "void stbvox_get_bounds(stbvox_mesh_maker *mm, float bounds[2][3])" + }, + "end": { + "filename": "stb/stb_voxel_render.h", + "line": 3626, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbvox_set_mesh_coordinates": { + "name": "stbvox_set_mesh_coordinates", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "mm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "z", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int z" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int z" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 3628, + "column": 1, + "source_line": "void stbvox_set_mesh_coordinates(stbvox_mesh_maker *mm, int x, int y, int z)" + }, + "start": { + "filename": "stb/stb_voxel_render.h", + "line": 3628, + "column": 1, + "source_line": "void stbvox_set_mesh_coordinates(stbvox_mesh_maker *mm, int x, int y, int z)" + }, + "end": { + "filename": "stb/stb_voxel_render.h", + "line": 3633, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "stbvox_set_input_stride": { + "name": "stbvox_set_input_stride", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "mm", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "stbvox_mesh_maker *mm", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "stbvox_mesh_maker" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "x_stride_in_bytes", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x_stride_in_bytes" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int x_stride_in_bytes" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y_stride_in_bytes", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y_stride_in_bytes" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int y_stride_in_bytes" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 3635, + "column": 1, + "source_line": "void stbvox_set_input_stride(stbvox_mesh_maker *mm, int x_stride_in_bytes, int y_stride_in_bytes)" + }, + "start": { + "filename": "stb/stb_voxel_render.h", + "line": 3635, + "column": 1, + "source_line": "void stbvox_set_input_stride(stbvox_mesh_maker *mm, int x_stride_in_bytes, int y_stride_in_bytes)" + }, + "end": { + "filename": "stb/stb_voxel_render.h", + "line": 3650, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "find_best_normal": { + "name": "find_best_normal", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "parameters": [ + { + "name": "x", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float x" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "y", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float y" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "z", + "type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float z" + }, + "declared_type": { + "model": "CFloat", + "qualifiers": [], + "source_text": "float z" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 3667, + "column": 1, + "source_line": "static char *find_best_normal(float x, float y, float z)" + }, + "start": { + "filename": "stb/stb_voxel_render.h", + "line": 3667, + "column": 1, + "source_line": "static char *find_best_normal(float x, float y, float z)" + }, + "end": { + "filename": "stb/stb_voxel_render.h", + "line": 3682, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "main": { + "name": "main", + "result_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + }, + "parameters": [ + { + "name": "argc", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int argc" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int argc" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "argv", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char **argv", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "char **argv", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [], + "source_text": "char" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 3684, + "column": 1, + "source_line": "int main(int argc, char **argv)" + }, + "start": { + "filename": "stb/stb_voxel_render.h", + "line": 3684, + "column": 1, + "source_line": "int main(int argc, char **argv)" + }, + "end": { + "filename": "stb/stb_voxel_render.h", + "line": 3702, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + } + }, + "structs": { + "stbvox_input_description": { + "reference": "struct stbvox_input_description" + }, + "stbvox_mesh_maker": { + "reference": "struct stbvox_mesh_maker" + } + }, + "unions": {}, + "enums": {}, + "typedefs": { + "stbvox_mesh_maker": { + "reference": "stbvox_mesh_maker" + }, + "stbvox_input_description": { + "reference": "stbvox_input_description" + }, + "stbvox_block_type": { + "reference": "stbvox_block_type" + }, + "stbvox_rgb": { + "reference": "stbvox_rgb" + }, + "stbvox_uint16": { + "reference": "stbvox_uint16" + }, + "stbvox_uint32": { + "reference": "stbvox_uint32" + }, + "stbvox_mesh_vertex": { + "reference": "stbvox_mesh_vertex" + }, + "stbvox_mesh_face": { + "reference": "stbvox_mesh_face" + }, + "stbvox_rotate": { + "reference": "stbvox_rotate" + }, + "stbvox_pos": { + "reference": "stbvox_pos" + } + }, + "variables": { + "stbvox_default_palette": { + "name": "stbvox_default_palette", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "static float stbvox_default_palette[64][4]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "64", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "4", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "storage": [ + "static" + ], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1542, + "column": 1, + "source_line": "static float stbvox_default_palette[64][4];" + }, + "callback_policy": null, + "declaration_locations": [] + }, + "stbvox_dummy_transform": { + "name": "stbvox_dummy_transform", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "static float stbvox_dummy_transform[3][3]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "3", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": "3", + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CFloat", + "qualifiers": [], + "source_text": "float" + } + ] + }, + "storage": [ + "static" + ], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1985, + "column": 1, + "source_line": "static float stbvox_dummy_transform[3][3];" + }, + "callback_policy": null, + "declaration_locations": [] + } + }, + "macros": { + "INCLUDE_STB_VOXEL_RENDER_H": { + "name": "INCLUDE_STB_VOXEL_RENDER_H", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 229, + "column": 1, + "source_line": "#define INCLUDE_STB_VOXEL_RENDER_H" + } + }, + "STBVXDEC": { + "name": "STBVXDEC", + "value": "extern", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 239, + "column": 1, + "source_line": "#define STBVXDEC extern" + } + }, + "STBVOX_COLOR_TEX1_ENABLE": { + "name": "STBVOX_COLOR_TEX1_ENABLE", + "value": "64", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 716, + "column": 1, + "source_line": "#define STBVOX_COLOR_TEX1_ENABLE 64" + } + }, + "STBVOX_COLOR_TEX2_ENABLE": { + "name": "STBVOX_COLOR_TEX2_ENABLE", + "value": "128", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 717, + "column": 1, + "source_line": "#define STBVOX_COLOR_TEX2_ENABLE 128" + } + }, + "STBVOX_FACE_NONE": { + "name": "STBVOX_FACE_NONE", + "value": "7", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1145, + "column": 1, + "source_line": "#define STBVOX_FACE_NONE 7" + } + }, + "STBVOX_BLOCKTYPE_EMPTY": { + "name": "STBVOX_BLOCKTYPE_EMPTY", + "value": "0", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1147, + "column": 1, + "source_line": "#define STBVOX_BLOCKTYPE_EMPTY 0" + } + }, + "STBVOX_BLOCKTYPE_HOLE": { + "name": "STBVOX_BLOCKTYPE_HOLE", + "value": "255", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1152, + "column": 1, + "source_line": "#define STBVOX_BLOCKTYPE_HOLE 255" + } + }, + "STBVOX_MAKE_GEOMETRY": { + "name": "STBVOX_MAKE_GEOMETRY", + "value": "((geom) + (rotate)*16 + (vheight)*64)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1155, + "column": 1, + "source_line": "#define STBVOX_MAKE_GEOMETRY(geom, rotate, vheight) ((geom) + (rotate)*16 + (vheight)*64)" + } + }, + "STBVOX_MAKE_VHEIGHT": { + "name": "STBVOX_MAKE_VHEIGHT", + "value": "((v_sw) + (v_se)*4 + (v_nw)*16 + (v_ne)*64)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1156, + "column": 1, + "source_line": "#define STBVOX_MAKE_VHEIGHT(v_sw, v_se, v_nw, v_ne) ((v_sw) + (v_se)*4 + (v_nw)*16 + (v_ne)*64)" + } + }, + "STBVOX_MAKE_MATROT": { + "name": "STBVOX_MAKE_MATROT", + "value": "((block) + (overlay)*4 + (color)*64)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1157, + "column": 1, + "source_line": "#define STBVOX_MAKE_MATROT(block, overlay, color) ((block) + (overlay)*4 + (color)*64)" + } + }, + "STBVOX_MAKE_TEX2_REPLACE": { + "name": "STBVOX_MAKE_TEX2_REPLACE", + "value": "((tex2) + ((tex2_replace_face) & 3)*64)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1158, + "column": 1, + "source_line": "#define STBVOX_MAKE_TEX2_REPLACE(tex2, tex2_replace_face) ((tex2) + ((tex2_replace_face) & 3)*64)" + } + }, + "STBVOX_MAKE_TEXLERP": { + "name": "STBVOX_MAKE_TEXLERP", + "value": "((ew2) + (ns2)*4 + (ud2)*16 + (vert)*64)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1159, + "column": 1, + "source_line": "#define STBVOX_MAKE_TEXLERP(ns2, ew2, ud2, vert) ((ew2) + (ns2)*4 + (ud2)*16 + (vert)*64)" + } + }, + "STBVOX_MAKE_TEXLERP_SIMPLE": { + "name": "STBVOX_MAKE_TEXLERP_SIMPLE", + "value": "((vert)*32 + (face)*4 + (baselerp))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1160, + "column": 1, + "source_line": "#define STBVOX_MAKE_TEXLERP_SIMPLE(baselerp,vert,face) ((vert)*32 + (face)*4 + (baselerp))" + } + }, + "STBVOX_MAKE_TEXLERP1": { + "name": "STBVOX_MAKE_TEXLERP1", + "value": "STBVOX_MAKE_TEXLERP(s2, w2, d2, vert)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1161, + "column": 1, + "source_line": "#define STBVOX_MAKE_TEXLERP1(vert,e2,n2,w2,s2,u4,d2) STBVOX_MAKE_TEXLERP(s2, w2, d2, vert)" + } + }, + "STBVOX_MAKE_TEXLERP2": { + "name": "STBVOX_MAKE_TEXLERP2", + "value": "((u2)*16 + (n2)*4 + (s2))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1162, + "column": 1, + "source_line": "#define STBVOX_MAKE_TEXLERP2(vert,e2,n2,w2,s2,u4,d2) ((u2)*16 + (n2)*4 + (s2))" + } + }, + "STBVOX_MAKE_FACE_MASK": { + "name": "STBVOX_MAKE_FACE_MASK", + "value": "((e)+(n)*2+(w)*4+(s)*8+(u)*16+(d)*32)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1163, + "column": 1, + "source_line": "#define STBVOX_MAKE_FACE_MASK(e,n,w,s,u,d) ((e)+(n)*2+(w)*4+(s)*8+(u)*16+(d)*32)" + } + }, + "STBVOX_MAKE_SIDE_TEXROT": { + "name": "STBVOX_MAKE_SIDE_TEXROT", + "value": "((e)+(n)*4+(w)*16+(s)*64)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1164, + "column": 1, + "source_line": "#define STBVOX_MAKE_SIDE_TEXROT(e,n,w,s) ((e)+(n)*4+(w)*16+(s)*64)" + } + }, + "STBVOX_MAKE_COLOR": { + "name": "STBVOX_MAKE_COLOR", + "value": "((color)+(t1)*64+(t2)*128)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1165, + "column": 1, + "source_line": "#define STBVOX_MAKE_COLOR(color,t1,t2) ((color)+(t1)*64+(t2)*128)" + } + }, + "STBVOX_MAKE_TEXLERP_VERT3": { + "name": "STBVOX_MAKE_TEXLERP_VERT3", + "value": "((e)+(n)*8+(w)*64+(s)*512+(u)*4096)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1166, + "column": 1, + "source_line": "#define STBVOX_MAKE_TEXLERP_VERT3(e,n,w,s,u) ((e)+(n)*8+(w)*64+(s)*512+(u)*4096)" + } + }, + "STBVOX_MAKE_TEXLERP_FACE3": { + "name": "STBVOX_MAKE_TEXLERP_FACE3", + "value": "((e)+(n)*8+(w)*64+(s)*512+(u)*4096+(d)*16384)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1167, + "column": 1, + "source_line": "#define STBVOX_MAKE_TEXLERP_FACE3(e,n,w,s,u,d) ((e)+(n)*8+(w)*64+(s)*512+(u)*4096+(d)*16384)" + } + }, + "STBVOX_MAKE_PACKED_COMPACT": { + "name": "STBVOX_MAKE_PACKED_COMPACT", + "value": "((rot)+4*(vheight)+16*(use)+32*(texlerp))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1168, + "column": 1, + "source_line": "#define STBVOX_MAKE_PACKED_COMPACT(rot, vheight, texlerp, def) ((rot)+4*(vheight)+16*(use)+32*(texlerp))" + } + }, + "STBVOX_MAKE_LIGHTING_EXT": { + "name": "STBVOX_MAKE_LIGHTING_EXT", + "value": "(((lighting)&~3)+(rot))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1170, + "column": 1, + "source_line": "#define STBVOX_MAKE_LIGHTING_EXT(lighting, rot) (((lighting)&~3)+(rot))" + } + }, + "STBVOX_MAKE_LIGHTING": { + "name": "STBVOX_MAKE_LIGHTING", + "value": "(lighting)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1171, + "column": 1, + "source_line": "#define STBVOX_MAKE_LIGHTING(lighting) (lighting)" + } + }, + "STBVOX_MAX_MESHES": { + "name": "STBVOX_MAX_MESHES", + "value": "2", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1174, + "column": 1, + "source_line": "#define STBVOX_MAX_MESHES 2 // opaque & transparent" + } + }, + "STBVOX_MAX_MESH_SLOTS": { + "name": "STBVOX_MAX_MESH_SLOTS", + "value": "3", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1177, + "column": 1, + "source_line": "#define STBVOX_MAX_MESH_SLOTS 3 // one vertex & two faces, or two vertex and one face" + } + }, + "STBVOX_NOTUSED": { + "name": "STBVOX_NOTUSED", + "value": "(void)sizeof(v)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1235, + "column": 4, + "source_line": " #define STBVOX_NOTUSED(v) (void)sizeof(v)" + } + }, + "STBVOX_ICONFIG_VERTEX_32": { + "name": "STBVOX_ICONFIG_VERTEX_32", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1299, + "column": 4, + "source_line": " #define STBVOX_ICONFIG_VERTEX_32" + } + }, + "STBVOX_ICONFIG_FACE1_1": { + "name": "STBVOX_ICONFIG_FACE1_1", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1300, + "column": 4, + "source_line": " #define STBVOX_ICONFIG_FACE1_1" + } + }, + "STBVOX_ICONFIG_UNTEXTURED": { + "name": "STBVOX_ICONFIG_UNTEXTURED", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1301, + "column": 4, + "source_line": " #define STBVOX_ICONFIG_UNTEXTURED" + } + }, + "STBVOX_ICONFIG_FACE_ATTRIBUTE": { + "name": "STBVOX_ICONFIG_FACE_ATTRIBUTE", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1308, + "column": 1, + "source_line": "#define STBVOX_ICONFIG_FACE_ATTRIBUTE" + } + }, + "STBVOX_ICONFIG_GLSL": { + "name": "STBVOX_ICONFIG_GLSL", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1313, + "column": 1, + "source_line": "#define STBVOX_ICONFIG_GLSL" + } + }, + "STBVOX_ICONFIG_OPENGL_3_1_COMPATIBILITY": { + "name": "STBVOX_ICONFIG_OPENGL_3_1_COMPATIBILITY", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1317, + "column": 1, + "source_line": "#define STBVOX_ICONFIG_OPENGL_3_1_COMPATIBILITY" + } + }, + "stbvox_vertex_encode": { + "name": "stbvox_vertex_encode", + "value": "((stbvox_uint8) ((z)+((ao)<<6))", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1334, + "column": 4, + "source_line": " #define stbvox_vertex_encode(x,y,z,ao,texlerp) \\" + } + }, + "STBVOX_RSQRT2": { + "name": "STBVOX_RSQRT2", + "value": "0.7071067811865f", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1452, + "column": 1, + "source_line": "#define STBVOX_RSQRT2 0.7071067811865f" + } + }, + "STBVOX_RSQRT3": { + "name": "STBVOX_RSQRT3", + "value": "0.5773502691896f", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1453, + "column": 1, + "source_line": "#define STBVOX_RSQRT3 0.5773502691896f" + } + }, + "STBVOX_SHADER_VERSION": { + "name": "STBVOX_SHADER_VERSION", + "value": "\"\"", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1567, + "column": 4, + "source_line": " #define STBVOX_SHADER_VERSION \"\"" + } + }, + "STBVOX_TEXBUF": { + "name": "STBVOX_TEXBUF", + "value": "0", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1990, + "column": 1, + "source_line": "#define STBVOX_TEXBUF 0" + } + }, + "STBVOX_GET_GEO": { + "name": "STBVOX_GET_GEO", + "value": "((geom_data) & 15)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2015, + "column": 1, + "source_line": "#define STBVOX_GET_GEO(geom_data) ((geom_data) & 15)" + } + }, + "STBVOX_ROTATE": { + "name": "STBVOX_ROTATE", + "value": "stbvox_rotate_face[x][r]", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2040, + "column": 1, + "source_line": "#define STBVOX_ROTATE(x,r) stbvox_rotate_face[x][r] // (((x)+(r))&3)" + } + }, + "STBVOX_MAX_GEOM": { + "name": "STBVOX_MAX_GEOM", + "value": "16", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2304, + "column": 1, + "source_line": "#define STBVOX_MAX_GEOM 16" + } + }, + "STBVOX_NUM_ROTATION": { + "name": "STBVOX_NUM_ROTATION", + "value": "4", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2305, + "column": 1, + "source_line": "#define STBVOX_NUM_ROTATION 4" + } + }, + "STBVOX_HEIGHTS": { + "name": "STBVOX_HEIGHTS", + "value": "{ stbvox_vertex_encode(0,0,a,0,0), stbvox_vertex_encode(0,0,b,0,0), stbvox_vertex_encode(0,0,c,0,0), stbvox_vertex_encode(0,0,d,0,0), stbvox_vertex_encode(0,0,e,0,0), stbvox_vertex_encode(0,0,f,0,0), stbvox_vertex_encode(0,0,g,0,0), stbvox_vertex_encode(0,0,h,0,0) }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2392, + "column": 4, + "source_line": " #define STBVOX_HEIGHTS(a,b,c,d,e,f,g,h) \\" + } + }, + "STBVOX_USE_PACKED": { + "name": "STBVOX_USE_PACKED", + "value": "( (f) == STBVOX_FACE_down)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2690, + "column": 7, + "source_line": " #define STBVOX_USE_PACKED(f) ( (f) == STBVOX_FACE_down)" + } + }, + "STBVOX_GET_LIGHTING": { + "name": "STBVOX_GET_LIGHTING", + "value": "(light)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2793, + "column": 13, + "source_line": " #define STBVOX_GET_LIGHTING(light) (light)" + } + }, + "STBVOX_LIGHTING_ROUNDOFF": { + "name": "STBVOX_LIGHTING_ROUNDOFF", + "value": "2", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2794, + "column": 13, + "source_line": " #define STBVOX_LIGHTING_ROUNDOFF 2" + } + }, + "STBVOX_CONFIG_PRECISION_Z": { + "name": "STBVOX_CONFIG_PRECISION_Z", + "value": "1", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2890, + "column": 1, + "source_line": "#define STBVOX_CONFIG_PRECISION_Z 1" + } + } + }, + "includes": { + "stb/stb_voxel_render.h:stdlib.h": { + "target": "stdlib.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1218, + "column": 1, + "source_line": "#include " + } + }, + "stb/stb_voxel_render.h:assert.h": { + "target": "assert.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1219, + "column": 1, + "source_line": "#include " + } + }, + "stb/stb_voxel_render.h:string.h": { + "target": "string.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1220, + "column": 1, + "source_line": "#include // memset" + } + }, + "stb/stb_voxel_render.h:stdint.h": { + "target": "stdint.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1224, + "column": 4, + "source_line": " #include " + } + } + }, + "functions_by_file": { + "stb/stb_voxel_render.h": [ + "stbvox_build_default_palette", + "stbvox_compute_mesh_face_value", + "stbvox_get_quad_vertex_pointer", + "stbvox_make_mesh_for_face", + "stbvox_make_12_split_mesh_for_face", + "stbvox_make_03_split_mesh_for_face", + "stbvox_make_mesh_for_block", + "stbvox_make_mesh_for_block_with_geo", + "stbvox_make_mesh_for_column", + "stbvox_bring_up_to_date", + "stbvox_make_mesh", + "stbvox_init_mesh_maker", + "stbvox_get_buffer_count", + "stbvox_get_buffer_size_per_quad", + "stbvox_reset_buffers", + "stbvox_set_buffer", + "stbvox_set_default_mesh", + "stbvox_get_quad_count", + "stbvox_get_input_description", + "stbvox_set_input_range", + "stbvox_get_transform", + "stbvox_get_bounds", + "stbvox_set_mesh_coordinates", + "stbvox_set_input_stride", + "find_best_normal", + "main" + ] + }, + "enum_constants": { + "STBVOX_GEOM_empty": { + "name": "STBVOX_GEOM_empty", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 665, + "column": 1, + "source_line": "enum" + } + }, + "STBVOX_GEOM_knockout": { + "name": "STBVOX_GEOM_knockout", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 665, + "column": 1, + "source_line": "enum" + } + }, + "STBVOX_GEOM_solid": { + "name": "STBVOX_GEOM_solid", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 665, + "column": 1, + "source_line": "enum" + } + }, + "STBVOX_GEOM_transp": { + "name": "STBVOX_GEOM_transp", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 665, + "column": 1, + "source_line": "enum" + } + }, + "STBVOX_GEOM_slab_upper": { + "name": "STBVOX_GEOM_slab_upper", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 665, + "column": 1, + "source_line": "enum" + } + }, + "STBVOX_GEOM_slab_lower": { + "name": "STBVOX_GEOM_slab_lower", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 665, + "column": 1, + "source_line": "enum" + } + }, + "STBVOX_GEOM_floor_slope_north_is_top": { + "name": "STBVOX_GEOM_floor_slope_north_is_top", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 665, + "column": 1, + "source_line": "enum" + } + }, + "STBVOX_GEOM_ceil_slope_north_is_bottom": { + "name": "STBVOX_GEOM_ceil_slope_north_is_bottom", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 665, + "column": 1, + "source_line": "enum" + } + }, + "STBVOX_GEOM_floor_slope_north_is_top_as_wall_UNIMPLEMENTED": { + "name": "STBVOX_GEOM_floor_slope_north_is_top_as_wall_UNIMPLEMENTED", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 665, + "column": 1, + "source_line": "enum" + } + }, + "STBVOX_GEOM_ceil_slope_north_is_bottom_as_wall_UNIMPLEMENTED": { + "name": "STBVOX_GEOM_ceil_slope_north_is_bottom_as_wall_UNIMPLEMENTED", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 665, + "column": 1, + "source_line": "enum" + } + }, + "STBVOX_GEOM_crossed_pair": { + "name": "STBVOX_GEOM_crossed_pair", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 665, + "column": 1, + "source_line": "enum" + } + }, + "STBVOX_GEOM_force": { + "name": "STBVOX_GEOM_force", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 665, + "column": 1, + "source_line": "enum" + } + }, + "STBVOX_GEOM_floor_vheight_03": { + "name": "STBVOX_GEOM_floor_vheight_03", + "value": "12", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 665, + "column": 1, + "source_line": "enum" + } + }, + "STBVOX_GEOM_floor_vheight_12": { + "name": "STBVOX_GEOM_floor_vheight_12", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 665, + "column": 1, + "source_line": "enum" + } + }, + "STBVOX_GEOM_ceil_vheight_03": { + "name": "STBVOX_GEOM_ceil_vheight_03", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 665, + "column": 1, + "source_line": "enum" + } + }, + "STBVOX_GEOM_ceil_vheight_12": { + "name": "STBVOX_GEOM_ceil_vheight_12", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 665, + "column": 1, + "source_line": "enum" + } + }, + "STBVOX_GEOM_count": { + "name": "STBVOX_GEOM_count", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 665, + "column": 1, + "source_line": "enum" + } + }, + "STBVOX_FACE_east": { + "name": "STBVOX_FACE_east", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 692, + "column": 1, + "source_line": "enum" + } + }, + "STBVOX_FACE_north": { + "name": "STBVOX_FACE_north", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 692, + "column": 1, + "source_line": "enum" + } + }, + "STBVOX_FACE_west": { + "name": "STBVOX_FACE_west", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 692, + "column": 1, + "source_line": "enum" + } + }, + "STBVOX_FACE_south": { + "name": "STBVOX_FACE_south", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 692, + "column": 1, + "source_line": "enum" + } + }, + "STBVOX_FACE_up": { + "name": "STBVOX_FACE_up", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 692, + "column": 1, + "source_line": "enum" + } + }, + "STBVOX_FACE_down": { + "name": "STBVOX_FACE_down", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 692, + "column": 1, + "source_line": "enum" + } + }, + "STBVOX_FACE_count": { + "name": "STBVOX_FACE_count", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 692, + "column": 1, + "source_line": "enum" + } + }, + "STBVOX_VERTEX_HEIGHT_0": { + "name": "STBVOX_VERTEX_HEIGHT_0", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1035, + "column": 1, + "source_line": "enum" + } + }, + "STBVOX_VERTEX_HEIGHT_half": { + "name": "STBVOX_VERTEX_HEIGHT_half", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1035, + "column": 1, + "source_line": "enum" + } + }, + "STBVOX_VERTEX_HEIGHT_1": { + "name": "STBVOX_VERTEX_HEIGHT_1", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1035, + "column": 1, + "source_line": "enum" + } + }, + "STBVOX_VERTEX_HEIGHT_one_and_a_half": { + "name": "STBVOX_VERTEX_HEIGHT_one_and_a_half", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1035, + "column": 1, + "source_line": "enum" + } + }, + "STBVOX_TEXLERP_FACE_0": { + "name": "STBVOX_TEXLERP_FACE_0", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1117, + "column": 1, + "source_line": "enum" + } + }, + "STBVOX_TEXLERP_FACE_half": { + "name": "STBVOX_TEXLERP_FACE_half", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1117, + "column": 1, + "source_line": "enum" + } + }, + "STBVOX_TEXLERP_FACE_1": { + "name": "STBVOX_TEXLERP_FACE_1", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1117, + "column": 1, + "source_line": "enum" + } + }, + "STBVOX_TEXLERP_FACE_use_vert": { + "name": "STBVOX_TEXLERP_FACE_use_vert", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1117, + "column": 1, + "source_line": "enum" + } + }, + "STBVOX_TEXLERP_BASE_0": { + "name": "STBVOX_TEXLERP_BASE_0", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1125, + "column": 1, + "source_line": "enum" + } + }, + "STBVOX_TEXLERP_BASE_2_7": { + "name": "STBVOX_TEXLERP_BASE_2_7", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1125, + "column": 1, + "source_line": "enum" + } + }, + "STBVOX_TEXLERP_BASE_5_7": { + "name": "STBVOX_TEXLERP_BASE_5_7", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1125, + "column": 1, + "source_line": "enum" + } + }, + "STBVOX_TEXLERP_BASE_1": { + "name": "STBVOX_TEXLERP_BASE_1", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1125, + "column": 1, + "source_line": "enum" + } + }, + "STBVOX_TEXLERP3_0_8": { + "name": "STBVOX_TEXLERP3_0_8", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1133, + "column": 1, + "source_line": "enum" + } + }, + "STBVOX_TEXLERP3_1_8": { + "name": "STBVOX_TEXLERP3_1_8", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1133, + "column": 1, + "source_line": "enum" + } + }, + "STBVOX_TEXLERP3_2_8": { + "name": "STBVOX_TEXLERP3_2_8", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1133, + "column": 1, + "source_line": "enum" + } + }, + "STBVOX_TEXLERP3_3_8": { + "name": "STBVOX_TEXLERP3_3_8", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1133, + "column": 1, + "source_line": "enum" + } + }, + "STBVOX_TEXLERP3_4_8": { + "name": "STBVOX_TEXLERP3_4_8", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1133, + "column": 1, + "source_line": "enum" + } + }, + "STBVOX_TEXLERP3_5_8": { + "name": "STBVOX_TEXLERP3_5_8", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1133, + "column": 1, + "source_line": "enum" + } + }, + "STBVOX_TEXLERP3_6_8": { + "name": "STBVOX_TEXLERP3_6_8", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1133, + "column": 1, + "source_line": "enum" + } + }, + "STBVOX_TEXLERP3_7_8": { + "name": "STBVOX_TEXLERP3_7_8", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1133, + "column": 1, + "source_line": "enum" + } + }, + "STBVF_e": { + "name": "STBVF_e", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + }, + "STBVF_n": { + "name": "STBVF_n", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + }, + "STBVF_w": { + "name": "STBVF_w", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + }, + "STBVF_s": { + "name": "STBVF_s", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + }, + "STBVF_u": { + "name": "STBVF_u", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + }, + "STBVF_d": { + "name": "STBVF_d", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + }, + "STBVF_eu": { + "name": "STBVF_eu", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + }, + "STBVF_ed": { + "name": "STBVF_ed", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + }, + "STBVF_eu_wall": { + "name": "STBVF_eu_wall", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + }, + "STBVF_nu_wall": { + "name": "STBVF_nu_wall", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + }, + "STBVF_wu_wall": { + "name": "STBVF_wu_wall", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + }, + "STBVF_su_wall": { + "name": "STBVF_su_wall", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + }, + "STBVF_ne_u": { + "name": "STBVF_ne_u", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + }, + "STBVF_ne_d": { + "name": "STBVF_ne_d", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + }, + "STBVF_nu": { + "name": "STBVF_nu", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + }, + "STBVF_nd": { + "name": "STBVF_nd", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + }, + "STBVF_ed_wall": { + "name": "STBVF_ed_wall", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + }, + "STBVF_nd_wall": { + "name": "STBVF_nd_wall", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + }, + "STBVF_wd_wall": { + "name": "STBVF_wd_wall", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + }, + "STBVF_sd_wall": { + "name": "STBVF_sd_wall", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + }, + "STBVF_nw_u": { + "name": "STBVF_nw_u", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + }, + "STBVF_nw_d": { + "name": "STBVF_nw_d", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + }, + "STBVF_wu": { + "name": "STBVF_wu", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + }, + "STBVF_wd": { + "name": "STBVF_wd", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + }, + "STBVF_ne_u_cross": { + "name": "STBVF_ne_u_cross", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + }, + "STBVF_nw_u_cross": { + "name": "STBVF_nw_u_cross", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + }, + "STBVF_sw_u_cross": { + "name": "STBVF_sw_u_cross", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + }, + "STBVF_se_u_cross": { + "name": "STBVF_se_u_cross", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + }, + "STBVF_sw_u": { + "name": "STBVF_sw_u", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + }, + "STBVF_sw_d": { + "name": "STBVF_sw_d", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + }, + "STBVF_su": { + "name": "STBVF_su", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + }, + "STBVF_sd": { + "name": "STBVF_sd", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + }, + "STBVF_se_u": { + "name": "STBVF_se_u", + "value": "STBVF_su", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + }, + "STBVF_se_d": { + "name": "STBVF_se_d", + "value": "STBVF_sd", + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + }, + "STBVF_count": { + "name": "STBVF_count", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 1377, + "column": 1, + "source_line": "enum" + } + }, + "STBVOX_FT_none": { + "name": "STBVOX_FT_none", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2146, + "column": 1, + "source_line": "enum" + } + }, + "STBVOX_FT_upper": { + "name": "STBVOX_FT_upper", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2146, + "column": 1, + "source_line": "enum" + } + }, + "STBVOX_FT_lower": { + "name": "STBVOX_FT_lower", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2146, + "column": 1, + "source_line": "enum" + } + }, + "STBVOX_FT_solid": { + "name": "STBVOX_FT_solid", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2146, + "column": 1, + "source_line": "enum" + } + }, + "STBVOX_FT_diag_012": { + "name": "STBVOX_FT_diag_012", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2146, + "column": 1, + "source_line": "enum" + } + }, + "STBVOX_FT_diag_023": { + "name": "STBVOX_FT_diag_023", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2146, + "column": 1, + "source_line": "enum" + } + }, + "STBVOX_FT_diag_013": { + "name": "STBVOX_FT_diag_013", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2146, + "column": 1, + "source_line": "enum" + } + }, + "STBVOX_FT_diag_123": { + "name": "STBVOX_FT_diag_123", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2146, + "column": 1, + "source_line": "enum" + } + }, + "STBVOX_FT_force": { + "name": "STBVOX_FT_force", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2146, + "column": 1, + "source_line": "enum" + } + }, + "STBVOX_FT_partial": { + "name": "STBVOX_FT_partial", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2146, + "column": 1, + "source_line": "enum" + } + }, + "STBVOX_FT_count": { + "name": "STBVOX_FT_count", + "value": null, + "source_location": { + "filename": "stb/stb_voxel_render.h", + "line": 2146, + "column": 1, + "source_line": "enum" + } + } + }, + "include_graph": { + "stb/stb_voxel_render.h": [] + }, + "system_includes": { + "stb/stb_voxel_render.h": [ + "assert.h", + "stdint.h", + "stdlib.h", + "string.h" + ] + }, + "unresolved_includes": { + "stb/stb_voxel_render.h": [] + }, + "header_source_pairs": { + "stb/stb_voxel_render.h": [] + }, + "diagnostics": [ + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBVOX_MAKE_GEOMETRY' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1155, + "column": 1, + "source_line": "#define STBVOX_MAKE_GEOMETRY(geom, rotate, vheight) ((geom) + (rotate)*16 + (vheight)*64)" + }, + "unit_kind": "macro", + "unit_name": "STBVOX_MAKE_GEOMETRY" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBVOX_MAKE_VHEIGHT' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1156, + "column": 1, + "source_line": "#define STBVOX_MAKE_VHEIGHT(v_sw, v_se, v_nw, v_ne) ((v_sw) + (v_se)*4 + (v_nw)*16 + (v_ne)*64)" + }, + "unit_kind": "macro", + "unit_name": "STBVOX_MAKE_VHEIGHT" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBVOX_MAKE_MATROT' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1157, + "column": 1, + "source_line": "#define STBVOX_MAKE_MATROT(block, overlay, color) ((block) + (overlay)*4 + (color)*64)" + }, + "unit_kind": "macro", + "unit_name": "STBVOX_MAKE_MATROT" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBVOX_MAKE_TEX2_REPLACE' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1158, + "column": 1, + "source_line": "#define STBVOX_MAKE_TEX2_REPLACE(tex2, tex2_replace_face) ((tex2) + ((tex2_replace_face) & 3)*64)" + }, + "unit_kind": "macro", + "unit_name": "STBVOX_MAKE_TEX2_REPLACE" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBVOX_MAKE_TEXLERP' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1159, + "column": 1, + "source_line": "#define STBVOX_MAKE_TEXLERP(ns2, ew2, ud2, vert) ((ew2) + (ns2)*4 + (ud2)*16 + (vert)*64)" + }, + "unit_kind": "macro", + "unit_name": "STBVOX_MAKE_TEXLERP" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBVOX_MAKE_TEXLERP_SIMPLE' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1160, + "column": 1, + "source_line": "#define STBVOX_MAKE_TEXLERP_SIMPLE(baselerp,vert,face) ((vert)*32 + (face)*4 + (baselerp))" + }, + "unit_kind": "macro", + "unit_name": "STBVOX_MAKE_TEXLERP_SIMPLE" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBVOX_MAKE_TEXLERP1' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1161, + "column": 1, + "source_line": "#define STBVOX_MAKE_TEXLERP1(vert,e2,n2,w2,s2,u4,d2) STBVOX_MAKE_TEXLERP(s2, w2, d2, vert)" + }, + "unit_kind": "macro", + "unit_name": "STBVOX_MAKE_TEXLERP1" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBVOX_MAKE_TEXLERP2' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1162, + "column": 1, + "source_line": "#define STBVOX_MAKE_TEXLERP2(vert,e2,n2,w2,s2,u4,d2) ((u2)*16 + (n2)*4 + (s2))" + }, + "unit_kind": "macro", + "unit_name": "STBVOX_MAKE_TEXLERP2" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBVOX_MAKE_FACE_MASK' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1163, + "column": 1, + "source_line": "#define STBVOX_MAKE_FACE_MASK(e,n,w,s,u,d) ((e)+(n)*2+(w)*4+(s)*8+(u)*16+(d)*32)" + }, + "unit_kind": "macro", + "unit_name": "STBVOX_MAKE_FACE_MASK" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBVOX_MAKE_SIDE_TEXROT' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1164, + "column": 1, + "source_line": "#define STBVOX_MAKE_SIDE_TEXROT(e,n,w,s) ((e)+(n)*4+(w)*16+(s)*64)" + }, + "unit_kind": "macro", + "unit_name": "STBVOX_MAKE_SIDE_TEXROT" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBVOX_MAKE_COLOR' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1165, + "column": 1, + "source_line": "#define STBVOX_MAKE_COLOR(color,t1,t2) ((color)+(t1)*64+(t2)*128)" + }, + "unit_kind": "macro", + "unit_name": "STBVOX_MAKE_COLOR" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBVOX_MAKE_TEXLERP_VERT3' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1166, + "column": 1, + "source_line": "#define STBVOX_MAKE_TEXLERP_VERT3(e,n,w,s,u) ((e)+(n)*8+(w)*64+(s)*512+(u)*4096)" + }, + "unit_kind": "macro", + "unit_name": "STBVOX_MAKE_TEXLERP_VERT3" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBVOX_MAKE_TEXLERP_FACE3' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1167, + "column": 1, + "source_line": "#define STBVOX_MAKE_TEXLERP_FACE3(e,n,w,s,u,d) ((e)+(n)*8+(w)*64+(s)*512+(u)*4096+(d)*16384)" + }, + "unit_kind": "macro", + "unit_name": "STBVOX_MAKE_TEXLERP_FACE3" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBVOX_MAKE_PACKED_COMPACT' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1168, + "column": 1, + "source_line": "#define STBVOX_MAKE_PACKED_COMPACT(rot, vheight, texlerp, def) ((rot)+4*(vheight)+16*(use)+32*(texlerp))" + }, + "unit_kind": "macro", + "unit_name": "STBVOX_MAKE_PACKED_COMPACT" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBVOX_MAKE_LIGHTING_EXT' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1170, + "column": 1, + "source_line": "#define STBVOX_MAKE_LIGHTING_EXT(lighting, rot) (((lighting)&~3)+(rot))" + }, + "unit_kind": "macro", + "unit_name": "STBVOX_MAKE_LIGHTING_EXT" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBVOX_MAKE_LIGHTING' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1171, + "column": 1, + "source_line": "#define STBVOX_MAKE_LIGHTING(lighting) (lighting)" + }, + "unit_kind": "macro", + "unit_name": "STBVOX_MAKE_LIGHTING" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBVOX_NOTUSED' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1233, + "column": 4, + "source_line": " #define STBVOX_NOTUSED(v) (void)(v)" + }, + "unit_kind": "macro", + "unit_name": "STBVOX_NOTUSED" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBVOX_NOTUSED' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1235, + "column": 4, + "source_line": " #define STBVOX_NOTUSED(v) (void)sizeof(v)" + }, + "unit_kind": "macro", + "unit_name": "STBVOX_NOTUSED" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbvox_vertex_encode' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1322, + "column": 4, + "source_line": " #define stbvox_vertex_encode(x,y,z,ao,texlerp) \\" + }, + "unit_kind": "macro", + "unit_name": "stbvox_vertex_encode" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbvox_vertex_encode' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1326, + "column": 4, + "source_line": " #define stbvox_vertex_encode(x,y,z,ao,texlerp) \\" + }, + "unit_kind": "macro", + "unit_name": "stbvox_vertex_encode" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbvox_vertex_encode' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1330, + "column": 4, + "source_line": " #define stbvox_vertex_encode(x,y,z,ao,texlerp) \\" + }, + "unit_kind": "macro", + "unit_name": "stbvox_vertex_encode" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'stbvox_vertex_encode' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1334, + "column": 4, + "source_line": " #define stbvox_vertex_encode(x,y,z,ao,texlerp) \\" + }, + "unit_kind": "macro", + "unit_name": "stbvox_vertex_encode" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBVOX_GET_GEO' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2015, + "column": 1, + "source_line": "#define STBVOX_GET_GEO(geom_data) ((geom_data) & 15)" + }, + "unit_kind": "macro", + "unit_name": "STBVOX_GET_GEO" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBVOX_ROTATE' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2040, + "column": 1, + "source_line": "#define STBVOX_ROTATE(x,r) stbvox_rotate_face[x][r] // (((x)+(r))&3)" + }, + "unit_kind": "macro", + "unit_name": "STBVOX_ROTATE" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBVOX_HEIGHTS' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2392, + "column": 4, + "source_line": " #define STBVOX_HEIGHTS(a,b,c,d,e,f,g,h) \\" + }, + "unit_kind": "macro", + "unit_name": "STBVOX_HEIGHTS" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBVOX_USE_PACKED' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2686, + "column": 7, + "source_line": " #define STBVOX_USE_PACKED(f) ((f) == STBVOX_FACE_up || (f) == STBVOX_FACE_down)" + }, + "unit_kind": "macro", + "unit_name": "STBVOX_USE_PACKED" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBVOX_USE_PACKED' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2688, + "column": 7, + "source_line": " #define STBVOX_USE_PACKED(f) ((f) == STBVOX_FACE_up )" + }, + "unit_kind": "macro", + "unit_name": "STBVOX_USE_PACKED" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBVOX_USE_PACKED' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2690, + "column": 7, + "source_line": " #define STBVOX_USE_PACKED(f) ( (f) == STBVOX_FACE_down)" + }, + "unit_kind": "macro", + "unit_name": "STBVOX_USE_PACKED" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBVOX_GET_LIGHTING' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2790, + "column": 13, + "source_line": " #define STBVOX_GET_LIGHTING(light) ((light) & ~3)" + }, + "unit_kind": "macro", + "unit_name": "STBVOX_GET_LIGHTING" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'STBVOX_GET_LIGHTING' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2793, + "column": 13, + "source_line": " #define STBVOX_GET_LIGHTING(light) (light)" + }, + "unit_kind": "macro", + "unit_name": "STBVOX_GET_LIGHTING" + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '\"C\"'.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 243, + "column": 1, + "source_line": "extern \"C\" {" + }, + "unit_kind": "declarator", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1428, + "column": 1, + "source_line": "static float stbvox_default_texgen[2][32][3] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1455, + "column": 1, + "source_line": "static float stbvox_default_normals[32][3] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1494, + "column": 1, + "source_line": "static float stbvox_default_texscale[128][4] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1514, + "column": 1, + "source_line": "static unsigned char stbvox_default_palette_compact[64][3] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1534, + "column": 1, + "source_line": "static float stbvox_default_ambient[4][4] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1570, + "column": 1, + "source_line": "static const char *stbvox_vertex_program =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1646, + "column": 1, + "source_line": "static const char *stbvox_fragment_program =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1866, + "column": 1, + "source_line": "static const char *stbvox_fragment_program_alpha_only =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBVXDEC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1970, + "column": 1, + "source_line": "STBVXDEC char *stbvox_get_vertex_shader(void)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBVXDEC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBVXDEC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1975, + "column": 1, + "source_line": "STBVXDEC char *stbvox_get_fragment_shader(void)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBVXDEC" + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBVXDEC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1980, + "column": 1, + "source_line": "STBVXDEC char *stbvox_get_fragment_shader_alpha_only(void)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBVXDEC" + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1993, + "column": 1, + "source_line": "static stbvox_uniform_info stbvox_uniforms[] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_MACRO_DEPENDENT_DECLARATION", + "message": "Declaration depends on object-like macro 'STBVXDEC'; provide preprocessed input to parse it.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2006, + "column": 1, + "source_line": "STBVXDEC int stbvox_get_uniform_info(stbvox_uniform_info *info, int uniform)" + }, + "unit_kind": "macro_dependent_declaration", + "unit_name": "STBVXDEC" + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2030, + "column": 1, + "source_line": "static unsigned char stbvox_rotate_face[6][4] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2162, + "column": 1, + "source_line": "static unsigned char stbvox_face_lerp[6] = { 0,2,0,2,4,4 };" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2163, + "column": 1, + "source_line": "static unsigned char stbvox_vert3_lerp[5] = { 0,3,6,9,12 };" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2164, + "column": 1, + "source_line": "static unsigned char stbvox_vert_lerp_for_face_lerp[4] = { 0, 4, 7, 7 };" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2165, + "column": 1, + "source_line": "static unsigned char stbvox_face3_lerp[6] = { 0,3,6,9,12,14 };" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2166, + "column": 1, + "source_line": "static unsigned char stbvox_vert_lerp_for_simple[4] = { 0,2,5,7 };" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2167, + "column": 1, + "source_line": "static unsigned char stbvox_face3_updown[8] = { 0,2,5,7,0,2,5,7 }; // ignore top bit" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2170, + "column": 1, + "source_line": "static unsigned char stbvox_vertex_vector[6][4][3] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2181, + "column": 1, + "source_line": "static unsigned char stbvox_vertex_selector[6][4] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2191, + "column": 1, + "source_line": "static stbvox_mesh_vertex stbvox_vmesh_delta_normal[6][4] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2219, + "column": 1, + "source_line": "static stbvox_mesh_vertex stbvox_vmesh_pre_vheight[6][4] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2247, + "column": 1, + "source_line": "static stbvox_mesh_vertex stbvox_vmesh_delta_half_z[6][4] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2275, + "column": 1, + "source_line": "static stbvox_mesh_vertex stbvox_vmesh_crossed_pair[6][4] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2308, + "column": 1, + "source_line": "static unsigned char stbvox_hasface[STBVOX_MAX_GEOM][STBVOX_NUM_ROTATION] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2329, + "column": 1, + "source_line": "static unsigned char stbvox_facetype[STBVOX_GEOM_count][6] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2354, + "column": 1, + "source_line": "static unsigned char stbvox_floor_slope_for_rot[4] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2362, + "column": 1, + "source_line": "static unsigned char stbvox_ceil_slope_for_rot[4] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2372, + "column": 1, + "source_line": "static unsigned short stbvox_face_visible[STBVOX_FT_count] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2390, + "column": 1, + "source_line": "static stbvox_mesh_vertex stbvox_geometry_vheight[8][8] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2413, + "column": 1, + "source_line": "static unsigned char stbvox_rotate_vertex[8][4] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2427, + "column": 1, + "source_line": "static unsigned char stbvox_optimized_face_up_normal[4][4][4][4] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2523, + "column": 1, + "source_line": "static unsigned char stbvox_planar_face_up_normal[4][4][4] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2550, + "column": 1, + "source_line": "static unsigned char stbvox_face_up_normal_012[4][4][4] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2575, + "column": 1, + "source_line": "static unsigned char stbvox_face_up_normal_013[4][4][4] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2600, + "column": 1, + "source_line": "static unsigned char stbvox_face_up_normal_023[4][4][4] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2625, + "column": 1, + "source_line": "static unsigned char stbvox_face_up_normal_123[4][4][4] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 2833, + "column": 1, + "source_line": "static unsigned char stbvox_reverse_face[STBVF_count] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 3659, + "column": 1, + "source_line": "static char *normal_names[32] =" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_CONFLICTING_TYPEDEF", + "message": "Conflicting typedef declarations for 'stbvox_block_type'.", + "severity": "error", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 707, + "column": 1, + "source_line": "typedef unsigned char stbvox_block_type;" + }, + "unit_kind": "typedef", + "unit_name": "stbvox_block_type" + }, + { + "code": "C_CONFLICTING_TYPEDEF", + "message": "Conflicting typedef declarations for 'stbvox_uint16'.", + "severity": "error", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1228, + "column": 4, + "source_line": " typedef unsigned short stbvox_uint16;" + }, + "unit_kind": "typedef", + "unit_name": "stbvox_uint16" + }, + { + "code": "C_CONFLICTING_TYPEDEF", + "message": "Conflicting typedef declarations for 'stbvox_uint32'.", + "severity": "error", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1229, + "column": 4, + "source_line": " typedef unsigned int stbvox_uint32;" + }, + "unit_kind": "typedef", + "unit_name": "stbvox_uint32" + }, + { + "code": "C_CONFLICTING_TYPEDEF", + "message": "Conflicting typedef declarations for 'stbvox_mesh_vertex'.", + "severity": "error", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1325, + "column": 4, + "source_line": " typedef stbvox_uint16 stbvox_mesh_vertex;" + }, + "unit_kind": "typedef", + "unit_name": "stbvox_mesh_vertex" + }, + { + "code": "C_CONFLICTING_TYPEDEF", + "message": "Conflicting typedef declarations for 'stbvox_mesh_vertex'.", + "severity": "error", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1329, + "column": 4, + "source_line": " typedef stbvox_uint16 stbvox_mesh_vertex;" + }, + "unit_kind": "typedef", + "unit_name": "stbvox_mesh_vertex" + }, + { + "code": "C_CONFLICTING_TYPEDEF", + "message": "Conflicting typedef declarations for 'stbvox_mesh_vertex'.", + "severity": "error", + "location": { + "filename": "stb/stb_voxel_render.h", + "line": 1333, + "column": 4, + "source_line": " typedef stbvox_uint8 stbvox_mesh_vertex;" + }, + "unit_kind": "typedef", + "unit_name": "stbvox_mesh_vertex" + } + ] +} diff --git a/tests/parser/c/fixtures/tinyexpr/tinyexpr.json b/tests/parser/c/fixtures/tinyexpr/tinyexpr.json new file mode 100644 index 000000000..9ee52bccf --- /dev/null +++ b/tests/parser/c/fixtures/tinyexpr/tinyexpr.json @@ -0,0 +1,6328 @@ +{ + "files": { + "tinyexpr/tinyexpr.c": { + "filename": "tinyexpr/tinyexpr.c", + "language": "c", + "parser_status": "partial", + "preprocessing": "raw", + "functions": [ + { + "name": "new_expr", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "te_expr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "te_expr", + "name": "te_expr", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "parameters": [ + { + "name": "type", + "type": { + "model": "CInt", + "qualifiers": [ + "const" + ], + "source_text": "const int type" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [ + "const" + ], + "source_text": "const int type" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "parameters", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const te_expr *parameters[]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [ + "const" + ], + "source_text": "const te_expr", + "name": "te_expr", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const te_expr *parameters[]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": null, + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "te_expr" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 87, + "column": 1, + "source_line": "static te_expr *new_expr(const int type, const te_expr *parameters[]) {" + }, + "start": { + "filename": "tinyexpr/tinyexpr.c", + "line": 87, + "column": 1, + "source_line": "static te_expr *new_expr(const int type, const te_expr *parameters[]) {" + }, + "end": { + "filename": "tinyexpr/tinyexpr.c", + "line": 101, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "te_free_parameters", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "n", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "te_expr *n", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "te_expr", + "name": "te_expr", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "te_expr *n", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "te_expr" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 104, + "column": 1, + "source_line": "void te_free_parameters(te_expr *n) {" + }, + "start": { + "filename": "tinyexpr/tinyexpr.c", + "line": 104, + "column": 1, + "source_line": "void te_free_parameters(te_expr *n) {" + }, + "end": { + "filename": "tinyexpr/tinyexpr.c", + "line": 115, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "te_free", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "n", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "te_expr *n", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "te_expr", + "name": "te_expr", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "te_expr *n", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "te_expr" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 118, + "column": 1, + "source_line": "void te_free(te_expr *n) {" + }, + "start": { + "filename": "tinyexpr/tinyexpr.c", + "line": 118, + "column": 1, + "source_line": "void te_free(te_expr *n) {" + }, + "end": { + "filename": "tinyexpr/tinyexpr.c", + "line": 122, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "pi", + "result_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + }, + "parameters": [], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 125, + "column": 1, + "source_line": "static double pi(void) {return 3.14159265358979323846;}" + }, + "start": { + "filename": "tinyexpr/tinyexpr.c", + "line": 125, + "column": 1, + "source_line": "static double pi(void) {return 3.14159265358979323846;}" + }, + "end": { + "filename": "tinyexpr/tinyexpr.c", + "line": 125, + "column": 55, + "source_line": "static double pi(void) {return 3.14159265358979323846;}" + }, + "declaration_locations": [] + }, + { + "name": "e", + "result_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + }, + "parameters": [], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 126, + "column": 1, + "source_line": "static double e(void) {return 2.71828182845904523536;}" + }, + "start": { + "filename": "tinyexpr/tinyexpr.c", + "line": 126, + "column": 1, + "source_line": "static double e(void) {return 2.71828182845904523536;}" + }, + "end": { + "filename": "tinyexpr/tinyexpr.c", + "line": 126, + "column": 54, + "source_line": "static double e(void) {return 2.71828182845904523536;}" + }, + "declaration_locations": [] + }, + { + "name": "fac", + "result_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double a" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double a" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 127, + "column": 1, + "source_line": "static double fac(double a) {/* simplest version of fac */" + }, + "start": { + "filename": "tinyexpr/tinyexpr.c", + "line": 127, + "column": 1, + "source_line": "static double fac(double a) {/* simplest version of fac */" + }, + "end": { + "filename": "tinyexpr/tinyexpr.c", + "line": 140, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "ncr", + "result_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + }, + "parameters": [ + { + "name": "n", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double n" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "r", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double r" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double r" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 141, + "column": 1, + "source_line": "static double ncr(double n, double r) {" + }, + "start": { + "filename": "tinyexpr/tinyexpr.c", + "line": 141, + "column": 1, + "source_line": "static double ncr(double n, double r) {" + }, + "end": { + "filename": "tinyexpr/tinyexpr.c", + "line": 154, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "npr", + "result_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + }, + "parameters": [ + { + "name": "n", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double n" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "r", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double r" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double r" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 155, + "column": 1, + "source_line": "static double npr(double n, double r) {return ncr(n, r) * fac(r);}" + }, + "start": { + "filename": "tinyexpr/tinyexpr.c", + "line": 155, + "column": 1, + "source_line": "static double npr(double n, double r) {return ncr(n, r) * fac(r);}" + }, + "end": { + "filename": "tinyexpr/tinyexpr.c", + "line": 155, + "column": 66, + "source_line": "static double npr(double n, double r) {return ncr(n, r) * fac(r);}" + }, + "declaration_locations": [] + }, + { + "name": "find_builtin", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const te_variable", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [ + "const" + ], + "source_text": "const te_variable", + "name": "te_variable", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "parameters": [ + { + "name": "name", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *name", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *name", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 195, + "column": 1, + "source_line": "static const te_variable *find_builtin(const char *name, int len) {" + }, + "start": { + "filename": "tinyexpr/tinyexpr.c", + "line": 195, + "column": 1, + "source_line": "static const te_variable *find_builtin(const char *name, int len) {" + }, + "end": { + "filename": "tinyexpr/tinyexpr.c", + "line": 214, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "find_lookup", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const te_variable", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [ + "const" + ], + "source_text": "const te_variable", + "name": "te_variable", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const state *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "state", + "name": "state", + "type": { + "model": "CStruct", + "qualifiers": [], + "source_text": "", + "name": "state", + "members": [ + { + "name": "start", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *start", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 67, + "column": 5, + "source_line": " const char *start;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "next", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *next", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 68, + "column": 5, + "source_line": " const char *next;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "type", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int type" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 69, + "column": 5, + "source_line": " int type;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "context", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "void *context", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 71, + "column": 5, + "source_line": " void *context;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "lookup", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const te_variable *lookup", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [ + "const" + ], + "source_text": "const te_variable", + "name": "te_variable", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 73, + "column": 5, + "source_line": " const te_variable *lookup;" + }, + "callback_policy": null, + "declaration_locations": [] + }, + { + "name": "lookup_len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int lookup_len" + }, + "storage": [], + "initializer": null, + "bit_width": null, + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 74, + "column": 5, + "source_line": " int lookup_len;" + }, + "callback_policy": null, + "declaration_locations": [] + } + ], + "anonymous_id": null, + "is_incomplete": false, + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 66, + "column": 1, + "source_line": "typedef struct state {" + } + }, + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 66, + "column": 1, + "source_line": "typedef struct state {" + }, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const state *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "state" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "name", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *name", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *name", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 216, + "column": 1, + "source_line": "static const te_variable *find_lookup(const state *s, const char *name, int len) {" + }, + "start": { + "filename": "tinyexpr/tinyexpr.c", + "line": 216, + "column": 1, + "source_line": "static const te_variable *find_lookup(const state *s, const char *name, int len) {" + }, + "end": { + "filename": "tinyexpr/tinyexpr.c", + "line": 227, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "add", + "result_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double a" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double a" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double b" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double b" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 231, + "column": 1, + "source_line": "static double add(double a, double b) {return a + b;}" + }, + "start": { + "filename": "tinyexpr/tinyexpr.c", + "line": 231, + "column": 1, + "source_line": "static double add(double a, double b) {return a + b;}" + }, + "end": { + "filename": "tinyexpr/tinyexpr.c", + "line": 231, + "column": 53, + "source_line": "static double add(double a, double b) {return a + b;}" + }, + "declaration_locations": [] + }, + { + "name": "sub", + "result_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double a" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double a" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double b" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double b" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 232, + "column": 1, + "source_line": "static double sub(double a, double b) {return a - b;}" + }, + "start": { + "filename": "tinyexpr/tinyexpr.c", + "line": 232, + "column": 1, + "source_line": "static double sub(double a, double b) {return a - b;}" + }, + "end": { + "filename": "tinyexpr/tinyexpr.c", + "line": 232, + "column": 53, + "source_line": "static double sub(double a, double b) {return a - b;}" + }, + "declaration_locations": [] + }, + { + "name": "mul", + "result_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double a" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double a" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double b" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double b" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 233, + "column": 1, + "source_line": "static double mul(double a, double b) {return a * b;}" + }, + "start": { + "filename": "tinyexpr/tinyexpr.c", + "line": 233, + "column": 1, + "source_line": "static double mul(double a, double b) {return a * b;}" + }, + "end": { + "filename": "tinyexpr/tinyexpr.c", + "line": 233, + "column": 53, + "source_line": "static double mul(double a, double b) {return a * b;}" + }, + "declaration_locations": [] + }, + { + "name": "divide", + "result_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double a" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double a" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double b" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double b" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 234, + "column": 1, + "source_line": "static double divide(double a, double b) {return a / b;}" + }, + "start": { + "filename": "tinyexpr/tinyexpr.c", + "line": 234, + "column": 1, + "source_line": "static double divide(double a, double b) {return a / b;}" + }, + "end": { + "filename": "tinyexpr/tinyexpr.c", + "line": 234, + "column": 56, + "source_line": "static double divide(double a, double b) {return a / b;}" + }, + "declaration_locations": [] + }, + { + "name": "negate", + "result_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double a" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double a" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 235, + "column": 1, + "source_line": "static double negate(double a) {return -a;}" + }, + "start": { + "filename": "tinyexpr/tinyexpr.c", + "line": 235, + "column": 1, + "source_line": "static double negate(double a) {return -a;}" + }, + "end": { + "filename": "tinyexpr/tinyexpr.c", + "line": 235, + "column": 43, + "source_line": "static double negate(double a) {return -a;}" + }, + "declaration_locations": [] + }, + { + "name": "comma", + "result_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double a" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double a" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double b" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double b" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 236, + "column": 1, + "source_line": "static double comma(double a, double b) {(void)a; return b;}" + }, + "start": { + "filename": "tinyexpr/tinyexpr.c", + "line": 236, + "column": 1, + "source_line": "static double comma(double a, double b) {(void)a; return b;}" + }, + "end": { + "filename": "tinyexpr/tinyexpr.c", + "line": 236, + "column": 60, + "source_line": "static double comma(double a, double b) {(void)a; return b;}" + }, + "declaration_locations": [] + }, + { + "name": "next_token", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "state *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "state" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "state *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "state" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 239, + "column": 1, + "source_line": "void next_token(state *s) {" + }, + "start": { + "filename": "tinyexpr/tinyexpr.c", + "line": 239, + "column": 1, + "source_line": "void next_token(state *s) {" + }, + "end": { + "filename": "tinyexpr/tinyexpr.c", + "line": 303, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "list", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "te_expr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "te_expr", + "name": "te_expr", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "state *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "state" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "state *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "state" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 571, + "column": 1, + "source_line": "static te_expr *list(state *s) {" + }, + "start": { + "filename": "tinyexpr/tinyexpr.c", + "line": 571, + "column": 1, + "source_line": "static te_expr *list(state *s) {" + }, + "end": { + "filename": "tinyexpr/tinyexpr.c", + "line": 589, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "tinyexpr/tinyexpr.c", + "line": 306, + "column": 1, + "source_line": "static te_expr *list(state *s);" + } + ] + }, + { + "name": "expr", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "te_expr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "te_expr", + "name": "te_expr", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "state *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "state" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "state *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "state" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 549, + "column": 1, + "source_line": "static te_expr *expr(state *s) {" + }, + "start": { + "filename": "tinyexpr/tinyexpr.c", + "line": 549, + "column": 1, + "source_line": "static te_expr *expr(state *s) {" + }, + "end": { + "filename": "tinyexpr/tinyexpr.c", + "line": 568, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "tinyexpr/tinyexpr.c", + "line": 307, + "column": 1, + "source_line": "static te_expr *expr(state *s);" + } + ] + }, + { + "name": "power", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "te_expr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "te_expr", + "name": "te_expr", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "state *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "state" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "state *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "state" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 422, + "column": 1, + "source_line": "static te_expr *power(state *s) {" + }, + "start": { + "filename": "tinyexpr/tinyexpr.c", + "line": 422, + "column": 1, + "source_line": "static te_expr *power(state *s) {" + }, + "end": { + "filename": "tinyexpr/tinyexpr.c", + "line": 445, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "tinyexpr/tinyexpr.c", + "line": 308, + "column": 1, + "source_line": "static te_expr *power(state *s);" + } + ] + }, + { + "name": "base", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "te_expr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "te_expr", + "name": "te_expr", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "state *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "state" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "state *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "state" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 310, + "column": 1, + "source_line": "static te_expr *base(state *s) {" + }, + "start": { + "filename": "tinyexpr/tinyexpr.c", + "line": 310, + "column": 1, + "source_line": "static te_expr *base(state *s) {" + }, + "end": { + "filename": "tinyexpr/tinyexpr.c", + "line": 419, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "factor", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "te_expr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "te_expr", + "name": "te_expr", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "state *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "state" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "state *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "state" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 448, + "column": 1, + "source_line": "static te_expr *factor(state *s) {" + }, + "start": { + "filename": "tinyexpr/tinyexpr.c", + "line": 448, + "column": 1, + "source_line": "static te_expr *factor(state *s) {" + }, + "end": { + "filename": "tinyexpr/tinyexpr.c", + "line": 501, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "term", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "te_expr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "te_expr", + "name": "te_expr", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "state *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "state" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "state *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "state" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 527, + "column": 1, + "source_line": "static te_expr *term(state *s) {" + }, + "start": { + "filename": "tinyexpr/tinyexpr.c", + "line": 527, + "column": 1, + "source_line": "static te_expr *term(state *s) {" + }, + "end": { + "filename": "tinyexpr/tinyexpr.c", + "line": 546, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "te_eval", + "result_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + }, + "parameters": [ + { + "name": "n", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const te_expr *n", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [ + "const" + ], + "source_text": "const te_expr", + "name": "te_expr", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const te_expr *n", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "te_expr" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 596, + "column": 1, + "source_line": "double te_eval(const te_expr *n) {" + }, + "start": { + "filename": "tinyexpr/tinyexpr.c", + "line": 596, + "column": 1, + "source_line": "double te_eval(const te_expr *n) {" + }, + "end": { + "filename": "tinyexpr/tinyexpr.c", + "line": 634, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "optimize", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "n", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "te_expr *n", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "te_expr", + "name": "te_expr", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "te_expr *n", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "te_expr" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 639, + "column": 1, + "source_line": "static void optimize(te_expr *n) {" + }, + "start": { + "filename": "tinyexpr/tinyexpr.c", + "line": 639, + "column": 1, + "source_line": "static void optimize(te_expr *n) {" + }, + "end": { + "filename": "tinyexpr/tinyexpr.c", + "line": 662, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "te_compile", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "te_expr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "te_expr", + "name": "te_expr", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "parameters": [ + { + "name": "expression", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *expression", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *expression", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "variables", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const te_variable *variables", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [ + "const" + ], + "source_text": "const te_variable", + "name": "te_variable", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const te_variable *variables", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "te_variable" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "var_count", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int var_count" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int var_count" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "error", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *error", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *error", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 665, + "column": 1, + "source_line": "te_expr *te_compile(const char *expression, const te_variable *variables, int var_count, int *error) {" + }, + "start": { + "filename": "tinyexpr/tinyexpr.c", + "line": 665, + "column": 1, + "source_line": "te_expr *te_compile(const char *expression, const te_variable *variables, int var_count, int *error) {" + }, + "end": { + "filename": "tinyexpr/tinyexpr.c", + "line": 690, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "te_interp", + "result_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + }, + "parameters": [ + { + "name": "expression", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *expression", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *expression", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "error", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *error", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *error", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 693, + "column": 1, + "source_line": "double te_interp(const char *expression, int *error) {" + }, + "start": { + "filename": "tinyexpr/tinyexpr.c", + "line": 693, + "column": 1, + "source_line": "double te_interp(const char *expression, int *error) {" + }, + "end": { + "filename": "tinyexpr/tinyexpr.c", + "line": 704, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "pn", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "n", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const te_expr *n", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [ + "const" + ], + "source_text": "const te_expr", + "name": "te_expr", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const te_expr *n", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "te_expr" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "depth", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int depth" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int depth" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 706, + "column": 1, + "source_line": "static void pn (const te_expr *n, int depth) {" + }, + "start": { + "filename": "tinyexpr/tinyexpr.c", + "line": 706, + "column": 1, + "source_line": "static void pn (const te_expr *n, int depth) {" + }, + "end": { + "filename": "tinyexpr/tinyexpr.c", + "line": 729, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + { + "name": "te_print", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "n", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const te_expr *n", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CTypedef", + "qualifiers": [ + "const" + ], + "source_text": "const te_expr", + "name": "te_expr", + "type": null, + "source_location": null, + "declaration_locations": [] + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const te_expr *n", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "te_expr" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 732, + "column": 1, + "source_line": "void te_print(const te_expr *n) {" + }, + "start": { + "filename": "tinyexpr/tinyexpr.c", + "line": 732, + "column": 1, + "source_line": "void te_print(const te_expr *n) {" + }, + "end": { + "filename": "tinyexpr/tinyexpr.c", + "line": 734, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + } + ], + "structs": [ + { + "reference": "struct state" + } + ], + "unions": [], + "enums": [ + { + "model": "CEnum", + "qualifiers": [], + "source_text": "", + "name": null, + "constants": [ + { + "name": "TOK_NULL", + "value": "TE_CLOSURE7+1", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 57, + "column": 1, + "source_line": "enum {" + } + }, + { + "name": "TOK_ERROR", + "value": null, + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 57, + "column": 1, + "source_line": "enum {" + } + }, + { + "name": "TOK_END", + "value": null, + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 57, + "column": 1, + "source_line": "enum {" + } + }, + { + "name": "TOK_SEP", + "value": null, + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 57, + "column": 1, + "source_line": "enum {" + } + }, + { + "name": "TOK_OPEN", + "value": null, + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 57, + "column": 1, + "source_line": "enum {" + } + }, + { + "name": "TOK_CLOSE", + "value": null, + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 57, + "column": 1, + "source_line": "enum {" + } + }, + { + "name": "TOK_NUMBER", + "value": null, + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 57, + "column": 1, + "source_line": "enum {" + } + }, + { + "name": "TOK_VARIABLE", + "value": null, + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 57, + "column": 1, + "source_line": "enum {" + } + }, + { + "name": "TOK_INFIX", + "value": null, + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 57, + "column": 1, + "source_line": "enum {" + } + } + ], + "anonymous_id": "enum@tinyexpr/tinyexpr.c:57:1", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 57, + "column": 1, + "source_line": "enum {" + } + }, + { + "model": "CEnum", + "qualifiers": [], + "source_text": "", + "name": null, + "constants": [ + { + "name": "TE_CONSTANT", + "value": "1", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 63, + "column": 1, + "source_line": "enum {TE_CONSTANT = 1};" + } + } + ], + "anonymous_id": "enum@tinyexpr/tinyexpr.c:63:1", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 63, + "column": 1, + "source_line": "enum {TE_CONSTANT = 1};" + } + } + ], + "typedefs": [ + { + "model": "CTypedef", + "qualifiers": [], + "source_text": "te_fun2", + "name": "te_fun2", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "typedef double (*te_fun2)(double, double)", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CFunctionType", + "qualifiers": [], + "source_text": "double", + "result_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + }, + "parameter_types": [ + { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + }, + { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + } + ], + "is_variadic": false, + "prototype_style": "prototype" + } + ] + }, + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 55, + "column": 1, + "source_line": "typedef double (*te_fun2)(double, double);" + }, + "declaration_locations": [] + }, + { + "reference": "state" + } + ], + "variables": [], + "macros": [ + { + "name": "NAN", + "value": "(0.0/0.0)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 47, + "column": 1, + "source_line": "#define NAN (0.0/0.0)" + } + }, + { + "name": "INFINITY", + "value": "(1.0/0.0)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 51, + "column": 1, + "source_line": "#define INFINITY (1.0/0.0)" + } + }, + { + "name": "TYPE_MASK", + "value": "((TYPE)&0x0000001F)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 78, + "column": 1, + "source_line": "#define TYPE_MASK(TYPE) ((TYPE)&0x0000001F)" + } + }, + { + "name": "IS_PURE", + "value": "(((TYPE) & TE_FLAG_PURE) != 0)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 80, + "column": 1, + "source_line": "#define IS_PURE(TYPE) (((TYPE) & TE_FLAG_PURE) != 0)" + } + }, + { + "name": "IS_FUNCTION", + "value": "(((TYPE) & TE_FUNCTION0) != 0)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 81, + "column": 1, + "source_line": "#define IS_FUNCTION(TYPE) (((TYPE) & TE_FUNCTION0) != 0)" + } + }, + { + "name": "IS_CLOSURE", + "value": "(((TYPE) & TE_CLOSURE0) != 0)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 82, + "column": 1, + "source_line": "#define IS_CLOSURE(TYPE) (((TYPE) & TE_CLOSURE0) != 0)" + } + }, + { + "name": "ARITY", + "value": "( ((TYPE) & (TE_FUNCTION0 | TE_CLOSURE0)) ? ((TYPE) & 0x00000007) : 0 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 83, + "column": 1, + "source_line": "#define ARITY(TYPE) ( ((TYPE) & (TE_FUNCTION0 | TE_CLOSURE0)) ? ((TYPE) & 0x00000007) : 0 )" + } + }, + { + "name": "NEW_EXPR", + "value": "new_expr((type), (const te_expr*[]){__VA_ARGS__})", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 84, + "column": 1, + "source_line": "#define NEW_EXPR(type, ...) new_expr((type), (const te_expr*[]){__VA_ARGS__})" + } + }, + { + "name": "CHECK_NULL", + "value": "if ((ptr) == NULL) { __VA_ARGS__; return NULL; }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 85, + "column": 1, + "source_line": "#define CHECK_NULL(ptr, ...) if ((ptr) == NULL) { __VA_ARGS__; return NULL; }" + } + }, + { + "name": "TE_FUN", + "value": "((double(*)(__VA_ARGS__))n->function)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 592, + "column": 1, + "source_line": "#define TE_FUN(...) ((double(*)(__VA_ARGS__))n->function)" + } + }, + { + "name": "M", + "value": "te_eval(n->parameters[e])", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 593, + "column": 1, + "source_line": "#define M(e) te_eval(n->parameters[e])" + } + }, + { + "name": "TE_FUN", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 636, + "column": 1, + "source_line": "#undef TE_FUN" + } + }, + { + "name": "M", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 637, + "column": 1, + "source_line": "#undef M" + } + } + ], + "includes": [ + { + "target": "tinyexpr.h", + "kind": "local", + "resolved_path": "tinyexpr/tinyexpr.h", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 38, + "column": 1, + "source_line": "#include \"tinyexpr.h\"" + } + }, + { + "target": "stdlib.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 39, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "math.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 40, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "string.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 41, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "stdio.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 42, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "ctype.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 43, + "column": 1, + "source_line": "#include " + } + }, + { + "target": "limits.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 44, + "column": 1, + "source_line": "#include " + } + } + ], + "raw_directives": [ + { + "directive": "ifndef", + "argument": "NAN", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 46, + "column": 1, + "source_line": "#ifndef NAN" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 48, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifndef", + "argument": "INFINITY", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 50, + "column": 1, + "source_line": "#ifndef INFINITY" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 52, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "_MSC_VER", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 157, + "column": 1, + "source_line": "#ifdef _MSC_VER" + } + }, + { + "directive": "pragma", + "argument": "function (ceil)", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 158, + "column": 1, + "source_line": "#pragma function (ceil)" + } + }, + { + "directive": "pragma", + "argument": "function (floor)", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 159, + "column": 1, + "source_line": "#pragma function (floor)" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 160, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "TE_NAT_LOG", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 177, + "column": 1, + "source_line": "#ifdef TE_NAT_LOG" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 179, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 181, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "TE_POW_FROM_RIGHT", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 447, + "column": 1, + "source_line": "#ifdef TE_POW_FROM_RIGHT" + } + }, + { + "directive": "else", + "argument": null, + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 502, + "column": 1, + "source_line": "#else" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 523, + "column": 1, + "source_line": "#endif" + } + } + ], + "macro_dependencies": [], + "diagnostics": [ + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'TYPE_MASK' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 78, + "column": 1, + "source_line": "#define TYPE_MASK(TYPE) ((TYPE)&0x0000001F)" + }, + "unit_kind": "macro", + "unit_name": "TYPE_MASK" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'IS_PURE' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 80, + "column": 1, + "source_line": "#define IS_PURE(TYPE) (((TYPE) & TE_FLAG_PURE) != 0)" + }, + "unit_kind": "macro", + "unit_name": "IS_PURE" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'IS_FUNCTION' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 81, + "column": 1, + "source_line": "#define IS_FUNCTION(TYPE) (((TYPE) & TE_FUNCTION0) != 0)" + }, + "unit_kind": "macro", + "unit_name": "IS_FUNCTION" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'IS_CLOSURE' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 82, + "column": 1, + "source_line": "#define IS_CLOSURE(TYPE) (((TYPE) & TE_CLOSURE0) != 0)" + }, + "unit_kind": "macro", + "unit_name": "IS_CLOSURE" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'ARITY' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 83, + "column": 1, + "source_line": "#define ARITY(TYPE) ( ((TYPE) & (TE_FUNCTION0 | TE_CLOSURE0)) ? ((TYPE) & 0x00000007) : 0 )" + }, + "unit_kind": "macro", + "unit_name": "ARITY" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'NEW_EXPR' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 84, + "column": 1, + "source_line": "#define NEW_EXPR(type, ...) new_expr((type), (const te_expr*[]){__VA_ARGS__})" + }, + "unit_kind": "macro", + "unit_name": "NEW_EXPR" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'CHECK_NULL' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 85, + "column": 1, + "source_line": "#define CHECK_NULL(ptr, ...) if ((ptr) == NULL) { __VA_ARGS__; return NULL; }" + }, + "unit_kind": "macro", + "unit_name": "CHECK_NULL" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'TE_FUN' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 592, + "column": 1, + "source_line": "#define TE_FUN(...) ((double(*)(__VA_ARGS__))n->function)" + }, + "unit_kind": "macro", + "unit_name": "TE_FUN" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'M' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 593, + "column": 1, + "source_line": "#define M(e) te_eval(n->parameters[e])" + }, + "unit_kind": "macro", + "unit_name": "M" + }, + { + "code": "C_UNSUPPORTED_FIELD_DECLARATION", + "message": "Nested aggregate field definitions are not supported yet.", + "severity": "warning", + "location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 70, + "column": 5, + "source_line": " union {double value; const double *bound; const void *function;};" + }, + "unit_kind": "struct_field", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 162, + "column": 1, + "source_line": "static const te_variable functions[] = {" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_DUPLICATE_FUNCTION_DEFINITION", + "message": "Duplicate definition for function 'factor'.", + "severity": "error", + "location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 503, + "column": 1, + "source_line": "static te_expr *factor(state *s) {" + }, + "unit_kind": "function", + "unit_name": "factor" + } + ] + }, + "tinyexpr/tinyexpr.h": { + "filename": "tinyexpr/tinyexpr.h", + "language": "c", + "parser_status": "partial", + "preprocessing": "raw", + "functions": [], + "structs": [], + "unions": [], + "enums": [], + "typedefs": [], + "variables": [], + "macros": [ + { + "name": "TINYEXPR_H", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "tinyexpr/tinyexpr.h", + "line": 27, + "column": 1, + "source_line": "#define TINYEXPR_H" + } + } + ], + "includes": [], + "raw_directives": [ + { + "directive": "ifndef", + "argument": "TINYEXPR_H", + "source_location": { + "filename": "tinyexpr/tinyexpr.h", + "line": 26, + "column": 1, + "source_line": "#ifndef TINYEXPR_H" + } + }, + { + "directive": "ifdef", + "argument": "__cplusplus", + "source_location": { + "filename": "tinyexpr/tinyexpr.h", + "line": 30, + "column": 1, + "source_line": "#ifdef __cplusplus" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "tinyexpr/tinyexpr.h", + "line": 32, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "ifdef", + "argument": "__cplusplus", + "source_location": { + "filename": "tinyexpr/tinyexpr.h", + "line": 83, + "column": 1, + "source_line": "#ifdef __cplusplus" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "tinyexpr/tinyexpr.h", + "line": 85, + "column": 1, + "source_line": "#endif" + } + }, + { + "directive": "endif", + "argument": null, + "source_location": { + "filename": "tinyexpr/tinyexpr.h", + "line": 87, + "column": 1, + "source_line": "#endif /*TINYEXPR_H*/" + } + } + ], + "macro_dependencies": [], + "diagnostics": [ + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '\"C\"'.", + "severity": "warning", + "location": { + "filename": "tinyexpr/tinyexpr.h", + "line": 31, + "column": 1, + "source_line": "extern \"C\" {" + }, + "unit_kind": "declarator", + "unit_name": null + } + ] + } + }, + "functions": { + "new_expr": { + "name": "new_expr", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "te_expr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "te_expr" + } + ] + }, + "parameters": [ + { + "name": "type", + "type": { + "model": "CInt", + "qualifiers": [ + "const" + ], + "source_text": "const int type" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [ + "const" + ], + "source_text": "const int type" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "parameters", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const te_expr *parameters[]", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "te_expr" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const te_expr *parameters[]", + "components": [ + { + "model": "CArray", + "qualifiers": [], + "source_text": "", + "bound": null, + "is_static_minimum": false, + "is_variable_length": false, + "is_flexible": false + }, + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "te_expr" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 87, + "column": 1, + "source_line": "static te_expr *new_expr(const int type, const te_expr *parameters[]) {" + }, + "start": { + "filename": "tinyexpr/tinyexpr.c", + "line": 87, + "column": 1, + "source_line": "static te_expr *new_expr(const int type, const te_expr *parameters[]) {" + }, + "end": { + "filename": "tinyexpr/tinyexpr.c", + "line": 101, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "te_free_parameters": { + "name": "te_free_parameters", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "n", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "te_expr *n", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "te_expr" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "te_expr *n", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "te_expr" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 104, + "column": 1, + "source_line": "void te_free_parameters(te_expr *n) {" + }, + "start": { + "filename": "tinyexpr/tinyexpr.c", + "line": 104, + "column": 1, + "source_line": "void te_free_parameters(te_expr *n) {" + }, + "end": { + "filename": "tinyexpr/tinyexpr.c", + "line": 115, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "te_free": { + "name": "te_free", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "n", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "te_expr *n", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "te_expr" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "te_expr *n", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "te_expr" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 118, + "column": 1, + "source_line": "void te_free(te_expr *n) {" + }, + "start": { + "filename": "tinyexpr/tinyexpr.c", + "line": 118, + "column": 1, + "source_line": "void te_free(te_expr *n) {" + }, + "end": { + "filename": "tinyexpr/tinyexpr.c", + "line": 122, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "pi": { + "name": "pi", + "result_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + }, + "parameters": [], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 125, + "column": 1, + "source_line": "static double pi(void) {return 3.14159265358979323846;}" + }, + "start": { + "filename": "tinyexpr/tinyexpr.c", + "line": 125, + "column": 1, + "source_line": "static double pi(void) {return 3.14159265358979323846;}" + }, + "end": { + "filename": "tinyexpr/tinyexpr.c", + "line": 125, + "column": 55, + "source_line": "static double pi(void) {return 3.14159265358979323846;}" + }, + "declaration_locations": [] + }, + "e": { + "name": "e", + "result_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + }, + "parameters": [], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 126, + "column": 1, + "source_line": "static double e(void) {return 2.71828182845904523536;}" + }, + "start": { + "filename": "tinyexpr/tinyexpr.c", + "line": 126, + "column": 1, + "source_line": "static double e(void) {return 2.71828182845904523536;}" + }, + "end": { + "filename": "tinyexpr/tinyexpr.c", + "line": 126, + "column": 54, + "source_line": "static double e(void) {return 2.71828182845904523536;}" + }, + "declaration_locations": [] + }, + "fac": { + "name": "fac", + "result_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double a" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double a" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 127, + "column": 1, + "source_line": "static double fac(double a) {/* simplest version of fac */" + }, + "start": { + "filename": "tinyexpr/tinyexpr.c", + "line": 127, + "column": 1, + "source_line": "static double fac(double a) {/* simplest version of fac */" + }, + "end": { + "filename": "tinyexpr/tinyexpr.c", + "line": 140, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "ncr": { + "name": "ncr", + "result_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + }, + "parameters": [ + { + "name": "n", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double n" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "r", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double r" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double r" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 141, + "column": 1, + "source_line": "static double ncr(double n, double r) {" + }, + "start": { + "filename": "tinyexpr/tinyexpr.c", + "line": 141, + "column": 1, + "source_line": "static double ncr(double n, double r) {" + }, + "end": { + "filename": "tinyexpr/tinyexpr.c", + "line": 154, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "npr": { + "name": "npr", + "result_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + }, + "parameters": [ + { + "name": "n", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double n" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double n" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "r", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double r" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double r" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 155, + "column": 1, + "source_line": "static double npr(double n, double r) {return ncr(n, r) * fac(r);}" + }, + "start": { + "filename": "tinyexpr/tinyexpr.c", + "line": 155, + "column": 1, + "source_line": "static double npr(double n, double r) {return ncr(n, r) * fac(r);}" + }, + "end": { + "filename": "tinyexpr/tinyexpr.c", + "line": 155, + "column": 66, + "source_line": "static double npr(double n, double r) {return ncr(n, r) * fac(r);}" + }, + "declaration_locations": [] + }, + "find_builtin": { + "name": "find_builtin", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const te_variable", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "te_variable" + } + ] + }, + "parameters": [ + { + "name": "name", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *name", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *name", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 195, + "column": 1, + "source_line": "static const te_variable *find_builtin(const char *name, int len) {" + }, + "start": { + "filename": "tinyexpr/tinyexpr.c", + "line": 195, + "column": 1, + "source_line": "static const te_variable *find_builtin(const char *name, int len) {" + }, + "end": { + "filename": "tinyexpr/tinyexpr.c", + "line": 214, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "find_lookup": { + "name": "find_lookup", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const te_variable", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "te_variable" + } + ] + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const state *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "state" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const state *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "state" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "name", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *name", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *name", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "len", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int len" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 216, + "column": 1, + "source_line": "static const te_variable *find_lookup(const state *s, const char *name, int len) {" + }, + "start": { + "filename": "tinyexpr/tinyexpr.c", + "line": 216, + "column": 1, + "source_line": "static const te_variable *find_lookup(const state *s, const char *name, int len) {" + }, + "end": { + "filename": "tinyexpr/tinyexpr.c", + "line": 227, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "add": { + "name": "add", + "result_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double a" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double a" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double b" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double b" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 231, + "column": 1, + "source_line": "static double add(double a, double b) {return a + b;}" + }, + "start": { + "filename": "tinyexpr/tinyexpr.c", + "line": 231, + "column": 1, + "source_line": "static double add(double a, double b) {return a + b;}" + }, + "end": { + "filename": "tinyexpr/tinyexpr.c", + "line": 231, + "column": 53, + "source_line": "static double add(double a, double b) {return a + b;}" + }, + "declaration_locations": [] + }, + "sub": { + "name": "sub", + "result_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double a" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double a" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double b" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double b" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 232, + "column": 1, + "source_line": "static double sub(double a, double b) {return a - b;}" + }, + "start": { + "filename": "tinyexpr/tinyexpr.c", + "line": 232, + "column": 1, + "source_line": "static double sub(double a, double b) {return a - b;}" + }, + "end": { + "filename": "tinyexpr/tinyexpr.c", + "line": 232, + "column": 53, + "source_line": "static double sub(double a, double b) {return a - b;}" + }, + "declaration_locations": [] + }, + "mul": { + "name": "mul", + "result_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double a" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double a" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double b" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double b" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 233, + "column": 1, + "source_line": "static double mul(double a, double b) {return a * b;}" + }, + "start": { + "filename": "tinyexpr/tinyexpr.c", + "line": 233, + "column": 1, + "source_line": "static double mul(double a, double b) {return a * b;}" + }, + "end": { + "filename": "tinyexpr/tinyexpr.c", + "line": 233, + "column": 53, + "source_line": "static double mul(double a, double b) {return a * b;}" + }, + "declaration_locations": [] + }, + "divide": { + "name": "divide", + "result_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double a" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double a" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double b" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double b" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 234, + "column": 1, + "source_line": "static double divide(double a, double b) {return a / b;}" + }, + "start": { + "filename": "tinyexpr/tinyexpr.c", + "line": 234, + "column": 1, + "source_line": "static double divide(double a, double b) {return a / b;}" + }, + "end": { + "filename": "tinyexpr/tinyexpr.c", + "line": 234, + "column": 56, + "source_line": "static double divide(double a, double b) {return a / b;}" + }, + "declaration_locations": [] + }, + "negate": { + "name": "negate", + "result_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double a" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double a" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 235, + "column": 1, + "source_line": "static double negate(double a) {return -a;}" + }, + "start": { + "filename": "tinyexpr/tinyexpr.c", + "line": 235, + "column": 1, + "source_line": "static double negate(double a) {return -a;}" + }, + "end": { + "filename": "tinyexpr/tinyexpr.c", + "line": 235, + "column": 43, + "source_line": "static double negate(double a) {return -a;}" + }, + "declaration_locations": [] + }, + "comma": { + "name": "comma", + "result_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + }, + "parameters": [ + { + "name": "a", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double a" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double a" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "b", + "type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double b" + }, + "declared_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double b" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 236, + "column": 1, + "source_line": "static double comma(double a, double b) {(void)a; return b;}" + }, + "start": { + "filename": "tinyexpr/tinyexpr.c", + "line": 236, + "column": 1, + "source_line": "static double comma(double a, double b) {(void)a; return b;}" + }, + "end": { + "filename": "tinyexpr/tinyexpr.c", + "line": 236, + "column": 60, + "source_line": "static double comma(double a, double b) {(void)a; return b;}" + }, + "declaration_locations": [] + }, + "next_token": { + "name": "next_token", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "state *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "state" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "state *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "state" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 239, + "column": 1, + "source_line": "void next_token(state *s) {" + }, + "start": { + "filename": "tinyexpr/tinyexpr.c", + "line": 239, + "column": 1, + "source_line": "void next_token(state *s) {" + }, + "end": { + "filename": "tinyexpr/tinyexpr.c", + "line": 303, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "list": { + "name": "list", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "te_expr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "te_expr" + } + ] + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "state *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "state" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "state *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "state" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 571, + "column": 1, + "source_line": "static te_expr *list(state *s) {" + }, + "start": { + "filename": "tinyexpr/tinyexpr.c", + "line": 571, + "column": 1, + "source_line": "static te_expr *list(state *s) {" + }, + "end": { + "filename": "tinyexpr/tinyexpr.c", + "line": 589, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "tinyexpr/tinyexpr.c", + "line": 306, + "column": 1, + "source_line": "static te_expr *list(state *s);" + } + ] + }, + "expr": { + "name": "expr", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "te_expr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "te_expr" + } + ] + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "state *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "state" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "state *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "state" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 549, + "column": 1, + "source_line": "static te_expr *expr(state *s) {" + }, + "start": { + "filename": "tinyexpr/tinyexpr.c", + "line": 549, + "column": 1, + "source_line": "static te_expr *expr(state *s) {" + }, + "end": { + "filename": "tinyexpr/tinyexpr.c", + "line": 568, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "tinyexpr/tinyexpr.c", + "line": 307, + "column": 1, + "source_line": "static te_expr *expr(state *s);" + } + ] + }, + "power": { + "name": "power", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "te_expr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "te_expr" + } + ] + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "state *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "state" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "state *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "state" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 422, + "column": 1, + "source_line": "static te_expr *power(state *s) {" + }, + "start": { + "filename": "tinyexpr/tinyexpr.c", + "line": 422, + "column": 1, + "source_line": "static te_expr *power(state *s) {" + }, + "end": { + "filename": "tinyexpr/tinyexpr.c", + "line": 445, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [ + { + "filename": "tinyexpr/tinyexpr.c", + "line": 308, + "column": 1, + "source_line": "static te_expr *power(state *s);" + } + ] + }, + "base": { + "name": "base", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "te_expr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "te_expr" + } + ] + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "state *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "state" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "state *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "state" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 310, + "column": 1, + "source_line": "static te_expr *base(state *s) {" + }, + "start": { + "filename": "tinyexpr/tinyexpr.c", + "line": 310, + "column": 1, + "source_line": "static te_expr *base(state *s) {" + }, + "end": { + "filename": "tinyexpr/tinyexpr.c", + "line": 419, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "factor": { + "name": "factor", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "te_expr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "te_expr" + } + ] + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "state *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "state" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "state *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "state" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 448, + "column": 1, + "source_line": "static te_expr *factor(state *s) {" + }, + "start": { + "filename": "tinyexpr/tinyexpr.c", + "line": 448, + "column": 1, + "source_line": "static te_expr *factor(state *s) {" + }, + "end": { + "filename": "tinyexpr/tinyexpr.c", + "line": 501, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "term": { + "name": "term", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "te_expr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "te_expr" + } + ] + }, + "parameters": [ + { + "name": "s", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "state *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "state" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "state *s", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "state" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 527, + "column": 1, + "source_line": "static te_expr *term(state *s) {" + }, + "start": { + "filename": "tinyexpr/tinyexpr.c", + "line": 527, + "column": 1, + "source_line": "static te_expr *term(state *s) {" + }, + "end": { + "filename": "tinyexpr/tinyexpr.c", + "line": 546, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "te_eval": { + "name": "te_eval", + "result_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + }, + "parameters": [ + { + "name": "n", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const te_expr *n", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "te_expr" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const te_expr *n", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "te_expr" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 596, + "column": 1, + "source_line": "double te_eval(const te_expr *n) {" + }, + "start": { + "filename": "tinyexpr/tinyexpr.c", + "line": 596, + "column": 1, + "source_line": "double te_eval(const te_expr *n) {" + }, + "end": { + "filename": "tinyexpr/tinyexpr.c", + "line": 634, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "optimize": { + "name": "optimize", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "n", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "te_expr *n", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "te_expr" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "te_expr *n", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "te_expr" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 639, + "column": 1, + "source_line": "static void optimize(te_expr *n) {" + }, + "start": { + "filename": "tinyexpr/tinyexpr.c", + "line": 639, + "column": 1, + "source_line": "static void optimize(te_expr *n) {" + }, + "end": { + "filename": "tinyexpr/tinyexpr.c", + "line": 662, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "te_compile": { + "name": "te_compile", + "result_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "te_expr", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "te_expr" + } + ] + }, + "parameters": [ + { + "name": "expression", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *expression", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *expression", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "variables", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const te_variable *variables", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "te_variable" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const te_variable *variables", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "te_variable" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "var_count", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int var_count" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int var_count" + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "error", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *error", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *error", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 665, + "column": 1, + "source_line": "te_expr *te_compile(const char *expression, const te_variable *variables, int var_count, int *error) {" + }, + "start": { + "filename": "tinyexpr/tinyexpr.c", + "line": 665, + "column": 1, + "source_line": "te_expr *te_compile(const char *expression, const te_variable *variables, int var_count, int *error) {" + }, + "end": { + "filename": "tinyexpr/tinyexpr.c", + "line": 690, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "te_interp": { + "name": "te_interp", + "result_type": { + "model": "CDouble", + "qualifiers": [], + "source_text": "double" + }, + "parameters": [ + { + "name": "expression", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *expression", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const char *expression", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CChar", + "qualifiers": [ + "const" + ], + "source_text": "const char" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "error", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *error", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "int *error", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "model": "CInt", + "qualifiers": [], + "source_text": "int" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 693, + "column": 1, + "source_line": "double te_interp(const char *expression, int *error) {" + }, + "start": { + "filename": "tinyexpr/tinyexpr.c", + "line": 693, + "column": 1, + "source_line": "double te_interp(const char *expression, int *error) {" + }, + "end": { + "filename": "tinyexpr/tinyexpr.c", + "line": 704, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "pn": { + "name": "pn", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "n", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const te_expr *n", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "te_expr" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const te_expr *n", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "te_expr" + } + ] + }, + "source_location": null, + "callback_policy": null + }, + { + "name": "depth", + "type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int depth" + }, + "declared_type": { + "model": "CInt", + "qualifiers": [], + "source_text": "int depth" + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [ + "static" + ], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 706, + "column": 1, + "source_line": "static void pn (const te_expr *n, int depth) {" + }, + "start": { + "filename": "tinyexpr/tinyexpr.c", + "line": 706, + "column": 1, + "source_line": "static void pn (const te_expr *n, int depth) {" + }, + "end": { + "filename": "tinyexpr/tinyexpr.c", + "line": 729, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + }, + "te_print": { + "name": "te_print", + "result_type": { + "model": "CVoid", + "qualifiers": [], + "source_text": "void" + }, + "parameters": [ + { + "name": "n", + "type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const te_expr *n", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "te_expr" + } + ] + }, + "declared_type": { + "model": "CComposedType", + "qualifiers": [], + "source_text": "const te_expr *n", + "components": [ + { + "model": "CPointer", + "qualifiers": [], + "source_text": "" + }, + { + "reference": "te_expr" + } + ] + }, + "source_location": null, + "callback_policy": null + } + ], + "storage": [], + "specifiers": [], + "is_variadic": false, + "is_definition": true, + "prototype_style": "prototype", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 732, + "column": 1, + "source_line": "void te_print(const te_expr *n) {" + }, + "start": { + "filename": "tinyexpr/tinyexpr.c", + "line": 732, + "column": 1, + "source_line": "void te_print(const te_expr *n) {" + }, + "end": { + "filename": "tinyexpr/tinyexpr.c", + "line": 734, + "column": 1, + "source_line": "}" + }, + "declaration_locations": [] + } + }, + "structs": { + "state": { + "reference": "struct state" + } + }, + "unions": {}, + "enums": {}, + "typedefs": { + "te_fun2": { + "reference": "te_fun2" + }, + "state": { + "reference": "state" + } + }, + "variables": {}, + "macros": { + "NAN": { + "name": "NAN", + "value": "(0.0/0.0)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 47, + "column": 1, + "source_line": "#define NAN (0.0/0.0)" + } + }, + "INFINITY": { + "name": "INFINITY", + "value": "(1.0/0.0)", + "function_like": false, + "directive": "define", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 51, + "column": 1, + "source_line": "#define INFINITY (1.0/0.0)" + } + }, + "TYPE_MASK": { + "name": "TYPE_MASK", + "value": "((TYPE)&0x0000001F)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 78, + "column": 1, + "source_line": "#define TYPE_MASK(TYPE) ((TYPE)&0x0000001F)" + } + }, + "IS_PURE": { + "name": "IS_PURE", + "value": "(((TYPE) & TE_FLAG_PURE) != 0)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 80, + "column": 1, + "source_line": "#define IS_PURE(TYPE) (((TYPE) & TE_FLAG_PURE) != 0)" + } + }, + "IS_FUNCTION": { + "name": "IS_FUNCTION", + "value": "(((TYPE) & TE_FUNCTION0) != 0)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 81, + "column": 1, + "source_line": "#define IS_FUNCTION(TYPE) (((TYPE) & TE_FUNCTION0) != 0)" + } + }, + "IS_CLOSURE": { + "name": "IS_CLOSURE", + "value": "(((TYPE) & TE_CLOSURE0) != 0)", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 82, + "column": 1, + "source_line": "#define IS_CLOSURE(TYPE) (((TYPE) & TE_CLOSURE0) != 0)" + } + }, + "ARITY": { + "name": "ARITY", + "value": "( ((TYPE) & (TE_FUNCTION0 | TE_CLOSURE0)) ? ((TYPE) & 0x00000007) : 0 )", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 83, + "column": 1, + "source_line": "#define ARITY(TYPE) ( ((TYPE) & (TE_FUNCTION0 | TE_CLOSURE0)) ? ((TYPE) & 0x00000007) : 0 )" + } + }, + "NEW_EXPR": { + "name": "NEW_EXPR", + "value": "new_expr((type), (const te_expr*[]){__VA_ARGS__})", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 84, + "column": 1, + "source_line": "#define NEW_EXPR(type, ...) new_expr((type), (const te_expr*[]){__VA_ARGS__})" + } + }, + "CHECK_NULL": { + "name": "CHECK_NULL", + "value": "if ((ptr) == NULL) { __VA_ARGS__; return NULL; }", + "function_like": true, + "directive": "define", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 85, + "column": 1, + "source_line": "#define CHECK_NULL(ptr, ...) if ((ptr) == NULL) { __VA_ARGS__; return NULL; }" + } + }, + "TE_FUN": { + "name": "TE_FUN", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 636, + "column": 1, + "source_line": "#undef TE_FUN" + } + }, + "M": { + "name": "M", + "value": null, + "function_like": false, + "directive": "undef", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 637, + "column": 1, + "source_line": "#undef M" + } + }, + "TINYEXPR_H": { + "name": "TINYEXPR_H", + "value": null, + "function_like": false, + "directive": "define", + "source_location": { + "filename": "tinyexpr/tinyexpr.h", + "line": 27, + "column": 1, + "source_line": "#define TINYEXPR_H" + } + } + }, + "includes": { + "tinyexpr/tinyexpr.c:tinyexpr.h": { + "target": "tinyexpr.h", + "kind": "local", + "resolved_path": "tinyexpr/tinyexpr.h", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 38, + "column": 1, + "source_line": "#include \"tinyexpr.h\"" + } + }, + "tinyexpr/tinyexpr.c:stdlib.h": { + "target": "stdlib.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 39, + "column": 1, + "source_line": "#include " + } + }, + "tinyexpr/tinyexpr.c:math.h": { + "target": "math.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 40, + "column": 1, + "source_line": "#include " + } + }, + "tinyexpr/tinyexpr.c:string.h": { + "target": "string.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 41, + "column": 1, + "source_line": "#include " + } + }, + "tinyexpr/tinyexpr.c:stdio.h": { + "target": "stdio.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 42, + "column": 1, + "source_line": "#include " + } + }, + "tinyexpr/tinyexpr.c:ctype.h": { + "target": "ctype.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 43, + "column": 1, + "source_line": "#include " + } + }, + "tinyexpr/tinyexpr.c:limits.h": { + "target": "limits.h", + "kind": "system", + "resolved_path": null, + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 44, + "column": 1, + "source_line": "#include " + } + } + }, + "functions_by_file": { + "tinyexpr/tinyexpr.c": [ + "new_expr", + "te_free_parameters", + "te_free", + "pi", + "e", + "fac", + "ncr", + "npr", + "find_builtin", + "find_lookup", + "add", + "sub", + "mul", + "divide", + "negate", + "comma", + "next_token", + "list", + "expr", + "power", + "base", + "factor", + "term", + "te_eval", + "optimize", + "te_compile", + "te_interp", + "pn", + "te_print" + ], + "tinyexpr/tinyexpr.h": [] + }, + "enum_constants": { + "TOK_NULL": { + "name": "TOK_NULL", + "value": "TE_CLOSURE7+1", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 57, + "column": 1, + "source_line": "enum {" + } + }, + "TOK_ERROR": { + "name": "TOK_ERROR", + "value": null, + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 57, + "column": 1, + "source_line": "enum {" + } + }, + "TOK_END": { + "name": "TOK_END", + "value": null, + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 57, + "column": 1, + "source_line": "enum {" + } + }, + "TOK_SEP": { + "name": "TOK_SEP", + "value": null, + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 57, + "column": 1, + "source_line": "enum {" + } + }, + "TOK_OPEN": { + "name": "TOK_OPEN", + "value": null, + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 57, + "column": 1, + "source_line": "enum {" + } + }, + "TOK_CLOSE": { + "name": "TOK_CLOSE", + "value": null, + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 57, + "column": 1, + "source_line": "enum {" + } + }, + "TOK_NUMBER": { + "name": "TOK_NUMBER", + "value": null, + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 57, + "column": 1, + "source_line": "enum {" + } + }, + "TOK_VARIABLE": { + "name": "TOK_VARIABLE", + "value": null, + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 57, + "column": 1, + "source_line": "enum {" + } + }, + "TOK_INFIX": { + "name": "TOK_INFIX", + "value": null, + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 57, + "column": 1, + "source_line": "enum {" + } + }, + "TE_CONSTANT": { + "name": "TE_CONSTANT", + "value": "1", + "source_location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 63, + "column": 1, + "source_line": "enum {TE_CONSTANT = 1};" + } + } + }, + "include_graph": { + "tinyexpr/tinyexpr.c": [ + "tinyexpr/tinyexpr.h" + ], + "tinyexpr/tinyexpr.h": [] + }, + "system_includes": { + "tinyexpr/tinyexpr.c": [ + "ctype.h", + "limits.h", + "math.h", + "stdio.h", + "stdlib.h", + "string.h" + ], + "tinyexpr/tinyexpr.h": [] + }, + "unresolved_includes": { + "tinyexpr/tinyexpr.c": [], + "tinyexpr/tinyexpr.h": [] + }, + "header_source_pairs": { + "tinyexpr/tinyexpr.h": [ + "tinyexpr/tinyexpr.c" + ] + }, + "diagnostics": [ + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'TYPE_MASK' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 78, + "column": 1, + "source_line": "#define TYPE_MASK(TYPE) ((TYPE)&0x0000001F)" + }, + "unit_kind": "macro", + "unit_name": "TYPE_MASK" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'IS_PURE' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 80, + "column": 1, + "source_line": "#define IS_PURE(TYPE) (((TYPE) & TE_FLAG_PURE) != 0)" + }, + "unit_kind": "macro", + "unit_name": "IS_PURE" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'IS_FUNCTION' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 81, + "column": 1, + "source_line": "#define IS_FUNCTION(TYPE) (((TYPE) & TE_FUNCTION0) != 0)" + }, + "unit_kind": "macro", + "unit_name": "IS_FUNCTION" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'IS_CLOSURE' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 82, + "column": 1, + "source_line": "#define IS_CLOSURE(TYPE) (((TYPE) & TE_CLOSURE0) != 0)" + }, + "unit_kind": "macro", + "unit_name": "IS_CLOSURE" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'ARITY' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 83, + "column": 1, + "source_line": "#define ARITY(TYPE) ( ((TYPE) & (TE_FUNCTION0 | TE_CLOSURE0)) ? ((TYPE) & 0x00000007) : 0 )" + }, + "unit_kind": "macro", + "unit_name": "ARITY" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'NEW_EXPR' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 84, + "column": 1, + "source_line": "#define NEW_EXPR(type, ...) new_expr((type), (const te_expr*[]){__VA_ARGS__})" + }, + "unit_kind": "macro", + "unit_name": "NEW_EXPR" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'CHECK_NULL' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 85, + "column": 1, + "source_line": "#define CHECK_NULL(ptr, ...) if ((ptr) == NULL) { __VA_ARGS__; return NULL; }" + }, + "unit_kind": "macro", + "unit_name": "CHECK_NULL" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'TE_FUN' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 592, + "column": 1, + "source_line": "#define TE_FUN(...) ((double(*)(__VA_ARGS__))n->function)" + }, + "unit_kind": "macro", + "unit_name": "TE_FUN" + }, + { + "code": "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "message": "Function-like macro 'M' is recorded but not expanded.", + "severity": "warning", + "location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 593, + "column": 1, + "source_line": "#define M(e) te_eval(n->parameters[e])" + }, + "unit_kind": "macro", + "unit_name": "M" + }, + { + "code": "C_UNSUPPORTED_FIELD_DECLARATION", + "message": "Nested aggregate field definitions are not supported yet.", + "severity": "warning", + "location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 70, + "column": 5, + "source_line": " union {double value; const double *bound; const void *function;};" + }, + "unit_kind": "struct_field", + "unit_name": null + }, + { + "code": "C_UNSUPPORTED_DECLARATION", + "message": "Braced or designated initializer declarations are not supported yet.", + "severity": "warning", + "location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 162, + "column": 1, + "source_line": "static const te_variable functions[] = {" + }, + "unit_kind": "braced_initializer_declaration", + "unit_name": null + }, + { + "code": "C_DUPLICATE_FUNCTION_DEFINITION", + "message": "Duplicate definition for function 'factor'.", + "severity": "error", + "location": { + "filename": "tinyexpr/tinyexpr.c", + "line": 503, + "column": 1, + "source_line": "static te_expr *factor(state *s) {" + }, + "unit_kind": "function", + "unit_name": "factor" + }, + { + "code": "C_UNSUPPORTED_DECLARATOR", + "message": "Unsupported declarator syntax after parsed type layers: '\"C\"'.", + "severity": "warning", + "location": { + "filename": "tinyexpr/tinyexpr.h", + "line": 31, + "column": 1, + "source_line": "extern \"C\" {" + }, + "unit_kind": "declarator", + "unit_name": null + } + ] +} diff --git a/tests/parser/c/generate_c_parser_goldens.py b/tests/parser/c/generate_c_parser_goldens.py new file mode 100644 index 000000000..a23c2b2e9 --- /dev/null +++ b/tests/parser/c/generate_c_parser_goldens.py @@ -0,0 +1,162 @@ +# -*- coding: utf-8 -*- +"""Generate/update golden files for grouped C parser fixture projects.""" + +from __future__ import annotations + +import json +import sys +from pathlib import Path + +from c_parser import parse_c_project + + +_TESTS_DIR = Path(__file__).resolve().parents[2] +_C_DATA_DIR = _TESTS_DIR / "data" / "c" +_FIXTURES_DIR = _TESTS_DIR / "parser" / "c" / "fixtures" +_FIXTURE_GROUPS = ("general", "json", "tinyexpr", "linmath", "nanosvg", "stb") +_SOURCE_SUFFIXES = {".c", ".h", ".i"} +_SOURCE_ORDER = {".c": 0, ".h": 1, ".i": 2} +_PROJECT_OVERRIDES = { + "nanosvg": { + "nanosvg": ("nanosvg.h", "nanosvgrast.h"), + }, +} + + +def _parser_filename_for_fixture(fixture: Path) -> str: + return fixture.relative_to(_C_DATA_DIR).as_posix() + + +def _fixture_sort_key(fixture: Path) -> tuple[int, str]: + return (_SOURCE_ORDER.get(fixture.suffix.lower(), 99), fixture.as_posix()) + + +def _project_key(fixture: Path) -> Path: + relative = fixture.relative_to(_C_DATA_DIR) + group = relative.parts[0] + for project_name, filenames in _PROJECT_OVERRIDES.get(group, {}).items(): + if relative.name in filenames: + return Path(group) / project_name + return relative.with_suffix("") + + +def _group_projects(fixtures: list[Path]) -> list[tuple[Path, list[Path]]]: + grouped: dict[Path, list[Path]] = {} + for fixture in sorted(fixtures, key=_fixture_sort_key): + grouped.setdefault(_project_key(fixture), []).append(fixture) + return [ + (project_key, _ordered_project_fixtures(project_key, project_fixtures)) + for project_key, project_fixtures in sorted(grouped.items()) + ] + + +def _ordered_project_fixtures(project_key: Path, fixtures: list[Path]) -> list[Path]: + group = project_key.parts[0] + override = _PROJECT_OVERRIDES.get(group, {}).get(project_key.name) + if override is not None: + order = {filename: index for index, filename in enumerate(override)} + return sorted(fixtures, key=lambda fixture: order[fixture.name]) + return sorted(fixtures, key=_fixture_sort_key) + + +def _normalize_resolved_paths(value): + if isinstance(value, dict): + resolved_path = value.get("resolved_path") + if resolved_path: + try: + value["resolved_path"] = Path(resolved_path).relative_to(_C_DATA_DIR).as_posix() + except ValueError: + pass + for key, nested in value.items(): + value[key] = _normalize_resolved_paths(nested) + elif isinstance(value, list): + return [_normalize_resolved_paths(nested) for nested in value] + elif isinstance(value, str): + try: + path = Path(value) + if path.is_absolute(): + return path.relative_to(_C_DATA_DIR).as_posix() + except ValueError: + pass + return value + + +def _serialize_project(fixtures: list[Path]) -> dict: + sources = { + _parser_filename_for_fixture(fixture): fixture.read_text(encoding="utf-8") + for fixture in sorted(fixtures, key=_fixture_sort_key) + } + include_dirs = sorted({fixture.parent for fixture in fixtures}) + parsed = parse_c_project(sources, include_dirs=include_dirs) + return _normalize_resolved_paths(parsed.to_dict()) + + +def _sibling_fixtures(fixture: Path) -> list[Path]: + relative = fixture.relative_to(_C_DATA_DIR) + group = relative.parts[0] + for filenames in _PROJECT_OVERRIDES.get(group, {}).values(): + if fixture.name in filenames: + return [fixture.parent / filename for filename in filenames] + return sorted( + ( + sibling + for sibling in fixture.parent.glob(f"{fixture.stem}.*") + if sibling.is_file() and sibling.suffix.lower() in _SOURCE_SUFFIXES + ), + key=_fixture_sort_key, + ) + + +def _default_projects() -> list[tuple[Path, list[Path]]]: + fixtures = [ + fixture + for group in _FIXTURE_GROUPS + for fixture in (_C_DATA_DIR / group).rglob("*") + if fixture.is_file() and fixture.suffix.lower() in _SOURCE_SUFFIXES + ] + return _group_projects(fixtures) + + +def _requested_projects(items: list[str]) -> list[tuple[Path, list[Path]]]: + fixtures: list[Path] = [] + for item in items: + fixture = Path(item) + if not fixture.is_absolute(): + fixture = _C_DATA_DIR / fixture + if fixture.suffix.lower() not in _SOURCE_SUFFIXES: + raise SystemExit(f"C fixtures must use .c, .h, or .i: {fixture}") + if not fixture.exists(): + raise SystemExit(f"Fixture does not exist: {fixture}") + fixtures.extend(_sibling_fixtures(fixture)) + return _group_projects(fixtures) + + +def _output_path_for_project(project_key: Path) -> Path: + return (_FIXTURES_DIR / project_key).with_suffix(".json") + + +def main() -> None: + requested = sys.argv[1:] + projects = _requested_projects(requested) if requested else _default_projects() + if not projects: + raise SystemExit("No C parser fixtures found") + + failures = [] + for project_key, fixtures in projects: + try: + payload = _serialize_project(fixtures) + out = _output_path_for_project(project_key) + out.parent.mkdir(parents=True, exist_ok=True) + out.write_text(json.dumps(payload, indent=2) + "\n", encoding="utf-8") + print(f"updated {out}") + except Exception as exc: + failures.append((project_key, exc)) + + if failures: + for project_key, exc in failures: + print(f"failed {project_key}: {exc}", file=sys.stderr) + raise SystemExit(1) + + +if __name__ == "__main__": + main() diff --git a/tests/parser/c/test_c_cli_skeleton.py b/tests/parser/c/test_c_cli_skeleton.py new file mode 100644 index 000000000..5145e8bfa --- /dev/null +++ b/tests/parser/c/test_c_cli_skeleton.py @@ -0,0 +1,258 @@ +# -*- coding: utf-8 -*- +"""C parser CLI coverage for the current partial subset.""" + +import json +import os +import subprocess +import sys +from pathlib import Path + + +def test_cli_help_shows_explicit_c_language_mode(): + cmd = [sys.executable, "-m", "x2py", "--help"] + + res = subprocess.run(cmd, capture_output=True, text=True, check=True) + + assert "--language" in res.stdout + assert "c" in res.stdout + + +def test_cli_c_parse_human_tree_output_for_header(tmp_path: Path): + header = tmp_path / "api.h" + header.write_text("int add(int a, int b);\n", encoding="utf-8") + cmd = [sys.executable, "-m", "x2py", str(header), "--language", "c", "--parse"] + + res = subprocess.run(cmd, capture_output=True, text=True, check=True) + + assert f"File: {header}" in res.stdout + assert "Language: c" in res.stdout + assert "Functions: 1" in res.stdout + assert "Parser status: partial" in res.stdout + + +def test_cli_c_parse_json_stdout_for_header(tmp_path: Path): + header = tmp_path / "api.h" + header.write_text("int add(int a, int b);\n", encoding="utf-8") + cmd = [sys.executable, "-m", "x2py", str(header), "--language", "c", "--parse", "--json"] + + res = subprocess.run(cmd, capture_output=True, text=True, check=True) + payload = json.loads(res.stdout) + file_payload = payload[str(header)] + + assert file_payload["language"] == "c" + assert file_payload["parser_status"] == "partial" + assert [fn["name"] for fn in file_payload["functions"]] == ["add"] + assert file_payload["structs"] == [] + assert file_payload["unions"] == [] + assert file_payload["enums"] == [] + assert file_payload["typedefs"] == [] + assert file_payload["variables"] == [] + assert file_payload["macros"] == [] + assert file_payload["includes"] == [] + assert file_payload["diagnostics"] == [] + + +def test_cli_c_parse_json_reports_raw_preprocessor_metadata(tmp_path: Path): + header = tmp_path / "api.h" + types = tmp_path / "api_types.h" + types.write_text("typedef int api_int;\n", encoding="utf-8") + header.write_text( + '#include "api_types.h"\n#define API_VERSION 3\n#define API_DECL(ret) ret\n', + encoding="utf-8", + ) + cmd = [sys.executable, "-m", "x2py", str(header), "--language", "c", "--parse", "--json"] + + res = subprocess.run(cmd, capture_output=True, text=True, check=True) + payload = json.loads(res.stdout) + file_payload = payload[str(header)] + + assert file_payload["includes"][0]["target"] == "api_types.h" + assert file_payload["includes"][0]["kind"] == "local" + assert file_payload["includes"][0]["resolved_path"] == str(types) + macros = {macro["name"]: macro for macro in file_payload["macros"]} + assert macros["API_VERSION"]["value"] == "3" + assert macros["API_DECL"]["function_like"] is True + assert file_payload["diagnostics"][0]["code"] == "C_UNSUPPORTED_FUNCTION_LIKE_MACRO" + + +def test_cli_c_parse_json_out_writes_file_and_suppresses_stdout(tmp_path: Path): + header = tmp_path / "api.h" + output = tmp_path / "report.json" + header.write_text("double scale(double x);\n", encoding="utf-8") + cmd = [ + sys.executable, + "-m", + "x2py", + str(header), + "--language", + "c", + "--parse", + "--json", + "--out", + str(output), + ] + + res = subprocess.run(cmd, capture_output=True, text=True, check=True) + payload = json.loads(output.read_text(encoding="utf-8")) + + assert res.stdout == "" + assert payload[str(header)]["language"] == "c" + assert payload[str(header)]["parser_status"] == "partial" + + +def test_cli_c_parse_out_without_json_writes_json_and_suppresses_stdout(tmp_path: Path): + header = tmp_path / "api.h" + output = tmp_path / "report.json" + header.write_text("int run(void);\n", encoding="utf-8") + cmd = [ + sys.executable, + "-m", + "x2py", + str(header), + "--language", + "c", + "--parse", + "--out", + str(output), + ] + + res = subprocess.run(cmd, capture_output=True, text=True, check=True) + payload = json.loads(output.read_text(encoding="utf-8")) + + assert res.stdout == "" + assert payload[str(header)]["parser_status"] == "partial" + + +def test_cli_c_semantic_stages_are_rejected_until_implemented(tmp_path: Path): + header = tmp_path / "api.h" + header.write_text("int add(int a, int b);\n", encoding="utf-8") + + for stage in ("--semantics", "--pyi", "--wrap-readiness"): + cmd = [sys.executable, "-m", "x2py", str(header), "--language", "c", stage] + res = subprocess.run(cmd, capture_output=True, text=True) + + assert res.returncode != 0 + assert "not supported" in res.stderr.lower() + + +def test_cli_c_rejects_fortran_only_parse_flags(tmp_path: Path): + header = tmp_path / "api.h" + header.write_text("int add(int a, int b);\n", encoding="utf-8") + cmd = [sys.executable, "-m", "x2py", str(header), "--language", "c", "--parse", "--show-vars"] + + res = subprocess.run(cmd, capture_output=True, text=True) + + assert res.returncode != 0 + assert "show-vars" in res.stderr + assert "Fortran-only" in res.stderr + + +def test_cli_c_no_color_and_debug_traceback_flags_are_accepted(tmp_path: Path): + header = tmp_path / "api.h" + header.write_text("int run(void);\n", encoding="utf-8") + cmd = [ + sys.executable, + "-m", + "x2py", + str(header), + "--language", + "c", + "--parse", + "--no-color", + "--debug-traceback", + ] + + res = subprocess.run(cmd, capture_output=True, text=True, check=True) + + assert "Parser status: partial" in res.stdout + + +def test_cli_c_no_color_and_no_color_env_format_parse_errors_without_ansi(tmp_path: Path): + source = tmp_path / "old_style.c" + source.write_text( + """ +int add(a, b) +int a; +int b; +{ + return a + b; +} +""", + encoding="utf-8", + ) + + base_cmd = [sys.executable, "-m", "x2py", str(source), "--language", "c", "--parse"] + no_color_res = subprocess.run( + [*base_cmd, "--no-color"], + capture_output=True, + text=True, + ) + env = {**os.environ, "NO_COLOR": "1"} + env_res = subprocess.run(base_cmd, capture_output=True, text=True, env=env) + + assert no_color_res.returncode == 1 + assert "K&R style function definitions are not supported" in no_color_res.stderr + assert "\x1b[" not in no_color_res.stderr + assert env_res.returncode == 1 + assert "K&R style function definitions are not supported" in env_res.stderr + assert "\x1b[" not in env_res.stderr + + +def test_cli_c_invalid_primitive_specifier_sequence_is_fatal(tmp_path: Path): + header = tmp_path / "invalid_specifiers.h" + header.write_text("unsigned float value;\n", encoding="utf-8") + cmd = [sys.executable, "-m", "x2py", str(header), "--language", "c", "--parse", "--no-color"] + + res = subprocess.run(cmd, capture_output=True, text=True) + + assert res.returncode == 1 + assert "error[CPARSE003]: Invalid type specifier sequence 'unsigned float'." in res.stderr + assert "\x1b[" not in res.stderr + + +def test_cli_c_debug_traceback_reraises_parse_errors(tmp_path: Path): + header = tmp_path / "invalid_specifiers.h" + header.write_text("unsigned float value;\n", encoding="utf-8") + cmd = [ + sys.executable, + "-m", + "x2py", + str(header), + "--language", + "c", + "--parse", + "--debug-traceback", + ] + + res = subprocess.run(cmd, capture_output=True, text=True) + + assert res.returncode == 1 + assert "Traceback" in res.stderr + assert "CParseError" in res.stderr + + +def test_cli_c_debug_env_reraises_parse_errors(tmp_path: Path): + header = tmp_path / "invalid_specifiers.h" + header.write_text("unsigned float value;\n", encoding="utf-8") + cmd = [sys.executable, "-m", "x2py", str(header), "--language", "c", "--parse"] + + res = subprocess.run( + cmd, + capture_output=True, + text=True, + env={**os.environ, "C_PARSER_DEBUG": "1"}, + ) + + assert res.returncode == 1 + assert "Traceback" in res.stderr + assert "CParseError" in res.stderr + + +def test_cli_without_language_keeps_fortran_default_behavior(): + fixture = Path(__file__).resolve().parents[2] / "data" / "fortran" / "general" / "basic_subroutine.f90" + cmd = [sys.executable, "-m", "x2py", str(fixture), "--parse"] + + res = subprocess.run(cmd, capture_output=True, text=True, check=True) + + assert "subroutine add1" in res.stdout + assert "Language: c" not in res.stdout diff --git a/tests/parser/c/test_c_corpus.py b/tests/parser/c/test_c_corpus.py new file mode 100644 index 000000000..dc8205d0e --- /dev/null +++ b/tests/parser/c/test_c_corpus.py @@ -0,0 +1,85 @@ +# -*- coding: utf-8 -*- +"""Planned C parser corpus tests. + +cJSON is the first target corpus because it is small, realistic, and exercises +headers, typedef structs, recursive pointers, function declarations, macros, +constants, and callback hook fields without requiring a large build system. +""" + +from pathlib import Path + +import pytest + +pytestmark = pytest.mark.skip( + reason="C parser corpus roadmap tests; unskip after fixture and corpus workflow exists." +) + + +_TESTS_DIR = Path(__file__).resolve().parents[2] +_CJSON_DIR = _TESTS_DIR / "data" / "c" / "corpus" / "cjson" + + +def test_cjson_corpus_files_are_pinned_and_provenanced(): + assert (_CJSON_DIR / "cJSON.h").exists() + assert (_CJSON_DIR / "cJSON.c").exists() + assert (_CJSON_DIR / "LICENSE").exists() + assert (_CJSON_DIR / "SOURCE.md").read_text(encoding="utf-8").strip() + + +def test_cjson_header_parse_records_public_functions_and_typedefs(): + from c_parser import parse_c_file + + parsed = parse_c_file(_CJSON_DIR / "cJSON.h") + + assert "cJSON_Parse" in {fn.name for fn in parsed.functions} + assert "cJSON" in {typedef.name for typedef in parsed.typedefs} + assert "cJSON_bool" in {typedef.name for typedef in parsed.typedefs} + + +def test_cjson_header_raw_mode_records_public_macro_wrappers(): + from c_parser import parse_c_file + + parsed = parse_c_file(_CJSON_DIR / "cJSON.h", preprocessing="raw") + + assert "CJSON_PUBLIC" in {macro.name for macro in parsed.macros} + assert any(diag.code == "C_MACRO_DECL_WRAPPER" for diag in parsed.diagnostics) + + +def test_cjson_header_preprocessed_mode_accepts_compiler_expanded_declarations(): + from c_parser import parse_c_file + + parsed = parse_c_file(_CJSON_DIR / "cJSON.h", preprocessing="compiler") + + assert "cJSON_ParseWithOpts" in {fn.name for fn in parsed.functions} + assert not any(diag.severity == "error" for diag in parsed.diagnostics) + + +def test_cjson_callback_hook_fields_are_modeled_with_policy_placeholders(): + from c_parser import parse_c_file + + parsed = parse_c_file(_CJSON_DIR / "cJSON.h") + + assert "cJSON_Hooks" in {struct.name for struct in parsed.structs} + hooks = next(struct for struct in parsed.structs if struct.name == "cJSON_Hooks") + callback_members = [member for member in hooks.members if member.callback_candidate] + assert callback_members + assert all(member.callback_policy is None for member in callback_members) + + +def test_cjson_source_file_parse_skips_function_bodies_safely(): + from c_parser import parse_c_file + + parsed = parse_c_file(_CJSON_DIR / "cJSON.c") + + assert any(fn.name == "cJSON_Parse" for fn in parsed.functions) + assert not any(hasattr(fn, "body") for fn in parsed.functions) + + +def test_cjson_project_parse_links_header_and_source(): + from c_parser import parse_c_project + + project = parse_c_project(_CJSON_DIR) + + assert "cJSON.h" in project.files + assert "cJSON.c" in project.files + assert project.header_source_pairs["cJSON.h"] == {"cJSON.c"} diff --git a/tests/parser/c/test_c_declarations_and_declarators.py b/tests/parser/c/test_c_declarations_and_declarators.py new file mode 100644 index 000000000..2814d8660 --- /dev/null +++ b/tests/parser/c/test_c_declarations_and_declarators.py @@ -0,0 +1,560 @@ +# -*- coding: utf-8 -*- +"""C declaration-specifier and composed-type parser tests.""" + +import pytest + + +def test_primitive_specifiers_create_concrete_primitive_types(): + from c_parser import CBool, CShort, CUnsignedLongLong, parse_c_file + + parsed = parse_c_file( + """ +unsigned long long next_id(void); +signed short clamp_short(signed short value); +_Bool enabled(void); +""", + filename="primitives.h", + ) + + functions = {function.name: function for function in parsed.functions} + assert isinstance(functions["next_id"].result_type, CUnsignedLongLong) + assert isinstance(functions["clamp_short"].parameters[0].type, CShort) + assert isinstance(functions["enabled"].result_type, CBool) + + +@pytest.mark.parametrize( + ("spelling", "expected_name"), + [ + ("void", "CVoid"), + ("_Bool", "CBool"), + ("char", "CChar"), + ("signed char", "CSignedChar"), + ("unsigned char", "CUnsignedChar"), + ("short", "CShort"), + ("short int", "CShort"), + ("signed short", "CShort"), + ("signed short int", "CShort"), + ("unsigned short", "CUnsignedShort"), + ("unsigned short int", "CUnsignedShort"), + ("int", "CInt"), + ("signed", "CInt"), + ("signed int", "CInt"), + ("unsigned", "CUnsignedInt"), + ("unsigned int", "CUnsignedInt"), + ("long", "CLong"), + ("long int", "CLong"), + ("signed long", "CLong"), + ("signed long int", "CLong"), + ("unsigned long", "CUnsignedLong"), + ("unsigned long int", "CUnsignedLong"), + ("long long", "CLongLong"), + ("long long int", "CLongLong"), + ("signed long long", "CLongLong"), + ("signed long long int", "CLongLong"), + ("unsigned long long", "CUnsignedLongLong"), + ("unsigned long long int", "CUnsignedLongLong"), + ("float", "CFloat"), + ("double", "CDouble"), + ("long double", "CLongDouble"), + ("float _Complex", "CFloatComplex"), + ("_Complex", "CDoubleComplex"), + ("double _Complex", "CDoubleComplex"), + ("long double _Complex", "CLongDoubleComplex"), + ], +) +def test_every_supported_primitive_spelling_creates_a_concrete_ctype(spelling, expected_name): + import c_parser + from c_parser import CType, parse_c_file + + function = parse_c_file(f"{spelling} primitive(void);\n", filename="primitive_table.h").functions[0] + expected = getattr(c_parser, expected_name) + + assert isinstance(function.result_type, expected) + assert isinstance(function.result_type, CType) + + +@pytest.mark.parametrize( + ("spelling", "expected_name"), + [ + ("int unsigned", "CUnsignedInt"), + ("int long unsigned", "CUnsignedLong"), + ("double long", "CLongDouble"), + ("_Complex float", "CFloatComplex"), + ], +) +def test_valid_reordered_primitive_specifiers_are_normalized(spelling, expected_name): + import c_parser + from c_parser import parse_c_file + + function = parse_c_file(f"{spelling} primitive(void);\n", filename="reordered_primitives.h").functions[0] + + assert isinstance(function.result_type, getattr(c_parser, expected_name)) + assert function.result_type.source_text == spelling + + +@pytest.mark.parametrize( + ("source", "expected_column"), + [ + ("unsigned float value;\n", 1), + ("void bad(long char value);\n", 1), + ("struct bad { signed unsigned value; };\n", 14), + ("unsigned float bad(void) { return 0; }\n", 1), + ], +) +def test_invalid_primitive_specifier_sequences_raise_parse_errors(source, expected_column): + from c_parser import CParseError, parse_c_file + + with pytest.raises(CParseError, match="Invalid type specifier sequence") as error: + parse_c_file(source, filename="invalid_specifiers.h") + + assert error.value.code == "CPARSE003" + assert ( + f"invalid_specifiers.h:1:{expected_column}: error[CPARSE003]" + in error.value.format_diagnostic(color=False) + ) + + +def test_unresolved_single_typedef_name_is_preserved_until_resolution(): + from c_parser import CTypedef, parse_c_file + + parsed = parse_c_file("external_type value;\n", filename="deferred_typedef.h") + + assert isinstance(parsed.variables[0].type, CTypedef) + assert parsed.variables[0].type.name == "external_type" + assert parsed.diagnostics == [] + + +def test_pointer_qualifiers_belong_to_the_component_they_qualify(): + from c_parser import CComposedType, CConst, CDouble, CPointer, CRestrict, parse_c_file + + parsed = parse_c_file( + "void copy(const double * restrict src, double * restrict dst);\n", + filename="qualifiers.h", + ) + + params = {parameter.name: parameter for parameter in parsed.functions[0].parameters} + src = params["src"].type + dst = params["dst"].type + assert isinstance(src, CComposedType) + assert isinstance(src.components[0], CPointer) + assert src.components[0].qualifiers == [CRestrict()] + assert isinstance(src.components[1], CDouble) + assert src.components[1].qualifiers == [CConst()] + assert dst.components[0].qualifiers == [CRestrict()] + + +def test_array_parameters_preserve_declarations_and_expose_adjusted_pointer_types(): + from c_parser import CArray, CComposedType, CConst, CDouble, CInt, CPointer, parse_c_file + + parsed = parse_c_file( + "void solve(size_t n, double a[static 4], const int shape[2], int work[const *], int matrix[3][4]);\n", + filename="arrays.h", + ) + + params = {parameter.name: parameter for parameter in parsed.functions[0].parameters} + a_declared = params["a"].declared_type + assert isinstance(a_declared, CComposedType) + assert [type(component) for component in a_declared.components] == [CArray, CDouble] + assert a_declared.components[0].bound == "4" + assert a_declared.components[0].is_static_minimum is True + assert [type(component) for component in params["a"].type.components] == [CPointer, CDouble] + + shape_declared = params["shape"].declared_type + assert shape_declared.components[0].bound == "2" + assert shape_declared.components[-1].qualifiers == [CConst()] + assert [type(component) for component in params["shape"].type.components] == [CPointer, CInt] + assert params["shape"].type.components[-1].qualifiers == [CConst()] + + work_declared = params["work"].declared_type + assert work_declared.components[0].qualifiers == [CConst()] + assert work_declared.components[0].is_variable_length is True + assert params["work"].type.components[0].qualifiers == [CConst()] + + matrix_declared = params["matrix"].declared_type + assert [type(component) for component in matrix_declared.components] == [CArray, CArray, CInt] + assert [component.bound for component in matrix_declared.components[:2]] == ["3", "4"] + assert [type(component) for component in params["matrix"].type.components] == [CPointer, CArray, CInt] + assert params["matrix"].type.components[1].bound == "4" + + +def test_multiple_declarators_share_specifiers_but_have_distinct_compositions(): + from c_parser import CArray, CComposedType, CConst, CInt, CPointer, parse_c_file + + parsed = parse_c_file("extern const int *left, right[4];\n", filename="variables.h") + + variables = {variable.name: variable for variable in parsed.variables} + assert variables["left"].storage == ["extern"] + assert isinstance(variables["left"].type, CComposedType) + assert [type(component) for component in variables["left"].type.components] == [CPointer, CInt] + assert [type(component) for component in variables["right"].type.components] == [CArray, CInt] + assert variables["right"].type.components[0].bound == "4" + assert variables["right"].type.components[-1].qualifiers == [CConst()] + + +def test_typedefs_and_typedef_references_are_concrete_types(): + from c_parser import CArray, CComposedType, CDouble, CPointer, CStruct, CTypedef, CUnsignedLong, parse_c_file + + parsed = parse_c_file( + """ +struct state; +typedef unsigned long api_size; +typedef const struct state *state_ref; +typedef double vector3[3]; +typedef vector3 basis3[3]; +state_ref current_state(void); +void set_basis(basis3 basis); +""", + filename="typedef_layers.h", + ) + + typedefs = {typedef.name: typedef for typedef in parsed.typedefs} + assert isinstance(typedefs["api_size"].type, CUnsignedLong) + state_ref = typedefs["state_ref"].type + assert isinstance(state_ref, CComposedType) + assert [type(component) for component in state_ref.components] == [CPointer, CStruct] + assert state_ref.components[-1].name == "state" + assert isinstance(typedefs["vector3"].type.components[0], CArray) + assert isinstance(typedefs["vector3"].type.components[-1], CDouble) + assert isinstance(typedefs["basis3"].type.components[-1], CTypedef) + assert typedefs["basis3"].type.components[-1].name == "vector3" + assert isinstance(parsed.functions[1].parameters[0].type, CTypedef) + + +def test_repeated_file_scope_tentative_variable_declarations_merge(): + from c_parser import parse_c_file + + parsed = parse_c_file("int i;\nint i;\n", filename="tentative.c") + + assert [variable.name for variable in parsed.variables] == ["i"] + assert parsed.variables[0].initializer is None + assert [location.line for location in parsed.variables[0].declaration_locations] == [2] + assert parsed.diagnostics == [] + + +def test_tentative_variable_declaration_followed_by_definition_prefers_definition(): + from c_parser import parse_c_file + + parsed = parse_c_file("int i;\nint i = 1;\n", filename="definition.c") + + assert [variable.name for variable in parsed.variables] == ["i"] + assert parsed.variables[0].initializer.source_text == "1" + assert parsed.variables[0].source_location.line == 2 + assert [location.line for location in parsed.variables[0].declaration_locations] == [1] + assert parsed.diagnostics == [] + + +def test_duplicate_initialized_file_scope_variables_report_diagnostic(): + from c_parser import parse_c_file + + parsed = parse_c_file("int i = 1;\nint i = 2;\n", filename="duplicate_variables.c") + + assert [variable.name for variable in parsed.variables] == ["i"] + assert parsed.variables[0].initializer.source_text == "1" + assert any(diag.code == "C_DUPLICATE_VARIABLE_DEFINITION" for diag in parsed.diagnostics) + + +def test_conflicting_file_scope_variable_declarations_report_diagnostic(): + from c_parser import parse_c_file + + parsed = parse_c_file("int i;\ndouble i;\n", filename="conflicting_variables.c") + + assert [variable.name for variable in parsed.variables] == ["i"] + assert any(diag.code == "C_CONFLICTING_VARIABLE_DECLARATION" for diag in parsed.diagnostics) + + +def test_compatible_repeated_typedefs_merge_but_conflicting_typedefs_diagnose(): + from c_parser import parse_c_file + + compatible = parse_c_file("typedef int count_t;\ntypedef int count_t;\n", filename="typedefs.h") + conflicting = parse_c_file("typedef int count_t;\ntypedef double count_t;\n", filename="bad_typedefs.h") + + assert [typedef.name for typedef in compatible.typedefs] == ["count_t"] + assert [location.line for location in compatible.typedefs[0].declaration_locations] == [2] + assert compatible.diagnostics == [] + assert any(diag.code == "C_CONFLICTING_TYPEDEF" for diag in conflicting.diagnostics) + + +def test_variables_preserve_initializer_text_arrays_and_concrete_tag_types(): + from c_parser import CArray, CComposedType, CEnum, CInt, CStruct, CUnion, parse_c_file + + parsed = parse_c_file( + """ +const struct state *global_state = 0; +volatile union scalar *global_scalar; +const enum status last_status = STATUS_OK; +double matrix[3][4]; +int answer = 42; +""", + filename="variables_richer.h", + ) + + variables = {variable.name: variable for variable in parsed.variables} + assert isinstance(variables["global_state"].type.components[-1], CStruct) + assert variables["global_state"].type.components[-1].name == "state" + assert variables["global_state"].initializer.source_text == "0" + assert isinstance(variables["global_scalar"].type.components[-1], CUnion) + assert isinstance(variables["last_status"].type, CEnum) + assert variables["last_status"].initializer.source_text == "STATUS_OK" + assert [component.bound for component in variables["matrix"].type.components[:2]] == ["3", "4"] + assert all(isinstance(component, CArray) for component in variables["matrix"].type.components[:2]) + assert isinstance(variables["answer"].type, CInt) + assert variables["answer"].initializer.source_text == "42" + + +def test_parameters_preserve_concrete_struct_union_and_enum_uses(): + from c_parser import CEnum, CStruct, CUnion, parse_c_file + + parsed = parse_c_file( + "void consume(const struct state *s, union scalar *u, enum status status);\n", + filename="tag_params.h", + ) + + params = {parameter.name: parameter for parameter in parsed.functions[0].parameters} + assert isinstance(params["s"].type.components[-1], CStruct) + assert params["s"].type.components[-1].name == "state" + assert isinstance(params["u"].type.components[-1], CUnion) + assert isinstance(params["status"].type, CEnum) + + +def test_incomplete_structs_and_pointer_uses_are_concrete_objects(): + from c_parser import CComposedType, CPointer, CStruct, parse_c_file + + parsed = parse_c_file( + """ +struct handle; +struct handle *open_handle(void); +void close_handle(struct handle *handle); +""", + filename="opaque.h", + ) + + handle = parsed.structs[0] + assert isinstance(handle, CStruct) + assert handle.name == "handle" + assert handle.is_incomplete is True + assert handle.members == [] + + functions = {function.name: function for function in parsed.functions} + result = functions["open_handle"].result_type + assert isinstance(result, CComposedType) + assert isinstance(result.components[0], CPointer) + assert isinstance(result.components[1], CStruct) + assert result.components[1].name == "handle" + + +def test_storage_is_declaration_metadata_and_qualifiers_are_type_metadata(): + from c_parser import CAtomic, CConst, CUnsignedLong, CVolatile, parse_c_file + + parsed = parse_c_file( + """ +extern int api_errno; +static const double scale_factor = 1.0; +_Thread_local unsigned long tls_counter; +register volatile int scratch; +_Atomic int atomic_counter; +""", + filename="storage_variables.h", + ) + + variables = {variable.name: variable for variable in parsed.variables} + assert variables["api_errno"].storage == ["extern"] + assert variables["scale_factor"].storage == ["static"] + assert variables["scale_factor"].type.qualifiers == [CConst()] + assert variables["tls_counter"].storage == ["_Thread_local"] + assert isinstance(variables["tls_counter"].type, CUnsignedLong) + assert variables["scratch"].storage == ["register"] + assert variables["scratch"].type.qualifiers == [CVolatile()] + assert variables["atomic_counter"].type.qualifiers == [CAtomic()] + + +def test_function_bodies_do_not_contribute_local_variables(): + from c_parser import parse_c_file + + parsed = parse_c_file( + """ +int compute(int x) { int local_value = x + 1; return local_value; } +extern int exported_value; +""", + filename="locals.c", + ) + + assert [variable.name for variable in parsed.variables] == ["exported_value"] + + +def test_declarations_return_concrete_objects_instead_of_kind_fields(): + from c_parser import CArray, CFunction, CFunctionType, CInt, CPointer, CStruct, CTypedef, CVariable, parse_c_file + + parsed = parse_c_file( + """ +struct handle; +typedef int (*compare_fn)(const void *, const void *); +extern int *values[4]; +extern int (*matrix)[4]; +int add(int a, int b); +void sort_items(int (*fallback)(const void *, const void *)); +""", + filename="declaration_matrix.h", + ) + + assert isinstance(parsed.structs[0], CStruct) + assert all(isinstance(typedef, CTypedef) for typedef in parsed.typedefs) + assert all(isinstance(variable, CVariable) for variable in parsed.variables) + assert all(isinstance(function, CFunction) for function in parsed.functions) + + compare = parsed.typedefs[0].type + assert [type(component) for component in compare.components] == [CPointer, CFunctionType] + values, matrix = parsed.variables + assert [type(component) for component in values.type.components] == [CArray, CPointer, CInt] + assert [type(component) for component in matrix.type.components] == [CPointer, CArray, CInt] + assert parsed.functions[1].parameters[0].callback_candidate is True + + +def test_composite_definitions_are_concrete_objects_and_static_assert_is_diagnostic(): + from c_parser import CEnum, CStruct, CUnion, CVariable, parse_c_file + + parsed = parse_c_file( + """ +struct point { double x; double y; }; +union value { int i; double d; }; +enum status { STATUS_OK = 0 }; +_Static_assert(sizeof(int) == 4, "expected int width"); +""", + filename="composites.h", + ) + + assert isinstance(parsed.structs[0], CStruct) + assert all(isinstance(member, CVariable) for member in parsed.structs[0].members) + assert [member.name for member in parsed.structs[0].members] == ["x", "y"] + assert isinstance(parsed.unions[0], CUnion) + assert isinstance(parsed.enums[0], CEnum) + assert [diagnostic.unit_kind for diagnostic in parsed.diagnostics] == ["static_assert"] + + +def test_parenthesized_declarators_preserve_pointer_array_order(): + from c_parser import CArray, CInt, CPointer, parse_c_file + + parsed = parse_c_file("extern int *values[4];\nextern int (*matrix)[4];\n", filename="paren_decl.h") + variables = {variable.name: variable for variable in parsed.variables} + + assert [type(component) for component in variables["values"].type.components] == [CArray, CPointer, CInt] + assert [type(component) for component in variables["matrix"].type.components] == [CPointer, CArray, CInt] + + +def test_function_type_discards_placeholder_parameter_names(): + from c_parser import CFunctionType, CPointer, parse_c_file + + parsed = parse_c_file( + "typedef int (*compare_fn)(const void *left, const void *right);\n", + filename="callback_typedef.h", + ) + + type_ = parsed.typedefs[0].type + assert isinstance(type_.components[0], CPointer) + signature = type_.components[1] + assert isinstance(signature, CFunctionType) + assert len(signature.parameter_types) == 2 + assert not hasattr(signature, "parameters") + + +def test_recursive_compositions_cover_tables_callback_arrays_and_function_results(): + from c_parser import CArray, CFunctionType, CInt, CPointer, parse_c_file + + parsed = parse_c_file( + """ +extern int *(*table)[4]; +typedef int (*callback_table[8])(int); +int (*factory(void))(int); +int direct(void), *value; +""", + filename="recursive_declarators.h", + ) + + variables = {variable.name: variable for variable in parsed.variables} + assert [type(component) for component in variables["table"].type.components] == [ + CPointer, + CArray, + CPointer, + CInt, + ] + assert [type(component) for component in variables["value"].type.components] == [CPointer, CInt] + callbacks = parsed.typedefs[0].type + assert [type(component) for component in callbacks.components] == [CArray, CPointer, CFunctionType] + functions = {function.name: function for function in parsed.functions} + assert set(functions) == {"factory", "direct"} + assert [type(component) for component in functions["factory"].result_type.components] == [ + CPointer, + CFunctionType, + ] + + +def test_unimplemented_declaration_extensions_are_diagnosed_not_partially_modeled(): + from c_parser import parse_c_file + + parsed = parse_c_file( + """ +int visible __attribute__((visibility("default"))); +int outdated [[deprecated]]; +_Alignas(16) int aligned_value; +_Atomic(int) atomic_value; +""", + filename="extensions.h", + ) + + assert parsed.variables == [] + assert [diagnostic.unit_kind for diagnostic in parsed.diagnostics] == [ + "attribute_declaration", + "attribute_declaration", + "alignment_declaration", + "atomic_type_declaration", + ] + + +def test_braced_initializer_declarations_are_diagnosed_not_declarator_failures(): + from c_parser import parse_c_file + + parsed = parse_c_file( + "struct config;\n" + "int values[3] = {1, 2, 3};\n" + "struct config cfg = {.enabled = 1};\n" + "int scalar = 1;\n", + filename="braced_initializers.h", + ) + + assert [variable.name for variable in parsed.variables] == ["scalar"] + assert [ + (diagnostic.code, diagnostic.unit_kind, diagnostic.location.line) + for diagnostic in parsed.diagnostics + ] == [ + ("C_UNSUPPORTED_DECLARATION", "braced_initializer_declaration", 2), + ("C_UNSUPPORTED_DECLARATION", "braced_initializer_declaration", 3), + ] + + +def test_unconsumed_declarator_suffixes_are_diagnosed_not_silently_discarded(): + from c_parser import parse_c_file + + parsed = parse_c_file( + 'extern int retained, pinned asm("r0");\nint run(int value asm("r0"));\n', + filename="declarator_extensions.h", + ) + + assert [variable.name for variable in parsed.variables] == ["retained"] + assert parsed.functions == [] + assert [diagnostic.code for diagnostic in parsed.diagnostics] == [ + "C_UNSUPPORTED_DECLARATOR", + "C_UNSUPPORTED_DECLARATOR", + ] + + +def test_storage_class_and_inline_specifiers_are_recorded_on_functions(): + from c_parser import parse_c_file + + parsed = parse_c_file( + "static inline int local_add(int a, int b) { return a + b; }\nextern int exported_add(int a, int b);\n", + filename="storage.c", + ) + + functions = {function.name: function for function in parsed.functions} + assert functions["local_add"].storage == ["static"] + assert "inline" in functions["local_add"].specifiers + assert functions["exported_add"].storage == ["extern"] diff --git a/tests/parser/c/test_c_error_fixture_suite.py b/tests/parser/c/test_c_error_fixture_suite.py new file mode 100644 index 000000000..ab6debf81 --- /dev/null +++ b/tests/parser/c/test_c_error_fixture_suite.py @@ -0,0 +1,84 @@ +# -*- coding: utf-8 -*- +"""C parser error fixture and diagnostic golden regression tests.""" + +import json +import os +from pathlib import Path + +import pytest + + +_TESTS_DIR = Path(__file__).resolve().parents[2] +_ERRORS_DIR = _TESTS_DIR / "data" / "c" / "errors" / "parser" +_EXPECTED_ERRORS_DIR = Path(__file__).parent / "fixtures" / "errors" +_SOURCE_SUFFIXES = {".c", ".h", ".i"} + + +def _expected_path_for_fixture(fixture: Path) -> Path: + return _EXPECTED_ERRORS_DIR / f"{fixture.name}.json" + + +def _load_expected_error(expected_path: Path) -> dict: + return json.loads(expected_path.read_text(encoding="utf-8")) + + +def test_c_error_fixture_suite_has_fixtures(): + fixtures = [path for path in _ERRORS_DIR.glob("*") if path.suffix.lower() in _SOURCE_SUFFIXES] + assert fixtures, "No C parser error fixtures found in tests/data/c/errors/parser" + + +def test_c_error_fixtures_have_matching_expected_json(): + if os.getenv("C_PARSER_UPDATE_GOLDENS", "0") == "1": + pytest.skip("Golden outputs are being updated by the diagnostic comparison test.") + + fixture_outputs = { + f"{path.name}.json" + for path in _ERRORS_DIR.glob("*") + if path.suffix.lower() in _SOURCE_SUFFIXES + } + expected_outputs = {path.name for path in _EXPECTED_ERRORS_DIR.glob("*.json")} + + assert not sorted(fixture_outputs - expected_outputs) + assert not sorted(expected_outputs - fixture_outputs) + + +def test_c_error_fixture_suite_reports_expected_diagnostics(): + from c_parser import CParseError, parse_c_file + + update_mode = os.getenv("C_PARSER_UPDATE_GOLDENS", "0") == "1" + + for fixture in sorted(_ERRORS_DIR.glob("*")): + if fixture.suffix.lower() not in _SOURCE_SUFFIXES: + continue + expected_path = _expected_path_for_fixture(fixture) + source = fixture.read_text(encoding="utf-8") + + if update_mode: + with pytest.raises(CParseError) as exc_info: + parse_c_file(source, filename=fixture.name) + payload = { + "parser": "parse_c_file", + "error_type": "CParseError", + "message_contains": [exc_info.value.base_message], + "diagnostic_contains": [ + f"error[{exc_info.value.code}]", + exc_info.value.base_message, + exc_info.value.source_line.strip() if exc_info.value.source_line else "", + ], + } + expected_path.parent.mkdir(parents=True, exist_ok=True) + expected_path.write_text(json.dumps(payload, indent=2) + "\n", encoding="utf-8") + continue + + expected = _load_expected_error(expected_path) + assert expected["parser"] == "parse_c_file" + assert expected["error_type"] == "CParseError" + with pytest.raises(CParseError) as exc_info: + parse_c_file(source, filename=fixture.name) + + for fragment in expected["message_contains"]: + assert fragment in str(exc_info.value) + diagnostic = exc_info.value.format_diagnostic(color=False) + for fragment in expected.get("diagnostic_contains", []): + if fragment: + assert fragment in diagnostic diff --git a/tests/parser/c/test_c_fixture_suite.py b/tests/parser/c/test_c_fixture_suite.py new file mode 100644 index 000000000..02b6a76c8 --- /dev/null +++ b/tests/parser/c/test_c_fixture_suite.py @@ -0,0 +1,177 @@ +# -*- coding: utf-8 -*- +"""C parser grouped-project fixture/golden regression tests.""" + +import json +import os +from pathlib import Path + +import pytest + +_TESTS_DIR = Path(__file__).resolve().parents[2] +_DATA_DIR = _TESTS_DIR / "data" / "c" +_FIXTURES_DIR = Path(__file__).parent / "fixtures" +_SOURCE_SUFFIXES = {".c", ".h", ".i"} +_SOURCE_ORDER = {".c": 0, ".h": 1, ".i": 2} +_FIXTURE_GROUPS = ("general", "json", "tinyexpr", "linmath", "nanosvg", "stb") +_PROJECT_OVERRIDES = { + "nanosvg": { + "nanosvg": ("nanosvg.h", "nanosvgrast.h"), + }, +} + + +def _parser_filename_for_fixture(fixture: Path) -> str: + return fixture.relative_to(_DATA_DIR).as_posix() + + +def _fixture_sort_key(fixture: Path) -> tuple[int, str]: + return (_SOURCE_ORDER.get(fixture.suffix.lower(), 99), fixture.as_posix()) + + +def _project_key(fixture: Path, root: Path) -> Path: + relative = fixture.relative_to(root) + for project_name, filenames in _PROJECT_OVERRIDES.get(root.name, {}).items(): + if relative.name in filenames: + return Path(project_name) + return relative.with_suffix("") + + +def _project_groups(root: Path) -> list[tuple[Path, list[Path]]]: + grouped: dict[Path, list[Path]] = {} + for fixture in sorted(root.rglob("*"), key=_fixture_sort_key): + if fixture.is_file() and fixture.suffix.lower() in _SOURCE_SUFFIXES: + grouped.setdefault(_project_key(fixture, root), []).append(fixture) + projects = [] + for project_key, fixtures in sorted(grouped.items()): + override = _PROJECT_OVERRIDES.get(root.name, {}).get(project_key.name) + if override is not None: + order = {filename: index for index, filename in enumerate(override)} + fixtures = sorted(fixtures, key=lambda fixture: order[fixture.name]) + else: + fixtures = sorted(fixtures, key=_fixture_sort_key) + projects.append((project_key, fixtures)) + return projects + + +def _source_json_relpaths(root: Path) -> set[Path]: + return {project_key.with_suffix(".json") for project_key, _ in _project_groups(root)} + + +def _fixture_json_relpaths(root: Path) -> set[Path]: + return {path.relative_to(root) for path in root.rglob("*.json") if path.is_file()} + + +def _expected_path_for_project(data_subdir: str, project_key: Path) -> Path: + return (_FIXTURES_DIR / data_subdir / project_key).with_suffix(".json") + + +def _normalize_resolved_paths(value): + if isinstance(value, dict): + resolved_path = value.get("resolved_path") + if resolved_path: + try: + value["resolved_path"] = Path(resolved_path).relative_to(_DATA_DIR).as_posix() + except ValueError: + pass + for key, nested in value.items(): + value[key] = _normalize_resolved_paths(nested) + elif isinstance(value, list): + return [_normalize_resolved_paths(nested) for nested in value] + elif isinstance(value, str): + try: + path = Path(value) + if path.is_absolute(): + return path.relative_to(_DATA_DIR).as_posix() + except ValueError: + pass + return value + + +def _parse_project(fixtures: list[Path]): + from c_parser import parse_c_project + + sources = { + _parser_filename_for_fixture(fixture): fixture.read_text(encoding="utf-8") + for fixture in sorted(fixtures, key=_fixture_sort_key) + } + include_dirs = sorted({fixture.parent for fixture in fixtures}) + return parse_c_project(sources, include_dirs=include_dirs) + + +def _serialize_project(fixtures: list[Path]) -> dict: + return _normalize_resolved_paths(_parse_project(fixtures).to_dict()) + + +@pytest.mark.parametrize("data_subdir", _FIXTURE_GROUPS) +def test_c_fixture_golden_suite_has_inputs(data_subdir): + fixtures = sorted((_DATA_DIR / data_subdir).glob("*")) + assert any(path.suffix.lower() in _SOURCE_SUFFIXES for path in fixtures) + + +@pytest.mark.parametrize("data_subdir", _FIXTURE_GROUPS) +def test_c_parser_project_goldens_match_fixture_stems_one_to_one(data_subdir): + if os.getenv("C_PARSER_UPDATE_GOLDENS", "0") == "1": + pytest.skip("Golden outputs are being updated by the comparison test.") + + data_root = _DATA_DIR / data_subdir + fixture_root = _FIXTURES_DIR / data_subdir + + expected = _source_json_relpaths(data_root) + actual = _fixture_json_relpaths(fixture_root) + + assert not sorted(expected - actual) + assert not sorted(actual - expected) + + +@pytest.mark.parametrize("data_subdir", _FIXTURE_GROUPS) +def test_c_fixture_golden_suite_compares_project_json(data_subdir): + update_mode = os.getenv("C_PARSER_UPDATE_GOLDENS", "0") == "1" + + for project_key, fixtures in _project_groups(_DATA_DIR / data_subdir): + expected_path = _expected_path_for_project(data_subdir, project_key) + parsed = _serialize_project(fixtures) + + if update_mode: + expected_path.parent.mkdir(parents=True, exist_ok=True) + expected_path.write_text(json.dumps(parsed, indent=2) + "\n", encoding="utf-8") + continue + + expected = json.loads(expected_path.read_text(encoding="utf-8")) + assert parsed == expected + + +def test_c_fixture_golden_suite_keeps_source_locations_stable(): + project = _parse_project( + [ + _DATA_DIR / "general" / "basic_array_update.h", + _DATA_DIR / "general" / "basic_array_update.c", + ] + ) + function = project.files["general/basic_array_update.h"].functions[0] + + assert function.source_location.filename == "general/basic_array_update.h" + assert function.source_location.line >= 1 + assert function.source_location.column >= 1 + + +def test_c_fixture_golden_suite_groups_matching_source_and_header_source_first(): + fixtures = [ + _DATA_DIR / "json" / "cJSON.h", + _DATA_DIR / "json" / "cJSON.c", + ] + project = _parse_project(fixtures) + + assert list(project.files) == ["json/cJSON.c", "json/cJSON.h"] + assert project.header_source_pairs["json/cJSON.h"] == {"json/cJSON.c"} + + +def test_c_fixture_golden_suite_groups_dependent_headers_dependency_first(): + project = _parse_project( + [ + _DATA_DIR / "nanosvg" / "nanosvg.h", + _DATA_DIR / "nanosvg" / "nanosvgrast.h", + ] + ) + + assert list(project.files) == ["nanosvg/nanosvg.h", "nanosvg/nanosvgrast.h"] + assert project.include_graph["nanosvg/nanosvgrast.h"] == {"nanosvg/nanosvg.h"} diff --git a/tests/parser/c/test_c_functions.py b/tests/parser/c/test_c_functions.py new file mode 100644 index 000000000..9131d368e --- /dev/null +++ b/tests/parser/c/test_c_functions.py @@ -0,0 +1,211 @@ +# -*- coding: utf-8 -*- +"""C function prototype and definition parser tests.""" + +import pytest + + +def test_named_function_exposes_result_type_named_parameters_and_derived_type(): + from c_parser import CDouble, CFunctionType, CTypedef, parse_c_file + + parsed = parse_c_file( + "double dot(size_t n, const double *x, const double *y);\n", + filename="functions.h", + ) + + function = parsed.functions[0] + assert function.name == "dot" + assert isinstance(function.result_type, CDouble) + assert [parameter.name for parameter in function.parameters] == ["n", "x", "y"] + assert isinstance(function.parameters[0].type, CTypedef) + assert isinstance(function.type, CFunctionType) + assert function.type.parameter_types == [parameter.type for parameter in function.parameters] + + +def test_function_definitions_skip_bodies_but_preserve_start_and_end_locations(): + from c_parser import parse_c_file + + parsed = parse_c_file( + """ +int add(int a, int b) +{ + return a + b; +} +""", + filename="definitions.c", + ) + + function = parsed.functions[0] + assert function.name == "add" + assert function.start is not None + assert function.end is not None + assert function.start.line == 2 + assert function.end.line == 5 + + +def test_void_parameter_list_and_empty_parameter_list_are_distinguished(): + from c_parser import parse_c_file + + parsed = parse_c_file("int explicit_void(void);\nint unspecified();\n", filename="void_params.h") + + functions = {function.name: function for function in parsed.functions} + assert functions["explicit_void"].parameters == [] + assert functions["explicit_void"].prototype_style == "prototype" + assert functions["unspecified"].prototype_style == "unspecified" + + +def test_variadic_functions_are_parsed_as_source_facts(): + from c_parser import parse_c_file + + parsed = parse_c_file("int log_msg(const char *fmt, ...);\n", filename="variadic.h") + + assert parsed.functions[0].is_variadic is True + assert parsed.functions[0].type.is_variadic is True + + +def test_old_style_knr_function_definition_raises_unsupported_diagnostic(): + from c_parser import CParseError, parse_c_file + + source = """ +int add(a, b) +int a; +int b; +{ + return a + b; +} +""" + + with pytest.raises(CParseError, match="K&R"): + parse_c_file(source, filename="knr.c") + + +def test_control_flow_conditions_inside_function_body_do_not_look_like_knr_definitions(): + from c_parser import parse_c_file + + parsed = parse_c_file( + """ +int evaluate(int value) +{ + if (value) + value = 1; + else if (value) + value = 2; + return value; +} +""", + filename="control_flow.c", + ) + + assert [function.name for function in parsed.functions] == ["evaluate"] + + +def test_function_pointer_parameter_is_a_callback_candidate_with_nameless_signature(): + from c_parser import CFunctionType, CInt, CPointer, parse_c_file + + parsed = parse_c_file( + "void sort_items(void *items, int (*compare)(const void *, const void *));\n", + filename="callbacks.h", + ) + + compare = parsed.functions[0].parameters[1] + assert compare.callback_candidate is True + assert compare.callback_policy is None + assert [type(component) for component in compare.type.components] == [CPointer, CFunctionType] + signature = compare.type.components[1] + assert isinstance(signature.result_type, CInt) + assert len(signature.parameter_types) == 2 + + +def test_function_parameter_preserves_declaration_and_adjusts_to_callback_pointer(): + from c_parser import CComposedType, CFunctionType, CPointer, parse_c_file + + parsed = parse_c_file("void apply(int callback(int));\n", filename="adjusted_callback.h") + + callback = parsed.functions[0].parameters[0] + assert isinstance(callback.declared_type, CFunctionType) + assert isinstance(callback.type, CComposedType) + assert [type(component) for component in callback.type.components] == [CPointer, CFunctionType] + assert callback.type.components[1] is callback.declared_type + assert callback.callback_candidate is True + assert parsed.functions[0].type.parameter_types[0] is callback.type + + +def test_project_resolves_callback_typedef_parameter_to_typedef_signature(): + from c_parser import CFunctionType, CTypedef, parse_c_project + + project = parse_c_project( + { + "callback_typedef.h": """ +typedef int (*compare_fn)(const void *a, const void *b); +void sort_items(void *items, compare_fn compare); +""" + } + ) + + referenced = project.functions["sort_items"].parameters[1].type + assert isinstance(referenced, CTypedef) + assert isinstance(referenced.type.components[1], CFunctionType) + + +def test_function_returning_pointer_to_const_struct_is_preserved(): + from c_parser import CComposedType, CConst, CPointer, CStruct, parse_c_file + + parsed = parse_c_file( + "struct state;\nconst struct state *current_state(void);\n", + filename="return_pointer.h", + ) + + result = parsed.functions[0].result_type + assert isinstance(result, CComposedType) + assert isinstance(result.components[0], CPointer) + assert isinstance(result.components[1], CStruct) + assert result.components[1].qualifiers == [CConst()] + + +def test_matching_prototype_and_definition_merge_and_prefer_definition(): + from c_parser import parse_c_file + + parsed = parse_c_file( + """ +int solve(int value); +int solve(int value) +{ + return value; +} +""", + filename="redeclarations.c", + ) + + assert [function.name for function in parsed.functions] == ["solve"] + function = parsed.functions[0] + assert function.is_definition is True + assert function.source_location.line == 3 + assert [location.line for location in function.declaration_locations] == [2] + assert parsed.diagnostics == [] + + +def test_conflicting_function_prototypes_report_diagnostic(): + from c_parser import parse_c_file + + parsed = parse_c_file( + "int work(int value);\ndouble work(double value);\n", + filename="conflicting_functions.h", + ) + + assert [function.name for function in parsed.functions] == ["work"] + assert any(diag.code == "C_CONFLICTING_FUNCTION_DECLARATION" for diag in parsed.diagnostics) + + +def test_duplicate_function_definitions_report_diagnostic(): + from c_parser import parse_c_file + + parsed = parse_c_file( + """ +int value(void) { return 1; } +int value(void) { return 2; } +""", + filename="duplicate_functions.c", + ) + + assert [function.name for function in parsed.functions] == ["value"] + assert parsed.functions[0].is_definition is True + assert any(diag.code == "C_DUPLICATE_FUNCTION_DEFINITION" for diag in parsed.diagnostics) diff --git a/tests/parser/c/test_c_json_sanity.py b/tests/parser/c/test_c_json_sanity.py new file mode 100644 index 000000000..581572f2c --- /dev/null +++ b/tests/parser/c/test_c_json_sanity.py @@ -0,0 +1,100 @@ +# -*- coding: utf-8 -*- +"""JSON schema sanity tests for C parser project goldens.""" + +import json +from pathlib import Path + +_FIXTURES_DIR = Path(__file__).parent / "fixtures" +_PARSER_FIXTURE_GROUPS = ("general", "json", "tinyexpr", "linmath", "nanosvg", "stb") + + +def _iter_project_payloads(): + for group in _PARSER_FIXTURE_GROUPS: + for path in (_FIXTURES_DIR / group).rglob("*.json"): + yield path, json.loads(path.read_text(encoding="utf-8")) + + +def _iter_file_payloads(): + for path, project in _iter_project_payloads(): + for filename, payload in project["files"].items(): + yield path, filename, payload + + +def test_c_json_fixtures_are_valid_json(): + for path in _FIXTURES_DIR.rglob("*.json"): + json.loads(path.read_text(encoding="utf-8")) + + +def test_c_json_project_fixtures_have_stable_top_level_shape(): + required_keys = { + "files", + "functions", + "structs", + "unions", + "enums", + "typedefs", + "variables", + "macros", + "includes", + "functions_by_file", + "enum_constants", + "include_graph", + "system_includes", + "unresolved_includes", + "header_source_pairs", + "diagnostics", + } + + for path, payload in _iter_project_payloads(): + assert required_keys <= set(payload), f"missing project keys in {path}" + + +def test_c_json_project_files_have_stable_c_file_shape(): + required_keys = { + "language", + "filename", + "functions", + "structs", + "unions", + "enums", + "typedefs", + "variables", + "macros", + "includes", + "diagnostics", + } + + for path, _, payload in _iter_file_payloads(): + assert required_keys <= set(payload), f"missing file keys in {path}" + assert payload["language"] == "c" + + +def test_c_json_functions_have_names_types_and_source_locations(): + for path, _, payload in _iter_file_payloads(): + for fn in payload.get("functions", []): + assert fn["name"], f"function without name in {path}" + assert fn["result_type"], f"function without result type in {path}" + assert isinstance(fn["parameters"], list) + assert fn["source_location"]["line"] >= 1 + assert fn["source_location"]["column"] >= 1 + + +def test_c_json_types_have_distinct_names_or_anonymous_ids(): + for path, _, payload in _iter_file_payloads(): + for key in ("structs", "unions", "enums"): + for entry in payload.get(key, []): + assert ( + entry.get("name") or entry.get("anonymous_id") or entry.get("reference") + ), f"anonymous {key} missing id in {path}" + + +def test_c_json_diagnostics_have_codes_locations_and_severities(): + allowed = {"info", "warning", "error"} + + for path, payload in _iter_project_payloads(): + for diagnostic in payload.get("diagnostics", []): + assert diagnostic["code"] + assert diagnostic["severity"] in allowed + assert diagnostic.get("message") + if diagnostic.get("location"): + assert diagnostic["location"]["line"] >= 1 diff --git a/tests/parser/c/test_c_lexer_preprocessor.py b/tests/parser/c/test_c_lexer_preprocessor.py new file mode 100644 index 000000000..8f73b24fa --- /dev/null +++ b/tests/parser/c/test_c_lexer_preprocessor.py @@ -0,0 +1,302 @@ +# -*- coding: utf-8 -*- +"""C lexer and lightweight preprocessing coverage.""" + +from pathlib import Path + +import pytest + + +def test_lexer_removes_comments_without_changing_string_or_char_literals(): + from c_parser.lexer import lex_c_source + + tokens = lex_c_source( + r''' +const char *url = "https://example.invalid/a//b"; +char slash = '/'; +/* removed block comment */ +int value; // removed line comment +''', + filename="comments.c", + ) + + spellings = [token.text for token in tokens] + assert '"https://example.invalid/a//b"' in spellings + assert "'/'" in spellings + assert "comment" not in spellings + + +def test_lexer_removes_multiline_block_comments_but_preserves_following_line_numbers(): + from c_parser.lexer import lex_c_source + + tokens = lex_c_source( + "int first;\n/* removed\n block */\nint second;\n", + filename="block_comments.c", + ) + + identifiers = [token for token in tokens if token.kind == "identifier"] + assert [token.text for token in identifiers] == ["int", "first", "int", "second"] + assert identifiers[-2].line == 4 + assert identifiers[-1].column == 5 + + +def test_line_continuations_preserve_original_line_numbers(): + from c_parser.preprocessor import normalize_c_source + + normalized = normalize_c_source( + "#define SUM(a, b) \\\n ((a) + (b))\nint x;\n", + filename="continuations.h", + ) + + assert normalized.records[0].original_start_line == 1 + assert normalized.records[0].original_end_line == 2 + assert normalized.records[1].original_start_line == 3 + + +def test_top_level_split_helpers_ignore_nested_commas_and_function_bodies(): + from c_parser.lexer import split_top_level_c_source, top_level_split + + assert top_level_split("int (*cmp)(int, int), int value") == [ + "int (*cmp)(int, int)", + "int value", + ] + + segments = split_top_level_c_source( + 'int add(int a, int b) { const char *s = "{;}"; return a + b; }\nint next(void);\n', + filename="split.c", + ) + + assert [(segment.text, segment.terminator) for segment in segments] == [ + ("int add(int a, int b)", "block"), + ("int next(void)", ";"), + ] + + +def test_raw_mode_records_includes_without_expanding_them(): + from c_parser import parse_c_file + + parsed = parse_c_file( + '#include "api_types.h"\n#include \nint run(void);\n', + filename="includes.h", + preprocessing="raw", + ) + + assert [include.target for include in parsed.includes] == ["api_types.h", "stddef.h"] + assert [include.kind for include in parsed.includes] == ["local", "system"] + + +def test_raw_mode_resolves_local_includes_relative_to_path_input(tmp_path): + from c_parser import parse_c_file + + header = tmp_path / "api.h" + types = tmp_path / "api_types.h" + header.write_text('#include "api_types.h"\n', encoding="utf-8") + types.write_text("typedef int api_int;\n", encoding="utf-8") + + parsed = parse_c_file(header) + + assert parsed.includes[0].resolved_path == str(types) + assert parsed.diagnostics == [] + + +def test_raw_mode_records_simple_object_like_macros_as_constants(): + from c_parser import parse_c_file + + parsed = parse_c_file( + """ +#define API_VERSION 3 +#define API_NAME "demo" +int version(void); +""", + filename="macros.h", + preprocessing="raw", + ) + + macros = {macro.name: macro for macro in parsed.macros} + assert macros["API_VERSION"].value == "3" + assert macros["API_NAME"].value == '"demo"' + assert macros["API_VERSION"].function_like is False + + +def test_raw_mode_records_undef_directives_as_macro_provenance(): + from c_parser import parse_c_file + + parsed = parse_c_file( + """ +#define API_FEATURE 1 +#undef API_FEATURE +""", + filename="undefs.h", + preprocessing="raw", + ) + + assert [(macro.name, macro.directive, macro.value) for macro in parsed.macros] == [ + ("API_FEATURE", "define", "1"), + ("API_FEATURE", "undef", None), + ] + + +def test_raw_mode_marks_function_like_macros_as_unsupported_until_expanded(): + from c_parser import parse_c_file + + parsed = parse_c_file( + """ +#define API_DECL(ret) ret +API_DECL(int) exported(void); +""", + filename="macro_decl.h", + preprocessing="raw", + ) + + macros = {macro.name: macro for macro in parsed.macros} + assert macros["API_DECL"].function_like is True + assert parsed.functions == [] + assert any(diag.code == "C_UNSUPPORTED_FUNCTION_LIKE_MACRO" for diag in parsed.diagnostics) + assert any(diag.code == "C_MACRO_DEPENDENT_DECLARATION" for diag in parsed.diagnostics) + + +def test_raw_mode_fixture_keeps_macro_shaped_declaration_deferred_until_preprocessing(): + from c_parser import parse_c_file + + fixture = ( + Path(__file__).resolve().parents[2] + / "data" + / "c" + / "general" + / "c_richer_features.h" + ) + + parsed = parse_c_file(fixture) + + function_names = {fn.name for fn in parsed.functions} + assert "x2py_sort" not in function_names + assert any( + diag.code == "C_UNSUPPORTED_FUNCTION_LIKE_MACRO" and diag.unit_name == "X2PY_API" + for diag in parsed.diagnostics + ) + assert any(macro.name == "X2PY_API" and macro.directive == "undef" for macro in parsed.macros) + + +def test_raw_conditional_directives_do_not_select_active_branches(): + from c_parser import parse_c_file + + parsed = parse_c_file( + """ +#ifdef USE_FAST +int run_fast(void); +#else +int run_slow(void); +#endif +""", + filename="conditional.h", + preprocessing="raw", + ) + + assert {fn.name for fn in parsed.functions} == {"run_fast", "run_slow"} + assert [(item.directive, item.argument) for item in parsed.raw_directives] == [ + ("ifdef", "USE_FAST"), + ("else", None), + ("endif", None), + ] + + +def test_raw_mode_records_macro_dependency_metadata_for_macro_shaped_declarations(): + from c_parser import parse_c_file + + parsed = parse_c_file( + """ +#define API_DECL(ret) ret +API_DECL(int) exported(void); +""", + filename="macro_dependency.h", + preprocessing="raw", + ) + + assert [(item.name, item.context) for item in parsed.macro_dependencies] == [ + ("API_DECL", "declaration") + ] + assert parsed.macro_dependencies[0].source_text == "API_DECL(int) exported(void)" + assert parsed.macro_dependencies[0].source_location.line == 3 + assert [(diag.code, diag.unit_kind, diag.unit_name) for diag in parsed.diagnostics] == [ + ("C_UNSUPPORTED_FUNCTION_LIKE_MACRO", "macro", "API_DECL"), + ("C_MACRO_DEPENDENT_DECLARATION", "macro_dependent_declaration", "API_DECL"), + ] + + +def test_raw_mode_conditional_macro_directive_is_not_treated_as_knr_function(): + from c_parser import parse_c_file + + parsed = parse_c_file( + """ +#define ENABLED(value) value +#if ENABLED(API) +typedef int api_value; +#endif +int run(void); +""", + filename="conditional_macro.h", + preprocessing="raw", + ) + + assert [function.name for function in parsed.functions] == ["run"] + assert any(macro.name == "ENABLED" for macro in parsed.macros) + + +def test_raw_mode_defers_declarations_prefixed_by_object_like_macros(): + from c_parser import parse_c_file + + parsed = parse_c_file( + """ +#define API_INLINE inline +static API_INLINE void run(void) {} +""", + filename="object_macro_decl.h", + preprocessing="raw", + ) + + assert parsed.functions == [] + assert [(item.name, item.context) for item in parsed.macro_dependencies] == [ + ("API_INLINE", "declaration") + ] + assert [(diag.code, diag.unit_kind, diag.unit_name) for diag in parsed.diagnostics] == [ + ("C_MACRO_DEPENDENT_DECLARATION", "macro_dependent_declaration", "API_INLINE"), + ] + + +def test_raw_mode_macro_initializers_do_not_hide_parseable_declarations(): + from c_parser import parse_c_file + + parsed = parse_c_file( + """ +#define INIT(value) value +int answer = INIT(42); +""", + filename="macro_initializer.h", + preprocessing="raw", + ) + + assert [variable.name for variable in parsed.variables] == ["answer"] + assert parsed.variables[0].initializer is not None + assert parsed.variables[0].initializer.source_text == "INIT(42)" + assert parsed.macro_dependencies == [] + assert [diagnostic.code for diagnostic in parsed.diagnostics] == [ + "C_UNSUPPORTED_FUNCTION_LIKE_MACRO" + ] + + +@pytest.mark.skip(reason="compiler-preprocessed mode lands after raw metadata collection.") +def test_compiler_preprocessed_mode_accepts_line_markers_and_expanded_declarations(): + from c_parser import parse_c_file + + parsed = parse_c_file( + """ +# 1 "api.h" +int exported(void); +# 20 "api.h" +double scale(double x); +""", + filename="api.i", + preprocessing="preprocessed", + ) + + assert [fn.name for fn in parsed.functions] == ["exported", "scale"] + assert parsed.functions[1].source_location.line == 20 diff --git a/tests/parser/c/test_c_project_resolution.py b/tests/parser/c/test_c_project_resolution.py new file mode 100644 index 000000000..709977fd0 --- /dev/null +++ b/tests/parser/c/test_c_project_resolution.py @@ -0,0 +1,287 @@ +# -*- coding: utf-8 -*- +"""Active coverage for current C project include/index behavior.""" + +from pathlib import Path + +import pytest + + +def test_project_include_graph_tracks_local_system_missing_and_cycles(tmp_path: Path): + from c_parser import parse_c_project + + (tmp_path / "a.h").write_text('#include "b.h"\n#include "missing.h"\n', encoding="utf-8") + (tmp_path / "b.h").write_text('#include "a.h"\n#include \n', encoding="utf-8") + + project = parse_c_project(tmp_path) + + assert project.include_graph["a.h"] == {"b.h", "missing.h"} + assert project.include_graph["b.h"] == {"a.h"} + assert project.system_includes["b.h"] == {"stddef.h"} + assert project.unresolved_includes["a.h"] == {"missing.h"} + assert any(diag.code == "C_UNRESOLVED_INCLUDE" for diag in project.files["a.h"].diagnostics) + + +def test_project_resolves_quoted_includes_through_include_dirs(tmp_path: Path): + from c_parser import parse_c_project + + include_dir = tmp_path / "include" + src_dir = tmp_path / "src" + include_dir.mkdir() + src_dir.mkdir() + types = include_dir / "types.h" + api = src_dir / "api.h" + types.write_text("typedef int api_int;\n", encoding="utf-8") + api.write_text('#include "types.h"\napi_int answer(void);\n', encoding="utf-8") + + project = parse_c_project([api], include_dirs=[include_dir]) + + include = project.files[str(api)].includes[0] + assert include.target == "types.h" + assert include.resolved_path == str(types) + assert project.unresolved_includes[str(api)] == set() + + +@pytest.mark.skip( + reason="Directory discovery of preprocessed .i inputs is deferred with preprocessed mode." +) +def test_parse_c_project_directory_discovers_preprocessed_i_files(tmp_path: Path): + from c_parser import parse_c_project + + (tmp_path / "api.c").write_text("int from_source(void);\n", encoding="utf-8") + (tmp_path / "generated.i").write_text("int generated(void);\n", encoding="utf-8") + + project = parse_c_project(tmp_path) + + assert set(project.files) == {"api.c", "generated.i"} + + +def test_project_indexes_functions_by_file_and_enum_constants(tmp_path: Path): + from c_parser import parse_c_project + + (tmp_path / "api.h").write_text( + "enum status { STATUS_OK = 0, STATUS_ERROR = -1 };\n" + "int run(void);\n" + "int stop(void);\n", + encoding="utf-8", + ) + + project = parse_c_project(tmp_path) + + assert project.functions_by_file["api.h"] == ["run", "stop"] + assert set(project.enum_constants) == {"STATUS_OK", "STATUS_ERROR"} + assert project.enum_constants["STATUS_OK"].value == "0" + + +def test_project_indexes_file_scope_variables_and_macros(tmp_path: Path): + from c_parser import parse_c_project + + (tmp_path / "api.h").write_text( + "#define API_VERSION 3\n" + "extern int global_count;\n", + encoding="utf-8", + ) + + project = parse_c_project(tmp_path) + + assert project.variables["global_count"].storage == ["extern"] + assert project.macros["API_VERSION"].value == "3" + + +def test_project_function_index_prefers_definition_over_compatible_prototype(tmp_path: Path): + from c_parser import parse_c_project + + (tmp_path / "api.h").write_text("int solve(int value);\n", encoding="utf-8") + (tmp_path / "api.c").write_text("int solve(int value) { return value; }\n", encoding="utf-8") + + project = parse_c_project(tmp_path) + + assert project.functions["solve"].is_definition is True + assert project.functions["solve"].declaration_locations + assert not any(diag.code.startswith("C_CONFLICTING") for diag in project.diagnostics) + + +def test_project_reports_conflicting_function_declarations(tmp_path: Path): + from c_parser import parse_c_project + + (tmp_path / "a.h").write_text("int work(int value);\n", encoding="utf-8") + (tmp_path / "b.h").write_text("double work(double value);\n", encoding="utf-8") + + project = parse_c_project(tmp_path) + + assert any(diag.code == "C_CONFLICTING_FUNCTION_DECLARATION" for diag in project.diagnostics) + + +def test_project_resolves_typedefs_and_struct_tags_across_files(tmp_path: Path): + from c_parser import CComposedType, CTypedef, parse_c_project + + (tmp_path / "types.h").write_text( + "typedef unsigned long api_size;\n" + "struct state { int id; };\n", + encoding="utf-8", + ) + (tmp_path / "api.h").write_text( + '#include "types.h"\n' + "api_size count(void);\n" + "void step(struct state *s);\n", + encoding="utf-8", + ) + + project = parse_c_project(tmp_path) + + assert isinstance(project.functions["count"].result_type, CTypedef) + assert project.functions["count"].result_type is project.typedefs["api_size"] + param_type = project.functions["step"].parameters[0].type + assert isinstance(param_type, CComposedType) + assert param_type.components[-1] is project.structs["state"] + + +def test_project_completes_forward_struct_tags_regardless_of_file_order(): + from c_parser import CComposedType, parse_c_project + + project = parse_c_project( + { + "forward.h": "struct state;\nvoid step(struct state *s);\n", + "definition.h": "struct state { int id; };\n", + } + ) + + assert project.structs["state"].is_incomplete is False + assert project.structs["state"].members[0].name == "id" + param_type = project.functions["step"].parameters[0].type + assert isinstance(param_type, CComposedType) + assert param_type.components[-1] is project.structs["state"] + + +def test_project_keeps_complete_union_definition_when_forward_seen_later(): + from c_parser import CComposedType, parse_c_project + + project = parse_c_project( + { + "definition.h": "union value { int i; };\n", + "forward.h": "union value;\nvoid set_value(union value *v);\n", + } + ) + + assert project.unions["value"].is_incomplete is False + assert project.unions["value"].members[0].name == "i" + param_type = project.functions["set_value"].parameters[0].type + assert isinstance(param_type, CComposedType) + assert param_type.components[-1] is project.unions["value"] + + +def test_project_resolves_typedef_chains_while_preserving_alias_objects(tmp_path: Path): + from c_parser import CTypedef, CUnsignedLong, parse_c_project + + (tmp_path / "types.h").write_text( + "typedef unsigned long raw_size;\n" + "typedef raw_size api_size;\n", + encoding="utf-8", + ) + (tmp_path / "api.h").write_text("api_size count(void);\n", encoding="utf-8") + + project = parse_c_project(tmp_path) + + assert project.typedefs["api_size"].type is project.typedefs["raw_size"] + assert isinstance(project.typedefs["raw_size"].type, CUnsignedLong) + assert isinstance(project.functions["count"].result_type, CTypedef) + assert project.functions["count"].result_type is project.typedefs["api_size"] + assert project.functions["count"].result_type.source_text == "api_size" + + +def test_project_reports_typedef_cycles_without_crashing(): + from c_parser import parse_c_project + + project = parse_c_project({"cycle.h": "typedef b a;\ntypedef a b;\n"}) + + assert {diag.code for diag in project.diagnostics} == {"C_TYPEDEF_CYCLE"} + + +def test_project_resolves_union_and_enum_tag_references(tmp_path: Path): + from c_parser import CComposedType, parse_c_project + + (tmp_path / "types.h").write_text( + "union value { int i; };\n" + "enum status { STATUS_OK = 0 };\n", + encoding="utf-8", + ) + (tmp_path / "api.h").write_text( + "void set_value(union value *v);\n" + "enum status current_status(void);\n", + encoding="utf-8", + ) + + project = parse_c_project(tmp_path) + + value_type = project.functions["set_value"].parameters[0].type + assert isinstance(value_type, CComposedType) + assert value_type.components[-1] is project.unions["value"] + assert project.functions["current_status"].result_type is project.enums["status"] + + +def test_project_resolves_opaque_pointer_typedefs_across_files(tmp_path: Path): + from c_parser import CComposedType, CTypedef, parse_c_project + + (tmp_path / "types.h").write_text( + "struct handle;\n" + "typedef struct handle *handle_t;\n", + encoding="utf-8", + ) + (tmp_path / "api.h").write_text("handle_t open_handle(void);\n", encoding="utf-8") + + project = parse_c_project(tmp_path) + + assert project.typedefs["handle_t"].type.components[-1] is project.structs["handle"] + assert project.structs["handle"].is_incomplete is True + assert isinstance(project.functions["open_handle"].result_type, CTypedef) + assert project.functions["open_handle"].result_type is project.typedefs["handle_t"] + assert isinstance(project.typedefs["handle_t"].type, CComposedType) + + +def test_project_preserves_unresolved_type_references_for_later_diagnostics(): + from c_parser import CTypedef, parse_c_project + + project = parse_c_project({"api.h": "missing_type value(void);\n"}) + + assert isinstance(project.functions["value"].result_type, CTypedef) + assert project.functions["value"].result_type.name == "missing_type" + assert project.functions["value"].result_type.type is None + + +def test_project_header_source_pairs_use_matching_stems_and_direct_includes(tmp_path: Path): + from c_parser import parse_c_project + + (tmp_path / "solver.h").write_text("int solve(void);\n", encoding="utf-8") + (tmp_path / "solver.c").write_text('#include "solver.h"\n', encoding="utf-8") + (tmp_path / "driver.h").write_text("int drive(void);\n", encoding="utf-8") + (tmp_path / "main.c").write_text('#include "driver.h"\n', encoding="utf-8") + + project = parse_c_project(tmp_path) + + assert project.header_source_pairs["solver.h"] == {"solver.c"} + assert project.header_source_pairs["driver.h"] == {"main.c"} + + +def test_project_header_source_pairs_preserve_many_to_many_relationships(tmp_path: Path): + from c_parser import parse_c_project + + (tmp_path / "a.h").write_text("int a(void);\n", encoding="utf-8") + (tmp_path / "b.h").write_text("int b(void);\n", encoding="utf-8") + (tmp_path / "one.c").write_text('#include "a.h"\n#include "b.h"\n', encoding="utf-8") + (tmp_path / "two.c").write_text('#include "a.h"\n', encoding="utf-8") + + project = parse_c_project(tmp_path) + + assert project.header_source_pairs["a.h"] == {"one.c", "two.c"} + assert project.header_source_pairs["b.h"] == {"one.c"} + + +def test_project_serialization_keeps_include_indexes_json_stable(tmp_path: Path): + from c_parser import parse_c_project + + (tmp_path / "api.h").write_text("#include \nint run(void);\n", encoding="utf-8") + + payload = parse_c_project(tmp_path).to_dict() + + assert payload["include_graph"] == {"api.h": []} + assert payload["system_includes"] == {"api.h": ["stddef.h"]} + assert payload["functions_by_file"] == {"api.h": ["run"]} diff --git a/tests/parser/c/test_c_public_api_skeleton.py b/tests/parser/c/test_c_public_api_skeleton.py new file mode 100644 index 000000000..8e2d4f603 --- /dev/null +++ b/tests/parser/c/test_c_public_api_skeleton.py @@ -0,0 +1,269 @@ +# -*- coding: utf-8 -*- +"""C parser public API coverage for the current partial subset.""" + +from pathlib import Path + + +def test_parse_c_file_accepts_inline_source_and_returns_typed_model(): + from c_parser import CFile, parse_c_file + + parsed = parse_c_file("int add(int a, int b);\n", filename="inline.h") + + assert isinstance(parsed, CFile) + assert parsed.filename == "inline.h" + assert parsed.language == "c" + assert parsed.parser_status == "partial" + assert [fn.name for fn in parsed.functions] == ["add"] + + +def test_parse_c_file_accepts_path_input_and_preserves_filename(tmp_path: Path): + from c_parser import parse_c_file + + header = tmp_path / "api.h" + header.write_text("double scale(double x);\n", encoding="utf-8") + + parsed = parse_c_file(header) + + assert parsed.filename == str(header) + assert [fn.name for fn in parsed.functions] == ["scale"] + + +def test_parse_c_file_accepts_empty_source_and_unknown_suffix(): + from c_parser import parse_c_file + + parsed = parse_c_file("", filename="empty.src") + + assert parsed.filename == "empty.src" + assert parsed.functions == [] + assert parsed.diagnostics == [] + + +def test_parse_c_project_accepts_mapping_sources(): + from c_parser import CProject, parse_c_project + + project = parse_c_project( + { + "types.h": "typedef int api_int;\n", + "api.h": '#include "types.h"\napi_int answer(void);\n', + } + ) + + assert isinstance(project, CProject) + assert set(project.files) == {"types.h", "api.h"} + assert project.files["api.h"].language == "c" + assert set(project.functions) == {"answer"} + + +def test_parse_c_project_indexes_forward_structs_by_tag_name(): + from c_parser import parse_c_project + + project = parse_c_project( + { + "types.h": "struct handle;\n", + "api.h": "struct handle *open_handle(void);\n", + } + ) + + assert set(project.structs) == {"handle"} + assert project.structs["handle"].is_incomplete is True + assert project.files["types.h"].structs[0].name == "handle" + + +def test_parse_c_project_indexes_named_union_and_enum_tags(): + from c_parser import parse_c_project + + project = parse_c_project( + { + "types.h": "union value { int i; }; enum status { STATUS_OK = 0 };", + } + ) + + assert set(project.unions) == {"value"} + assert set(project.enums) == {"status"} + + +def test_parse_c_project_accepts_directory_input_with_c_and_h_files(tmp_path: Path): + from c_parser import parse_c_project + + (tmp_path / "api.h").write_text("int add(int a, int b);\n", encoding="utf-8") + (tmp_path / "api.c").write_text('#include "api.h"\n', encoding="utf-8") + (tmp_path / "notes.txt").write_text("ignored\n", encoding="utf-8") + + project = parse_c_project(tmp_path) + + assert set(project.files) == {"api.h", "api.c"} + + +def test_c_file_serialization_is_json_stable(): + from c_parser import parse_c_file + + parsed = parse_c_file("", filename="empty.c") + + assert parsed.to_dict() == { + "filename": "empty.c", + "language": "c", + "parser_status": "partial", + "preprocessing": "raw", + "functions": [], + "structs": [], + "unions": [], + "enums": [], + "typedefs": [], + "variables": [], + "macros": [], + "includes": [], + "raw_directives": [], + "macro_dependencies": [], + "diagnostics": [], + } + + +def test_concrete_type_serialization_preserves_semantic_type_fields_and_locations(): + from c_parser import parse_c_file + + parsed = parse_c_file( + "typedef int (*compare_fn)(const void *, const void *);\n" + "compare_fn select_compare(void);\n", + filename="types.h", + ) + payload = parsed.to_dict() + + typedef = payload["typedefs"][0] + assert typedef["model"] == "CTypedef" + assert typedef["type"]["model"] == "CComposedType" + assert typedef["type"]["components"][0]["model"] == "CPointer" + assert typedef["type"]["components"][1]["model"] == "CFunctionType" + assert typedef["type"]["components"][1]["result_type"]["model"] == "CInt" + first_parameter = typedef["type"]["components"][1]["parameter_types"][0] + assert first_parameter["components"][-1]["qualifiers"] == ["const"] + assert typedef["source_location"]["filename"] == "types.h" + assert typedef["source_location"]["line"] == 1 + + function = payload["functions"][0] + assert function["result_type"]["model"] == "CTypedef" + assert function["result_type"]["name"] == "compare_fn" + assert function["source_location"]["line"] == 2 + + +def test_parameter_adjustment_serialization_preserves_declared_and_effective_types(): + from c_parser import parse_c_file + + payload = parse_c_file( + "void process(int values[4], int callback(int));\n", + filename="adjustment.h", + ).to_dict() + values, callback = payload["functions"][0]["parameters"] + + assert values["declared_type"]["components"][0]["model"] == "CArray" + assert values["declared_type"]["components"][0]["bound"] == "4" + assert values["type"]["components"][0]["model"] == "CPointer" + assert callback["declared_type"]["model"] == "CFunctionType" + assert callback["type"]["components"][0]["model"] == "CPointer" + assert callback["type"]["components"][1]["model"] == "CFunctionType" + + +def test_inline_aggregate_typedef_serialization_uses_references_without_cycles(): + from c_parser import parse_c_file + + payload = parse_c_file( + "typedef struct node { struct node *next; } node_t;\n", + filename="node.h", + ).to_dict() + + assert payload["structs"][0]["model"] == "CStruct" + assert payload["structs"][0]["members"][0]["type"]["components"][-1]["model"] == "CStruct" + assert payload["typedefs"][0]["model"] == "CTypedef" + assert payload["typedefs"][0]["type"] == {"reference": "struct node"} + + +def test_model_json_shapes_cover_directive_include_macro_and_diagnostic_fields(): + from c_parser import parse_c_file + + payload = parse_c_file( + '#ifdef FEATURE\n#include "missing.h"\n#define API(ret) ret\nAPI(int) run(void);\n#endif\n', + filename="metadata.h", + ).to_dict() + + assert payload["raw_directives"][0]["directive"] == "ifdef" + assert payload["raw_directives"][0]["argument"] == "FEATURE" + assert payload["includes"][0]["target"] == "missing.h" + assert payload["includes"][0]["resolved_path"] is None + assert payload["macros"][0]["name"] == "API" + assert payload["macros"][0]["function_like"] is True + assert payload["macro_dependencies"][0]["name"] == "API" + assert payload["macro_dependencies"][0]["source_text"] == "API(int) run(void)" + assert {diagnostic["code"] for diagnostic in payload["diagnostics"]} >= { + "C_UNRESOLVED_INCLUDE", + "C_UNSUPPORTED_FUNCTION_LIKE_MACRO", + "C_MACRO_DEPENDENT_DECLARATION", + } + + +def test_unresolved_typedef_reference_metadata_is_preserved_in_json(): + from c_parser import parse_c_file + + payload = parse_c_file("api_size count(void);\n", filename="unresolved.h").to_dict() + + result_type = payload["functions"][0]["result_type"] + assert result_type["model"] == "CTypedef" + assert result_type["name"] == "api_size" + assert result_type["type"] is None + + +def test_public_c_parser_entrypoints_do_not_include_parser_side_readiness(): + import c_parser + + assert hasattr(c_parser, "parse_c_file") + assert hasattr(c_parser, "parse_c_project") + assert not hasattr(c_parser, "assess_c_wrap_readiness") + + +def test_c_parser_instance_entrypoints_match_public_functions(): + from c_parser import CParser, parse_c_file, parse_c_project + + source = "int answer(void);\n" + parser = CParser() + + assert parser.visit_file(source, filename="api.h") == parse_c_file(source, filename="api.h") + assert parser.visit_project({"api.h": source}) == parse_c_project({"api.h": source}) + + +def test_c_parse_error_attributes_and_diagnostic_formatting(): + from c_parser import CParseError + + err = CParseError( + "unexpected token", + filename="bad.h", + line_number=2, + column=5, + source_line="int broken(;", + ) + + assert err.filename == "bad.h" + assert err.line_number == 2 + assert err.column == 5 + assert err.base_message == "unexpected token" + assert err.code == "CPARSE001" + + diagnostic = err.format_diagnostic(color=False, debug=True) + assert "bad.h:2:5: error[CPARSE001]: unexpected token" in diagnostic + assert "2 | int broken(;" in diagnostic + assert "note: parser raised at" in diagnostic + + +def test_c_parse_error_color_and_no_color_formatting(): + from c_parser import CParseError + + err = CParseError( + "unexpected token", + filename="bad.h", + line_number=2, + column=5, + source_line="int broken(;", + ) + + plain = err.format_diagnostic(color=False) + colored = err.format_diagnostic(color=True) + + assert "\x1b[" not in plain + assert "\x1b[" in colored diff --git a/tests/parser/c/test_c_structs_unions_enums_typedefs.py b/tests/parser/c/test_c_structs_unions_enums_typedefs.py new file mode 100644 index 000000000..aa56c04a5 --- /dev/null +++ b/tests/parser/c/test_c_structs_unions_enums_typedefs.py @@ -0,0 +1,298 @@ +# -*- coding: utf-8 -*- +"""C aggregate type, enum, and typedef parser tests.""" + +import pytest + + +def test_named_struct_members_are_variables_in_source_order(): + from c_parser import CArray, CComposedType, CVariable, parse_c_file + + parsed = parse_c_file( + "struct point { double x; double y; double coordinates[2]; };\n", + filename="structs.h", + ) + + point = parsed.structs[0] + assert [member.name for member in point.members] == ["x", "y", "coordinates"] + assert all(isinstance(member, CVariable) for member in point.members) + assert isinstance(point.members[2].type, CComposedType) + assert isinstance(point.members[2].type.components[0], CArray) + assert point.members[2].type.components[0].bound == "2" + + +def test_typedef_struct_alias_refers_to_the_concrete_struct_object(): + from c_parser import parse_c_file + + parsed = parse_c_file( + "typedef struct point { double x; double y; } point_t;\n", + filename="typedef_struct.h", + ) + + assert parsed.structs[0].name == "point" + assert parsed.typedefs[0].name == "point_t" + assert parsed.typedefs[0].type is parsed.structs[0] + + +def test_forward_struct_declaration_is_completed_by_later_definition(): + from c_parser import parse_c_file + + parsed = parse_c_file( + "struct state;\nstruct state { int id; };\n", + filename="complete_struct.h", + ) + + assert [struct.name for struct in parsed.structs] == ["state"] + assert parsed.structs[0].is_incomplete is False + assert parsed.structs[0].members[0].name == "id" + assert parsed.diagnostics == [] + + +def test_duplicate_complete_tag_definitions_report_diagnostics(): + from c_parser import parse_c_file + + parsed = parse_c_file( + "struct state { int id; };\nstruct state { int id; };\n", + filename="duplicate_struct.h", + ) + + assert [struct.name for struct in parsed.structs] == ["state"] + assert any(diag.code == "C_DUPLICATE_TAG_DEFINITION" for diag in parsed.diagnostics) + + +def test_anonymous_struct_typedef_gets_stable_anonymous_id(): + from c_parser import parse_c_file + + parsed = parse_c_file("typedef struct { int code; } result_t;\n", filename="anon_struct.h") + + assert parsed.structs[0].name is None + assert parsed.structs[0].anonymous_id + assert parsed.typedefs[0].type is parsed.structs[0] + + +def test_union_members_are_variables_without_struct_field_class(): + from c_parser import CUnion, CVariable, parse_c_file + + parsed = parse_c_file("union value { int i; double d; };\n", filename="union.h") + + value = parsed.unions[0] + assert isinstance(value, CUnion) + assert [member.name for member in value.members] == ["i", "d"] + assert all(isinstance(member, CVariable) for member in value.members) + + +def test_anonymous_union_typedef_refers_to_the_concrete_union_object(): + from c_parser import CUnion, parse_c_file + + parsed = parse_c_file("typedef union { int i; double d; } value_t;\n", filename="anon_union.h") + + assert isinstance(parsed.unions[0], CUnion) + assert parsed.unions[0].anonymous_id + assert parsed.typedefs[0].type is parsed.unions[0] + + +def test_incomplete_union_and_tag_typedef_aliases_use_concrete_tag_classes(): + from c_parser import CStruct, CUnion, parse_c_file + + parsed = parse_c_file( + "struct handle;\nunion payload;\ntypedef struct handle handle_t;\ntypedef union payload payload_t;\n", + filename="tag_aliases.h", + ) + + assert parsed.structs[0].is_incomplete is True + assert parsed.unions[0].is_incomplete is True + typedefs = {typedef.name: typedef for typedef in parsed.typedefs} + assert isinstance(typedefs["handle_t"].type, CStruct) + assert typedefs["handle_t"].type.name == "handle" + assert isinstance(typedefs["payload_t"].type, CUnion) + assert typedefs["payload_t"].type.name == "payload" + + +def test_enum_constants_preserve_explicit_implicit_and_symbolic_values(): + from c_parser import parse_c_file + + parsed = parse_c_file( + """ +enum status { + STATUS_OK = 0, + STATUS_WARN, + STATUS_ERROR = 10, + STATUS_NEXT = STATUS_ERROR + 1 +}; +""", + filename="enum.h", + ) + + assert [(item.name, item.value) for item in parsed.enums[0].constants] == [ + ("STATUS_OK", "0"), + ("STATUS_WARN", None), + ("STATUS_ERROR", "10"), + ("STATUS_NEXT", "STATUS_ERROR + 1"), + ] + + +def test_typedef_enum_and_trailing_tag_variable_are_separate_objects(): + from c_parser import CEnum, CStruct, parse_c_file + + parsed = parse_c_file( + "typedef enum { FLAG_NONE = 0, FLAG_READ = 1 } flag_t;\nstruct point { int x; } origin;\n", + filename="tag_declarators.h", + ) + + assert parsed.enums[0].anonymous_id + assert isinstance(parsed.typedefs[0].type, CEnum) + assert parsed.typedefs[0].type is parsed.enums[0] + assert parsed.variables[0].name == "origin" + assert isinstance(parsed.variables[0].type, CStruct) + assert parsed.variables[0].type is parsed.structs[0] + + +def test_recursive_struct_pointer_uses_an_incomplete_struct_component_without_cycles(): + from c_parser import CComposedType, CPointer, CStruct, parse_c_file + + parsed = parse_c_file( + "typedef struct node { int value; struct node *next; } node_t;\n", + filename="recursive_struct.h", + ) + + node = parsed.structs[0] + next_type = node.members[1].type + assert isinstance(next_type, CComposedType) + assert isinstance(next_type.components[0], CPointer) + assert isinstance(next_type.components[1], CStruct) + assert next_type.components[1].name == "node" + assert next_type.components[1].is_incomplete is True + + +def test_typedef_chains_preserve_typedef_objects_before_resolution(): + from c_parser import CTypedef, CUnsignedLong, parse_c_file + + parsed = parse_c_file( + "typedef unsigned long size_type;\ntypedef size_type api_size;\napi_size count(void);\n", + filename="typedef_chain.h", + ) + + typedefs = {typedef.name: typedef for typedef in parsed.typedefs} + assert isinstance(typedefs["size_type"].type, CUnsignedLong) + assert isinstance(typedefs["api_size"].type, CTypedef) + assert typedefs["api_size"].type.name == "size_type" + assert isinstance(parsed.functions[0].result_type, CTypedef) + + +def test_struct_members_use_same_components_for_callbacks_arrays_and_bitfields(): + from c_parser import CArray, CFunctionType, CPointer, parse_c_file + + parsed = parse_c_file( + "struct hooks { int (*compare)(const void *, const void *); unsigned enabled : 1; int values[4]; };\n", + filename="members.h", + ) + + compare, enabled, values = parsed.structs[0].members + assert [type(component) for component in compare.type.components] == [CPointer, CFunctionType] + assert compare.callback_candidate is True + assert enabled.bit_width == "1" + assert isinstance(values.type.components[0], CArray) + assert values.type.components[0].bound == "4" + + +def test_struct_members_preserve_precise_locations_and_legal_flexible_array_metadata(): + from c_parser import CArray, parse_c_file + + parsed = parse_c_file( + """struct packet { + unsigned size; + unsigned char data[]; +}; +""", + filename="packet.h", + ) + + size, data = parsed.structs[0].members + assert [(member.source_location.line, member.source_location.column) for member in (size, data)] == [ + (2, 5), + (3, 5), + ] + assert data.source_location.source_line == " unsigned char data[];" + assert isinstance(data.type.components[0], CArray) + assert data.type.components[0].is_flexible is True + assert parsed.diagnostics == [] + + +@pytest.mark.parametrize( + ("source", "owner_name", "message"), + [ + ( + """struct bad { + unsigned char data[]; + int tail; +}; +""", + "structs", + "must be the final member", + ), + ( + """struct bad { + unsigned char data[]; +}; +""", + "structs", + "requires a preceding named struct member", + ), + ( + """union bad { + unsigned char data[]; + int code; +}; +""", + "unions", + "cannot be a flexible array member", + ), + ], +) +def test_invalid_flexible_array_members_are_diagnosed(source, owner_name, message): + from c_parser import parse_c_file + + parsed = parse_c_file(source, filename="invalid_flexible.h") + aggregate = getattr(parsed, owner_name)[0] + data = aggregate.members[0] + + assert data.type.components[0].is_flexible is False + assert [(diagnostic.code, diagnostic.severity) for diagnostic in parsed.diagnostics] == [ + ("C_INVALID_FLEXIBLE_ARRAY_MEMBER", "error"), + ] + assert message in parsed.diagnostics[0].message + assert parsed.diagnostics[0].location.line == 2 + assert parsed.diagnostics[0].unit_name == "data" + + +def test_unnamed_and_zero_width_bitfields_preserve_source_facts_and_locations(): + from c_parser import parse_c_file + + parsed = parse_c_file( + """struct flags { + unsigned : 0; + unsigned mode : 3; +}; +""", + filename="bitfields.h", + ) + + zero_width, mode = parsed.structs[0].members + assert [(member.name, member.bit_width) for member in (zero_width, mode)] == [ + (None, "0"), + ("mode", "3"), + ] + assert [member.source_location.line for member in (zero_width, mode)] == [2, 3] + assert parsed.diagnostics == [] + + +def test_nested_aggregate_member_definition_is_diagnosed_explicitly(): + from c_parser import parse_c_file + + parsed = parse_c_file( + "struct outer { struct { int nested; } inner; int kept; };\n", + filename="nested_member.h", + ) + + assert [member.name for member in parsed.structs[0].members] == ["kept"] + assert parsed.diagnostics[0].code == "C_UNSUPPORTED_FIELD_DECLARATION" + assert parsed.diagnostics[0].unit_kind == "struct_field" diff --git a/tests/semantics/test_c_semantic_readiness.py b/tests/semantics/test_c_semantic_readiness.py new file mode 100644 index 000000000..5cabf6716 --- /dev/null +++ b/tests/semantics/test_c_semantic_readiness.py @@ -0,0 +1,150 @@ +# -*- coding: utf-8 -*- +"""Planned C semantic wrap-readiness tests. + +These tests intentionally live under ``tests/semantics`` because readiness is +owned by semantic IR or edited ``.pyi`` interfaces, not by the C parser. +""" + +import pytest + +pytestmark = pytest.mark.skip( + reason="C semantic readiness roadmap tests; unskip after C semantic IR conversion exists." +) + + +def test_c_semantic_readiness_accepts_plain_primitive_function_signatures(): + from c_parser import parse_c_file + from semantics.c2ir import c_file_to_semantic_modules + from semantics.readiness import assess_semantic_wrap_readiness + + parsed = parse_c_file( + """ +int add(int a, int b); +double scale(double x); +""", + filename="simple.h", + ) + modules = c_file_to_semantic_modules(parsed) + report = assess_semantic_wrap_readiness(modules, source="simple.h") + + assert report["wrappable"] is True + assert report["wrappability_blockers"] == [] + + +def test_c_semantic_readiness_reports_unresolved_typedefs(): + from c_parser import parse_c_file + from semantics.c2ir import c_file_to_semantic_modules + from semantics.readiness import assess_semantic_wrap_readiness + + parsed = parse_c_file("api_size count(void);\n", filename="unresolved_typedef.h") + modules = c_file_to_semantic_modules(parsed) + report = assess_semantic_wrap_readiness(modules, source="unresolved_typedef.h") + + assert report["wrappable"] is False + assert any(blocker["code"] == "unresolved_semantic_types" for blocker in report["wrappability_blockers"]) + + +def test_c_semantic_readiness_reports_macro_dependent_declarations(): + from c_parser import parse_c_file + from semantics.c2ir import c_file_to_semantic_modules + from semantics.readiness import assess_semantic_wrap_readiness + + parsed = parse_c_file( + """ +#define API(ret) ret +API(int) exported(void); +""", + filename="macro_dependent.h", + ) + modules = c_file_to_semantic_modules(parsed) + report = assess_semantic_wrap_readiness(modules, source="macro_dependent.h") + + assert report["wrappable"] is False + assert any(blocker["code"] == "c_macro_dependent_declaration" for blocker in report["wrappability_blockers"]) + + +def test_c_semantic_readiness_reports_variadic_functions_as_blockers(): + from c_parser import parse_c_file + from semantics.c2ir import c_file_to_semantic_modules + from semantics.readiness import assess_semantic_wrap_readiness + + parsed = parse_c_file("int log_msg(const char *fmt, ...);\n", filename="variadic.h") + modules = c_file_to_semantic_modules(parsed) + report = assess_semantic_wrap_readiness(modules, source="variadic.h") + + assert report["wrappable"] is False + assert any(blocker["code"] == "c_variadic_function" for blocker in report["wrappability_blockers"]) + + +def test_c_semantic_readiness_reports_callback_policy_required(): + from c_parser import parse_c_file + from semantics.c2ir import c_file_to_semantic_modules + from semantics.readiness import assess_semantic_wrap_readiness + + parsed = parse_c_file( + "void each_item(void *items, void (*visit)(void *item, void *userdata), void *userdata);\n", + filename="callback.h", + ) + modules = c_file_to_semantic_modules(parsed) + report = assess_semantic_wrap_readiness(modules, source="callback.h") + + assert report["wrappable"] is False + assert any(blocker["code"] == "callback_signature_incomplete" for blocker in report["wrappability_blockers"]) + + +def test_completed_pyi_callback_policy_can_make_c_api_semantically_ready(): + from semantics.pyi_parser import parse_pyi_text + from semantics.readiness import assess_semantic_wrap_readiness + + module = parse_pyi_text( + """ +from typing import Any, Callable + +def each_item( + items: Pointer[Any], + visit: Callable[[Pointer[Any], Pointer[Any]], None], + userdata: Pointer[Any], +) -> None: ... +""", + module_name="callback_api", + ) + + report = assess_semantic_wrap_readiness(module, source="callback_api.pyi") + + assert report["wrappable"] is True + assert report["wrappability_blockers"] == [] + + +def test_c_semantic_readiness_reports_pointer_ownership_ambiguity(): + from c_parser import parse_c_file + from semantics.c2ir import c_file_to_semantic_modules + from semantics.readiness import assess_semantic_wrap_readiness + + parsed = parse_c_file("int read_values(double *values, size_t n);\n", filename="buffers.h") + modules = c_file_to_semantic_modules(parsed) + report = assess_semantic_wrap_readiness(modules, source="buffers.h") + + assert report["wrappable"] is False + assert any(blocker["code"] == "c_pointer_ownership_ambiguous" for blocker in report["wrappability_blockers"]) + + +def test_c_semantic_readiness_aggregates_file_and_function_blockers(): + from c_parser import parse_c_file + from semantics.c2ir import c_file_to_semantic_modules + from semantics.readiness import assess_semantic_wrap_readiness + + parsed = parse_c_file( + """ +unknown_t make_unknown(void); +int log_msg(const char *fmt, ...); +""", + filename="mixed_blockers.h", + ) + modules = c_file_to_semantic_modules(parsed) + report = assess_semantic_wrap_readiness(modules, source="mixed_blockers.h") + + assert report["wrappable"] is False + assert {blocker["code"] for blocker in report["wrappability_blockers"]} >= { + "unresolved_semantic_types", + "c_variadic_function", + } diff --git a/x2py/cli.py b/x2py/cli.py index 82dac6185..f18d9f056 100644 --- a/x2py/cli.py +++ b/x2py/cli.py @@ -7,6 +7,8 @@ from dataclasses import asdict, fields, is_dataclass from pathlib import Path +from c_parser.cli import format_c_report, parse_c_report +from c_parser.models import CParseError from fortran_parser.models import FortranParseError from fortran_parser.parser import FortranParser from fortran_parser.cli import _format_report @@ -242,6 +244,8 @@ def main() -> int: " python -m x2py path/to/src_dir --parse --print-limit 20\n" " Print parser JSON:\n" " python -m x2py path/to/file.f90 --parse --json\n" + " Parse C subset JSON:\n" + " python -m x2py path/to/api.h --language c --parse --json\n" " Write parser JSON:\n" " python -m x2py path/to/file.f90 --parse --json --out report.json\n" " Write one JSON file next to each source:\n" @@ -265,7 +269,13 @@ def main() -> int: " pip install rich" ), ) - parser.add_argument("paths", nargs="+", help="Fortran source file(s), .pyi file(s), or directory path(s)") + parser.add_argument("paths", nargs="+", help="Source file(s), .pyi file(s), or directory path(s)") + parser.add_argument( + "--language", + choices=("fortran", "c"), + default="fortran", + help="Frontend language. Defaults to fortran; C currently supports partial --parse output.", + ) parser.add_argument("--parse", action="store_true", help="Run and output parser stage report") parser.add_argument( "--show-vars", @@ -297,6 +307,18 @@ def main() -> int: parser.add_argument("--debug-traceback", action="store_true", help="Re-raise parser errors for debug") args = parser.parse_args() + if args.language == "c": + if not (args.parse or args.semantics or args.pyi or args.wrap_readiness): + parser.error("--language c requires --parse; C semantics and .pyi output are not supported yet") + if args.semantics: + parser.error("--semantics is not supported for --language c yet") + if args.pyi: + parser.error("--pyi is not supported for --language c yet") + if args.wrap_readiness: + parser.error("--wrap-readiness is semantic-layer output and is not supported for --language c yet") + if args.show_vars or args.print_limit is not None or args.vars_limit is not None: + parser.error("--show-vars/--print-limit are Fortran-only and are not supported for --language c") + if args.out is not None and not (args.parse or args.semantics or args.pyi or args.wrap_readiness): parser.error("--out requires a stage flag: choose one of --parse, --semantics, --pyi, or --wrap-readiness") @@ -311,10 +333,19 @@ def main() -> int: parser.error("Select at least one stage flag: --parse, --semantics, --pyi, or --wrap-readiness") try: - parse_payload = _parse_report(args.paths) if args.parse else None + parse_payload = ( + parse_c_report(args.paths) + if args.parse and args.language == "c" + else _parse_report(args.paths) if args.parse else None + ) semantic_payload = _semantic_report(args.paths) if (args.semantics or args.pyi) else None readiness_payload = _wrap_readiness_report(args.paths) if args.wrap_readiness else None _attach_wrap_readiness(semantic_payload, readiness_payload) + except CParseError as exc: + if args.debug_traceback or _env_flag("C_PARSER_DEBUG"): + raise + print(exc.format_diagnostic(color=_diagnostic_color_enabled(disabled=args.no_color), debug=False), file=sys.stderr) + return 1 except FortranParseError as exc: if args.debug_traceback or _env_flag("FORTRAN_PARSER_DEBUG"): raise @@ -378,7 +409,10 @@ def main() -> int: elif args.pyi and not args.json: print_pyi_output(_format_pyi_report(semantic_payload or {})) elif args.parse and not (args.semantics or args.json or args.pyi): - print(_format_report(parse_payload or {}, show_vars=args.show_vars or args.vars_limit is not None, print_limit=print_limit)) + if args.language == "c": + print(format_c_report(parse_payload or {})) + else: + print(_format_report(parse_payload or {}, show_vars=args.show_vars or args.vars_limit is not None, print_limit=print_limit)) else: print(json.dumps(payload, indent=2))